面向对象编程

一，面向对象

1.什么是类(抽象)

对拥有相同属性和方法的对象的封装，类中相同的属性的值是不确定的。

2.什么是对象(具体)

对象就是类的实例，对象的属性是确定的。

3.编程的方式

• 面向过程编程：一步一步写代码实现功能--->工具：逻辑和算法
• 函数式编程：面对问题考虑有没有拥有某种功能的函数--->工具：函数
• 面向对象编程：面对问题直接考虑是否有相应的对象来解决这个问题--->工具：类和对象

二，类

1.类的声明

结构：

class 类名：
  属性
  方法

• class :python中声明类的关键字
• 类名：标识符，类名的首字母大写，驼峰式命名
• ():类如果要继承自其他类，需要写括号，括号里面父类的名字。
• 属性：对象属性和类的字段----->保存数据
• 方法：实质就是声明在类中的函数----->实现类的功能

2.创建对象

a.通过类的构造方法去创建对象(名字和类名同名的方法，自动生成的)

对象名 = 类名()

b.类的对象，可以使用点方法去使用类中的方法和属性

对象.方法名() 或 对象.属性名

3.self参数

对象方法都有一个默认参数self，在调用这个方法的时候不需要给这个参数传参(系统会自动给这个参数传参)，谁来调用这个方法，self就是谁

代码实现：

# 1.声明Person类
class Person:
    """
    类的说明：人类
    """
    # 生命两个对象方法，需要使用对象来调用
    def eat(self):
        print('在吃饭')

    def sleep(self):
        print('在睡觉')

if __name__ == "__main__":
    # 声明对象
    p1 = Person()
    print(p1)
    # 一个类可以有多个对象
    p2 = Person()
    print(p2)

    # 对象可以调用对象方法
    p1.eat()
    p2.eat()

    p1.sleep()
    p2.sleep()

输出结果：

<__main__.Person object at 0x00000221D2AA00F0>
<__main__.Person object at 0x00000221D2AA0160>
在吃饭
在吃饭
在睡觉
在睡觉

三，对象的属性

1.对象属性的声明

class 类名：
    def __init__(self):
        self.属性 = 初值
        self.属性2 = 初值

2.init方法

• init方法是系统自带的方法，这个方法不能直接调用，而是通过类创建对象的时候，系统会自动调用这个方法
• init方法的作用是对对象的属性进行初始化
• 通过构造方法创建对象的时候，一定要保证init方法中除了self以外，其他每个参数都必须有值
  代码实现：

class Person:
    def __init__(self, name1='', age1=0, sex='女'):
        # 在这个地方声明对象的属性
        print('=====')
        print(name1)
        print(sex)
        # 在init方法中声明对象的属性
        self.name = name1
        self.age = age1
        self.sex = sex

if __name__ == "__main__":
    # 构造方法中的参数实际上是传递给init方法中的参数
    p1 = Person('chen', 18)
    # 通过对象使用对象属性
    print(p1.name)
    print(p1.age)
    print(p1.sex)

    # 创建对象的时候不给属性赋值
    p3 = Person()
    p3 = Person('CHEN', sex='男')
    p3 = Person(sex='男')

输出结果：

=====
chen
女
chen
18
女
=====

女
=====
CHEN
男
=====

男

四，对象属性的增删查改

1.查，获取对象的属性

方法一：对象.属性（当获取的属性不存在时会报错）
方法二：对象.getattribute(属性名)和 getattr(对象, 属性名, 默认值)

2.改，修改属性的值

方法一：对象.属性 = 新值
方法二：对象.setattr(属性, 新值) 和 setattr(对象, 属性名, 新值)

3.增，增加对象属性

对象.属性(这个属性之前不存在)

注意：这个属性是添加给对象的，而不是类！！！

4.删，删除对象属性

del 对象.属性

注意：删除的是对象的属性，不会影响这个类的其他对象

代码实现：

"""---chen---"""


class Dog:
    """狗类"""
    def __init__(self, age1=0, color1='red'):
        self.age = age1
        self.color = color1



if __name__ == "__main__":
    dog1 = Dog(age1=2, color1='white')
    # 1.查，获取属性
    """
    方法一：对象.属性(查找的时候如果属性不存在，会报错)
    方法二：对象.__getattribute__(属性名)和 getattr(对象, 属性名, 默认值)
    """
    print(dog1.age, dog1.color)
    print(dog1.__getattribute__('age'))
    print(getattr(dog1, 'age'))
    # 如果设置了default的值，那么当属性不存在的时候不会报错，并且返回默认值
    print(getattr(dog1, 'abc', None))

    # 2.改，修改属性的值
    """
    方法一：对象.属性 = 新值
    方法二：对象.__setattr__(属性, 新值) 和 setattr(对象, 属性名, 新值)
    """
    dog1.age = 3
    print(dog1.age)

    dog1.__setattr__('color', 'black')
    print(dog1.color)

    setattr(dog1, 'color', 'blue')
    print(dog1.color)


    # 3.增，增加对象属性
    """
    对象.属性(这个属性之前不存在)
    注意：这个属性是添加给对象的，而不是类！！！
    """
    dog1.name = '大黄'
    print(dog1.name)
    dog1.__setattr__('type', '哈士奇')
    print(dog1.type)

    setattr(dog1, 'sex', '公狗')
    print(dog1.sex)

    # dog2 = Dog()
    # print(dog2.name)

    # 4.删，删除对象属性
    """
    del 对象.属性
    注意：删除的是对象的属性，不会影响这个类的其他对象
    """
    # del dog1.age
    # print(dog1.age) AttributeError: 'Dog' object has no attribute 'name'
    # dog1.__delattr__('age')
    delattr(dog1, 'age')
    # print(dog1.age）

输出结果：

2 white
2
2
None
3
black
blue
大黄
哈士奇
公狗

六，slots和str

_slots的作用：约束类中的对象属性
_str的作用：自定义对象的打印格式
代码实现：

class Person:
    # __slots__的功能：约束类中的对象属性
    __slots__ = ('name', 'age', 'sex')

    def __init__(self, name='', age=0):
        self.name = name
        self.age = age
        # self.tel = 123 AttributeError: 'Person' object has no attribute 'tel'

    # 自定义对象的打印格式
    def __str__(self):
        return '人类'

输出结果：

人类

七，类中的方法

1.属性的分类

• 对象的属性
  对象属性是属于对象的，不同的对象对应的值可能不一样。对象属性，通过对象来使用
• 类的属性(字段)
  类的属性声明在类里面，函数外面。类属性属于类，通过类来使用

2.方法的分类

• 对象方法
  对象方法自带一个self参数，一般通过对象去调用
• 类方法
  类方法使用@classmethod修饰 。自带一个cls参数，这个参数不用传参，谁来调用这个方法，cls就指向谁。类方法要通过类来调用
• 静态函数
  静态函数使用@staticmethod修饰 ，没有默认参数 ，静态方法要通过类来调用

3.方法的选择

• 如果实现函数的功能需要使用对象的属性，就是用对象方法；
• 如果实现函数的功能需要使用字段或者调用类的方法，就是声明成对象方法；
• 如果实现函数功能既不需要对象属性，也不需要类的字段，就声明成静态方法。
  代码实现：

class Person:
    # number是类属性
    number = 0

    def __init__(self, name='', age=0):
        # name 和 age 都是对象属性
        self.name = name
        self.age = age

    # eat方法是对象方法
    def eat(self, food):
        print('%s在吃%s' % (self.name, food))

    # hurt_earth就是一个类方法
    @classmethod
    def hurt_earth(cls):
        # cls指向的是Person,cls可以当成类来使用
        pt = cls('张三')  # 可以使用cls创建类的对象
        print(pt.name)
        print(cls.number)   # 也可以使用cls使用类的字段
        print('人类破坏环境！！')

    # protect_earth是一个静态方法
    @staticmethod
    def protect_earth():
        print('人类保护地球！！')


if __name__ == "__main__":
    # 类字段要通过类来使用
    print(Person.number)
    # 对象的属性通过对象来使用
    p1 = Person('小明')
    print(p1.name, p1.age)
    # 对象方法对象调用
    p1.eat('面条')
    p2 = Person('小红')
    p2.eat('火锅')
    # 类方法通过类来调用
    Person.hurt_earth()
    # 静态方法通过类来调用
    Person.protect_earth(

输出结果：

0
小明 0
小明在吃面条
小红在吃火锅
张三
0
人类破坏环境！！
人类保护地球！！