---

一、前言

  在Python中，类表示具有相同属性和方法的对象的集合。在使用类时，需要先定义类，然后再创建类的实例，通过类的实例就可以访问类中的属性和方法了。

---

二、定义类

  在Python中，类的定义使用class关键字来实现，语法如下：

class ClassName：
	“”“类的帮助信息”“”     # 类文本字符串
	statement            # 类体

参数说明：

• ClassName：用于指定类名，一般使用大写字母开头，如果类名中包括个词，第二个单词的首字母也要大写，这种命名方法也称为“驼峰式命名法”，这是惯例。当然，也可以根据自己的习惯命名，但是一般推荐按照惯例来命名。
• “类的帮助信息”：用于指定类的文档字符串。定义该字符串后，在创建类的对象时，输入类名和左侧的括号“（ ” 后，将显示信息。
• statement：类体，主要由类变量（或类成员）、方法和属性等定义语句组成。如果在定义类时，没有想好类的具体功能，也可以在类体中直接使用Pass语句代替。

class Geese:
	"""大雁类"""
	pass

---

三、创建类的实例

  定义完成后，并不会真正创建一个实例。这就好比一个汽车的设计图。设计图可以告诉你汽车看上去怎么样，但设计图本身不是一个汽车。你不能开走它，它只能用来建造真正的汽车，而且可以使用它制造很多汽车。那么如何创建实例呢？

  class语句本身并不创建该类的任何实例。所以在类定义完成以后，可以创建类的实例，即实例化该类的对象。创建类的实例的语法如下：

ClassName(parameterlist)

参数说明：

• ClassName：是必选参数，用于指定类。
• parameterlist：可以选参数，当创建一个类时，没有创建__init__()方法，或者当__init__()方法只有一个self参数时， parameterlist可以省略。

  例如，创建上面Geese类的实例，可以使用下面代码：

# 创建类
class Geese:
    """大雁类"""
    pass


# 创建实例
wildGoose = Geese()
print(wildGoose)

  执行上面代码后，将显示类似下面的内容：

  从上面的执行结果中可以看出，wildGoose是Geese类的实例。

---

四、“魔术”方法——_ init _()

  在创建类后，类通常会自动创建一个__init__()方法。该方法是一个特殊的方法，类似JAVA 语言中的构造方法。每当创建一个类的新实例时，Python都会自动执行它。init()方法必须包含一个参数，并且必须是第一参数。self参数是一个指向实例本身的引用，用于访问类中的属性和方法。
在方法调用时会自动传递实际参数self。因此，当__init__()方法只有一个参数时，在创建类的实例时，就不需要指定参数了。

---

  例如，下面乃然以大雁为例，并创建__init__()方法，代码如下：

# 创建类
class Geese:
    """大雁类"""

    def __init__(self):
        print("我是大雁类")

wildGoose = Geese()

  运行以上代码，将输出以下内容：

---

  常见错误
  在为类创建__init__()方法时，在开发环境中运行下面的代码：

# 创建类
class Geese:
    """大雁类"""

    def __init__():             # 构建方法
        print("我是大雁类")


wildGoose = Geese()				# 创建大雁实例

  运行上述代码，将抛出以下异常：

---

  在__init__()方法中，除了self参数外，还可以自定义一些参数，参数间使用逗号“,”进行分隔。例如，下面的代码将在创建__init__()方法时，再指定3个参数，分别是beak、wing和claw：

# 创建类
class Geese:
    """大雁类"""

    def __init__(self, beak, wing, claw):
        print("我是大雁类!我有一下特征：")
        print(beak)
        print(wing)
        print(claw)

beak_1 = "喙"
wing_1 = "翅膀"
claw_1 = "爪"
wildGoose = Geese(beak_1, wing_1, claw_1)

  运行上面代码，将显示以下结果：

---

五、创建类的成员并访问

  类的成员主要由实例方法和数据成员组成。在类中创建了类的成员后，可以通过类的实例进行访问。下面进行详细介绍。

---

1.创建实例方法并访问

  所谓实例方法是指在类中定义函数。该函数是一种在类的实例上操作的函数。同__init__()方法一样，实例方法的第一参数必须是self，并且必须包含一个self参数。创建实例的方法的语法格式如下：

def functionName(self,parameterlist):
	block

参数说明：

• functionName：用于指定方法名，一般使用小写字母开头。
• self：必要参数，表示类的实例，其名称可以是self以外的单词，使用self只是一个习惯而已。
• parameterlist：用于指定除self参数以外的参数，各参数间使用逗号“,”进行分隔。
• block：方法体，实现的具体功能

---

  实例创建完成后，可以通过类的实例名称和点(.)操作符进行访问。具体的语法格式如下：

instanceName.functionName(parametervalue)

参数说明：

• instanceName：为类的实例名称
• functionName：为要调用的方法名称
• parametervalue：表示为方法指定对应的实际参数，其值的个数与创建实例方法中parameterlist的个数相同。

---

2.创建数据成员并访问

  数据成员是指类中定义的变量，即属性，根据定义位置，又可以分为类属性和实例属性，下面分别进行介绍。

---

• 类属性
    类属性是指在定义类中，并且在函数体外的属性。类属性可以在类的所有实例之间共享值，也就是在所有实例化的对象中公用。

---

  例如，定义一个雁类，在该类中定义3个属性，用于记录雁的特征，代码如下：

class Geese:
    """大雁类"""
    beak_1 = "喙，比较尖"  # 定义类属性（喙）
    wing_1 = "翅膀，比较大" 
    claw_1 = "爪，行走自如"

    def __init__(self):
        print("我是大雁类!我有一下特征：")
        print(Geese.beak_1)   # 输出喙的属性
        print(Geese.wing_1)
        print(Geese.claw_1)

  创建上面的类Geese，然后创建类的实例，代码如下：

goose = Geese()  # 实例化一个雁的对象

  运行上面代码创建Geese类的实例后，将显示以下内容：

---

• 实例属性

  实例属性是指定义在类的方法中的属性，只作用于当前实例中。

  例如，定义一个雁类Geese，在该类的__init__()方法中定义3个实例属性，用于记录雁类的特征，代码如下：

# 创建类
class Geese:
    """大雁类"""
    def __init__(self):
        self.beak_1 = "喙，比较尖"  # 定义实例属性（喙）
        self.wing_1 = "翅膀，比较大"
        self.claw_1 = "爪，行走自如"
        print("我是大雁类!我有一下特征：")
        print(self.beak_1)   # 输出喙的属性
        print(self.wing_1)
        print(self.claw_1)

  创建上面的类Geese，然后创建类的实例，代码如下：

goose = Geese()  # 实例化一个雁的对象

  运行上面代码创建Geese类的实例后，将显示以下内容：

• 说明：

  实例属性只能通过实例名访问。如果通过类名访问实例属性，将抛出如图所示的异常。

---

  对于实例的属性也可以通过实例名称修改，与类不同，通过实例名称修改实例属性后，并不能影响该类的其他实例中相应的实例属性值。例如，定义一个雁类，并在__init__()方法中定义一个实例属性，然后创建两个Geese类的实例，并修改一个实例属性，最后分别输出实例属性，代码如下：

# 创建类
class Geese:
    """大雁类"""

    def __init__(self):
        self.beak_1 = "喙，比较尖"  # 定义实例属性（喙）
        print(self.beak_1)


goose1 = Geese()  # 创建Geese实例1
goose2 = Geese()  # 创建Geese实例2
goose1.beak_1 = "喙，比长鹅尖"  # 修改实例属性
print("goose1的beak_1属性：", goose1.beak_1)
print("goose2的beak_1属性：", goose2.beak_1)

  运行上面代码，将显示以下内容：

---

六、访问限制

  在类的内部可以定义属性和方法，而在类的外部则可以直接调用属性或方法来操作数据，从而隐藏了类内部的复杂逻辑。但Python并没有对属性和方法的访问权限进行限制。为了保证类内部的某些属性或方法不被外部所访问，可以在属性或方法名前面添加单下划线（_foo）、双下划线（__foo）或者首尾加双下划线（ __ foo __）,从而限制访问权限。其中，单下划线、双下划线、首尾双下划线的作用如下：

• __ foo __ ：首尾双下划线表示定义特殊方法，一般是系统定于名字，如__init__()。
• _foo：以单下划线开头的表示protected（保护）类型的成员，只允许类本身或子类访问，但不能使用“ from module impor”语句导入。

---

  例如，创建一个Swan类，定义保护属性_neck_swan,并在__init__()方法中访问该属性，然后创建Swan类的实例，并通过实例名输出保护属性_neck_swan，代码如下：

class Swan:
    """天鹅类"""
    _neck_swan = "天鹅脖子长"  # 创建私有属性

    def __init__(self):
        print("__init__():", Swan._neck_swan)


swan = Swan()  # 创建Swan类
print("直接访问：", swan._neck_swan)

  执行以上代码，将显示以下内容：

   从上面的运行结果中可以看出：保护属性可以通过实例名访问。

---

• __foo：双下划线表示private（私有）类型的成员，只允许定义该方法的类本身进行访问，而且也不能通过类的实例进行访问，但是可以通过“类的实例名.类名 __xxx”方式访问。

  例如，创建一个Swan类，定义保护属性__neck_swan,并在__init__()方法中访问该属性，然后创建Swan类的实例，并通过实例名输出保护属性__neck_swan，代码如下：

class Swan:
    """天鹅类"""
    __neck_swan = "天鹅脖子长"  # 创建私有属性

    def __init__(self):
        print("__init__():", Swan.__neck_swan)


swan = Swan()  # 创建Swan类
print("加入类名：", swan._Swan__neck_swan)
print("直接访问：", swan.__neck_swan)

  运行上面代码，将输出如图所示的结果：

  从上面的运行结果可以看出：私有属性可以通过“类名.属性名”方式访问，也可以通过“实例名.类名__xxx”方式访问，但是不能直接通过“实例名.属性名”方式访问。

---

 

由于 Python 对面向对象有着良好的支持，因此在 Python 中定义和使用类并不复杂。类的定义和使用跟函数的定义和使用有很多相似之处。

一、类的定义

在 Python 中，类的定义与函数的定义类似，所不同的是，类的定义是使用关键字 "class"。与函数定义相同的是，在定义类时也要使用缩进的形式，以表示缩进的语句属于该类。类的定义形式如下。

class <类名>:
    <语句1>
    <语句2>
    ...
    <语句3>

与函数定义相同，在使用类之前必须先定义类。类的定义一般放在脚本的头部。在 Python 中也可以在 if 语句的分支或者函数定义中定义类。下面的代码定义了一个 human 类，并定义了相关的属性。

class human:    # 定义 human 类
    age = 0     # 定义 age 属性
    sex = ''    # 定义 sex 属性
    height = 0  # 定义 height 属性
    weight = 0  # 定义 weight 属性
    name = ''   # 定义 name 属性

类还可以通过继承的形式来进行定义。通过类继承来定义类的基本形式如下。

class <类名>(父类名):
    <语句1>
    <语句2>
    ...
    <语句3>

其中圆括号中的父类名就是要继承的类。以下所示的代码是通过继承 human 类来生成一个新类。

class student(human):    # 通过继承 human 类创建 student 类
    school = ''          # 定义 weight 属性
    number = 0           # 定义 weight 属性
    grade = 0            # 定义 weight 属性

上述通过 human 继承而来的 student 类，自动继承了 human 中的属性。同时在上面的代码中又为 student 类定义了其他的属性。

类定义后就产生了一个名字空间，与函数类似。在类内部使用的属性，相当于函数中的变量名，还可以在类的外部继续使用。类的内部与函数的内部一样，相当于一个局部作用域。不同类的内部也可以使用相同的属性名。

二、类的使用

类在定义后必须先实例化才能使用。类的实例化与函数调用类似，只要使用类名加圆括号的形式就可以实例化一个类。

类实例化后会生成一个对象。一个类可以实例化成多个对象，对象与对象之间并不会相互影响。类实例化后就可以使用其属性和方法等。下面的代码首先定义了一个 book 类，然后将其实例化。

class book:  # 定义 book 类
    author = ''  # 定义 author 属性
    name = ''  # 定义 name 属性
    pages = 0  # 定义 pages 属性
    price = 0  # 定义 price 属性
    press = ''  # 定义 press 属性


a = book()  # book 类实例化
print(a)  # 查看对象 a
print(a.author)  # 访问 author 属性
print(a.pages)  # 访问 pages 属性
print(a.price)  # 访问 price 属性

a.author = 'Tutu'  # 设置 author 属性
a.pages = 300  # 设置 pages 属性
a.price = 25  # 设置 price 属性
print(a.author)  # 重新访问 author 属性
print(a.pages)  # 重新访问 pages 属性
print(a.price)  # 重新访问 price 属性

b = book()  # 将 book 类实例化生成 b 对象
print(b.author)  # 访问 b 对象的 author 属性
print(b.price)  # 访问 b 对象的 price 属性
b.author = 'Butter'  # 设置 b 对象的 author 属性
b.price = 15  # 设置 b 对象的 price 属性

print(b.price)  # 访问 b 对象的 price 属性
print(a.price)  # 访问 a 对象的 price 属性，没有发生改变
print(b.author)  # 访问 b 对象的 author 属性
print(a.author)  # 访问 a 对象的 author 属性，没有发生改变
print(b.pages)  # 访问 b 对象的 pages 属性
print(a.pages)  # 访问 a 对象的 pages 属性

上面的脚本输出结果如下：

上述例子只定义了类的属性，并在类实例化后重新设置其属性。从代码中可以看出，类的实例化相当于调用一个函数，这个函数就是类。函数返回一个类的实例对象，返回后的对象就具有了类所定义的属性。上述例子生成了两个 book 实例对象，设置其中一个对象的属性，并不会影响到另一个对象的属性，也就是说，这两个对象是相互独立的。

在 Python 中需要注意的是，虽然类首先需要实例化，然后才能使用其属性。但实际上当创建一个类以后就可以通过该类名访问其属性。如果直接使用类名修改其属性，那么将影响已经通过该类实例化的其他对象。演示代码如下。

class A:            # 定义类 A
    name = 'A'      # 定义属性 name 将其赋值为 'A'
    num = 2         # 定义 num 属性将其赋值为 2


print(A.name)       # 直接使用类名访问类的属性
print(A.num)        # 直接使用类名访问类的属性

a = A()             # 生成 a 对象
print(A.name)       # 查看 a 的 name 属性

b = A()             # 生成 b 对象
print(b.name)       # 查看 b 的 name 属性

A.name = 'B'        # 使用类名修改 name 属性
print(a.name)       # a 对象的 name 属性被修改
print(b.name)       # b 对象的 name 属性也被修改

每一次的 print 输出如下：

 1.什么是枚举用enum修饰是一种特殊的类，但枚举是类，使用枚举可以很方便的定义常量 

枚举的概念:枚举类是一种特殊形式的Java类，枚举类的对象个数是有限且明确的

为什么需要枚举:
因为一些方法在运行时，它需要的数据不能是任意的，而必须是一定范围内的值

自定义枚举类

package cn.tedu.exec;
/*
 JDK1.8之前 枚举类定义和使用
 */

//自定义枚举
 class Season {
     /*
     1.枚举类中声明的每一个枚举值代表枚举类的一个实例对象
     2.与Java中的普通类一样在声明枚举类时也可以声明属性方法和构造函数
     3.但是枚举类的构造函数必须为私有的
     4.枚举都必须要大写
      */
    //1.私有化常量类型
    private final String SEASON_NAME;
    private final String SEASON_DEAE;

    //2.私有化形参构造器
    private Season(String SEASON_NAME, String SEASON_DEAE) {
        this.SEASON_NAME = SEASON_NAME;
        this.SEASON_DEAE = SEASON_DEAE;
    }

    //3.公共静态常量创建对象
    public static  final Season SPRING=new Season("春天","春暖花开");
    public static  final Season SUMMER=new Season("夏天","夏日炎炎");
    public static  final Season AUTUMM=new Season("秋天","秋高气爽");
    public static  final Season WINTER=new Season("冬天天","寒风凛凛");

    //4.提供get方法
    public String getSEASON_NAME() {
        return SEASON_NAME;
    }

    public String getSEASON_DEAE() {
        return SEASON_DEAE;
    }

    //5.重写toString方法
    @Override
    public String toString() {
        return "Season{" +
                "SEASON_NAME='" + SEASON_NAME + '\'' +
                ", SEASON_DEAE='" + SEASON_DEAE + '\'' +
                '}';
    }
}
class  SeasonTest {
    public static void main(String[] args) {
       //1.打印通过类名调用对象获取get方法
        System.out.println(Season.SPRING.getSEASON_NAME());
        System.out.println(Season.SUMMER.getSEASON_NAME());
       //2.使用类名调用对象获取toString
        System.out.println(Season.AUTUMM);
    }
}

使用枚举enum实现枚举类

package cn.tedu.exec;

import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;
import org.w3c.dom.ls.LSOutput;

/*
    JDK1.8之后使用定义枚举和使用
 */
//使用enum关键字定义枚举类
enum Food{
    /*
    1.public static final可以省略不写
    2.枚举对象不能像自定义枚举类对象时new
    3.枚举名1(值1,值2),枚举名2(值1,值2),枚举名3(值1,值2);
    4.不需要生成toString,因为使用enum关键字定义的枚举类继承了java.lang.Enum
    5.在Enum中重写了继承自Object的toString()直接打印的就是枚举名
     */
        //1.通过枚举名传形参
        HAMBURG("汉堡","又大又扁"),
        BEEF("牛肉","肉质柔软"),
        MUTTON("羊肉 ","烹调的香味");
        //2.私有化常量类型
        private  final String FOOD_NAME;
        private  final String FOOD_DESE;
        //3.提供枚举形参构造器
    Food(String FOOD_NAME, String FOOD_DESE) {
        this.FOOD_NAME = FOOD_NAME;
        this.FOOD_DESE = FOOD_DESE;
    }
    //4.提供get方法
    public String getFOOD_NAME() {
        return FOOD_NAME;
    }
    public String getFOOD_DESE() {
        return FOOD_DESE;
    }
}
/*
食物测试类
 */
class  TestFood{
    public static void main(String[] args) {
        //1.通过枚举类调用枚举名获取类型名
        System.out.println(Food.HAMBURG.getFOOD_NAME());
        System.out.println(Food.BEEF.getFOOD_NAME());
        System.out.println(Food.MUTTON.getFOOD_NAME());
        //2.通过枚举类调用枚举名获取类型描述
        System.out.println(Food.HAMBURG.getFOOD_DESE());
        System.out.println(Food.BEEF.getFOOD_DESE());
        System.out.println(Food.MUTTON.getFOOD_DESE());
    }
}

总结新的知识点:

枚举的作用分为 
1.限定用户输入的值，保证安全,有效性2.快速找到所需要的值
枚举的本质:整型的字面值，效率高 3.枚举类型更规范，在函数形参定义为枚举类型的时候，
4.只接受枚举类型的常量，比起普通的更安全，5.枚举类型成员默认被public static final修饰

使用枚举类的好处
 1.提高代码的维护性，确保变量合法 2.提高代码可读性 3.提高代码键入

枚举类的底层实现
枚举类在后台实现时，实际上是转化为一个继承了java.lang.Enum类的实体类，
原先的枚举类型变成对应的实体类型，
并且会生成一个新的构造函数，若原来有构造函数，
则在此基础上添加两个参数，生成新的构造函数

枚举类是线程安全的 为什么是线程安全的 
1.我们定义的一个枚举，在第一次被真正用到的时候，
会被虚拟机加载并初始化，而这个初始化过程是线程安全的。而我们知道，解决单例的并发问题，
主要解决的就是初始化过程中的线程安全问题 2.由于枚举的以上特性，枚举实现的单例是天生线程安全的

枚举类的特点:
1.所有的枚举类都是Enum的子类 2.我们可以通过枚举类名 枚举项名称 去访问指定的枚举项
3.每个枚举类项其实就是该枚举的一个对象 4.枚举也是一个类，也可以去定义一个成员变量
5.枚举类的第一行上必须是枚举项 最后一个枚举项后的分后是可以省略的 但是如果枚举类有其他的东西
这个分号就不能省略 建议不要省略
6.枚举类可以有构造器和构造函数 但必须是private的 它默认的也是private的 枚举项的用法比较特殊 
枚举("");
7.枚举类也可以有抽象方法 但是枚举项必须重写该方法