一 复习

1.什么是类，什么是对象
类就是拥有相同功能和相同属性的对象的集合
对象就是类的实例

2.类的申明
class 类的名字：
    类的说明文档
    类的属性（字段，对象属性）
    类中的方法（对象方法，类方法，静态方法）

3.创建对象
类（）

4.对象方法
a.怎么声明：直接声明在类中的函数
b.特点：自带self参数，通过对象调用不用传参，系统会将当前对象传给self
c.怎么调用：通过对象来调用

5.init方法和构造方法

6.属性
1）字段：
a.怎么定义：直接声明在类中的变量
b.怎么使用：通过类的使用（类.字段）
c.什么时候用：如果属性值不会因为对象不同而不一样


2）对象属性
a.怎么定义：声明在init方法中，以‘self.属性=值’
b.怎么使用：通过对象使用
c.什么时候用：如果属性值会因为对象不同而不一样

3）对象属性的增删改查

4）内置类属性



注意：如果字段设置__slots__的值，那么当前类的对象就不能再使用__dict__



定制，单独打印对象的时候的样式。返回值是什么就打印什么（要求返回值必须是字符串）
def __str__(self):
    return str(self.__dict__)

定制，打印对象的时候的样式。返回值是什么就打印什么
def __repr__(self):
    return str(self.__dict__)

二 类的私有化

本质上，python中所有的属性和方法都是公开的，在类的外部可以使用，也可以被继承。

1.私有化 ----让属性和方法只能在类的内部使用，不能在类的外部使用

• 1）语法：
  声明属性或者方法的时候，在属性名或者方法名前加'__'

• 2)python
  私有化的原理
  python并不能像其他语言一样从访问权限上去限制属性和方法，没有真正的私有化属性和方法。
  私有化只是在两个下划线开头的名字前加前缀'_类名'，导致不能直接通过原名进行访问。

class Person:
    __num = 20

    def __init__(self,name,age=0):
        self.name = name
        self.age = age

    def eat(self,food='米饭'):
        print(Person.__num)
        print('%s在吃%s'%(self.name,food))


p1= Person('小明')
# print(Person.num)

p1.eat()
print(p1.eat())

2.对象属性的保护：不要直接访问或者修改对象属性的值，而是通过属性访问器（getter）和修改器（setter）去操作对象属性

• 需要添加getter或者setter的对象属性，属性命名的时候需要在最前面加'_'（添加的目的是为了告诉使用者，这个属性我给他添加了getter或者setter）

• 1)getter --- 获取属性的值（间接）
  语法：

@property
def 函数名（self）：
    其他语句
    return 属性值

说明：
函数名    ---  对应的属性名去掉下划线
属性值    ---  对应的有下划线的属性值有关联

什么时候用
如果希望在获取某个属性的值之前干点别的是，就给这个属性添加getter

• 2）setter --- 给属性赋值（间接）
  想要添加setter必须要有getter

@getter名.setter
def 函数名（self，参数）：
    其他语句
    self.属性=值

什么时候用:
如果在给属性赋值前想要做点其他事，就给这个属性添加setter

class Student:
    def __init__(self,name,age):
        self._name = name
        self._age = age
    @property
    def name(self):
        return self._name



    @property
    def age(self):
        return self._age
    @age.setter
    def age(self,value):
        if isinstance(value,int):
            if value<0 or value>100:
                print('年龄只能在0到100')
            else:
                self._age=0

s1 = Student('xiaohog',1)
print(s1.name)

练习：声明矩形类，有属性长、宽、周长、面积。

要求修改长、宽的值得时候，周长和面积自动变化，

并且不能直接给周长、面积赋值（如果主动给周长面积赋值，程序直接报错）

class Rectangle:
    def __init__(self,length,width):
        self._length = length
        self._width = width
        self._area =length* width
        self._per = (length+width)*2

   # length
    @property
    def length(self):
        return self._length
    @length.setter
    def length(self,value):
        self._length = value
        self._area = self._length * self._width
        self._per = (self._width+self._length)*2

    # width
    @property
    def width(self):
        return self._width
    @width.setter
    def width(self,value):
        self._width = value
        self._area = self._length * self._width
        self._per = (self._width + self._length) * 2


    # area
    @property
    def area(self):
        return self._area
    @area.setter
    def area(self,value):
        raise ValueError

    # per
    @ property
    def per(self):
        return self._per
    @per.setter
    def per(self,value):
        raise ValueError

三 类中的方法

1.类中的方法：对象方法 、类方法、静态方法

• 1）对象方法
  怎么声明：直接声明在类中
  特点：自带一个默认参数self；调用不用传参，指向当前对象
  怎么调用：通过对象调用（对象.对象方法（））
  什么时候用：如果实现函数的功能，需要使用对象属性，就用对象方法

• 2）类方法
  怎么声明：声明函数前添加@classmethod装饰器
  特点：有默认参数cls;调用时不用传参，系统将调用的这个方法的类传给他，指向当前类
  怎么调用：通过类调用
  什么时候用：在不需要对象属性的前提下，需要类的字段，就用类方法

• 3）静态方法
  怎么声明：声明前添加@staticmethod装饰器
  特点：没有默认参数
  怎么调用：通过类来调用
  什么时候用：即不需要对象属性也不需要类的字段，就用静态方法

class Person:
    num = 30
    def __init__(self,name='xiao ',age=1):
        self.name = name
        self.age = age

    #对象方法


    # 类方法
    @classmethod
    def show_count(cls):
        # cls ：当前类，当前类能做的，cls都能做
        print('类方法')
        print(cls.num)

        p=cls()  # 创建类



     # 静态方法
    @staticmethod
    def static():
        print('静态方法')

p1= Person('xiaoming',1)
print(p1.show_count())

Person.show_count()

Person.static()

四 继承

继承者 --- 子类
被继承者 --- 父类
继承 ---就是子类直接拥有父类的属性和方法

1)语法
class 类名（父类）：
    类的内容

1.在子类中添加内容

• 1）在子类中添加字段和方法
  直接在子类中声明新的字段和方法
• 2）添加对象属性
  在子类中实现init方法，并且添加新的属性。同时需要通过super（）.init（）取调用父类的init方法

补充：类中的函数的调用过程
先看当前类中是否有这个方法，如果有直接调用自己的方法；
没有就去看父类有没有这个方法，如果没有就调用父类的方法
如果父类也没有就找父类的父类，以此类推，如果找到object都没有这个方法，就报错

2.重写

在子类中重新实现父类的函数；可以通过super（）去掉用父类中的方法。
注意：super（）不能再静态方法中使用，只能在对象和类方法中使用

python中所有的类都是默认继承object，object是python中所有类的基类

class Person:
    num = 40

    def __init__(self):
        self.name = 'lisi'
        self.age = 0
        self.gender = '女'

    def eat(self,food):
        print('%s在吃%s'%(self.name,food))

    def run(self):
        print('ao')


class Student(Person):
    # 添加字段和方法
    num = 100
    id_pre= 'stu'

    @staticmethod
    def study():
        print('good good study,day day up')

    # 添加对象属性
    def __init__(self):
        # 调用当前类的父类的__init__方法
        super().__init__()
        self.stu_id = '007'
        self.score = 9

    # 重写方法
    @classmethod
    def run(cls):
        super().run()
        print('aas')


print(Student.num)
stu = Student()
print(stu.name)