【总结】面向对象

面向对象

1. 编程思维

根据面对问题不同人层显示的思维模式不同，将编程思维分为三种：

1）面向过程编程（穷人思想） - 遇得到问题想到的是解决这个问题的具体逻辑和步骤

2）函数式编程（小资思想） - 遇到问题想到的是有没有一个函数可以解决，如果没有就造一个。

3）面向对象编程（富豪思想） - 遇到问题想到的是有没有一个具有这个功能的对象，如果没有就造一个对象（一个对象可以同时具有多个函数）。

2. 类和对象

2.1 什么是类？什么是对象？

类就是拥有相同功能或者相同属性的对象的集合

对象就是类的实例。(对象是类的具体表现)

如果人是类， xx是对象，具体某一个人是对象

如果车是类，婷姐的车是对象

如果斗地主游戏是类，某一场游戏是对象

2.1 定义类 - 创建类

1）定义类：用代码来描述你的这个类拥有哪些相同功能（函数）和哪些相同属性（变量）的对象的集合

2）语法：

class 类名:
    类的说明文档
    类的内容（包含方法和属性）

3）说明

a. class - 关键字；固定写法

b. 类名 - 程序员自己命名;

​ 两个要求：是标识符，不是关键字

​ 规范：见名知义；不使用系统函数名、类名和模块名；采用大驼峰式命名（比如：UserName）

c. 类的说明文档 - 本事就是一个多行注释

d. 类的内容 - 包含定义在类中的函数（方法）和定义在类中的变量（属性）

• 方法包括：对象方法、类方法、静态方法
• 属性包括：类属性、对象属性

类的创建

# 类的创建
class Dog:
    """这是狗"""
    pass

创建对象

• 对象是通过类来创建的
• 语法：类名()

dog1 = Dog()
dog2 = Dog()
print(dog1)
print(dog2)

3. 方法

3.1 什么是方法

定义在类中的函数就是方法

3.2 不同方法的使用

1）对象方法

a. 怎么定义：直接定义在类中函数就是对象方法
b. 怎么调用：以‘对象.xxx()’的形式来调用
c. 特点：自带参数self,调用函数的时候不需要传参，系统会自动将当前对象传给self（谁调用self指向谁）

2）类方法

a. 怎么定义:定义函数前添加装饰器 @classmethod
b. 怎么调用：以‘类名.xxx()’的形式调用
c. 特点:自带参数cls,调用函数的时候cls不需要传参，系统会自动将类传给cls

3）静态方法

a. 怎么定义：定义函数前添加装饰器 @staticmethod
b. 怎么调用：以‘类名.xxx()’的形式调用
c. 特点:没有特点

class A:
    # func1 是对象方法
    def func1(self):
        # self = a1
        print(f'self:{self}')   # self:<__main__.A object at 0x0000013C61394BB0>
        print('对象方法1')

    def func2(self, a, b=2):
        print(f'对象方法2, a:{a}, b:{b}')   # 对象方法2, a:100, b:2     # 对象方法2, a:100, b:200

    # func3是类方法
    @classmethod
    def func3(cls):
        print(f'cls:{cls}')     # cls:<class '__main__.A'>
        print('类方法')

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


# 创建对象
# a1 和 a2 不一样
a1 = A()
a2 = A()
print(f'a1:{a1}')    # a1:<__main__.A object at 0x0000013C61394BB0>
print(f'a2:{a2}')    # a2:<__main__.A object at 0x0000013C613952A0>

# 通过对象调用对象方法
a1.func1()
a2.func2(100)
a2.func2(100,200)

# 调用类方法
print(f'A:{A}')     # A:<class '__main__.A'>
A.func3()

# 调用静态方法
A.func4()

4. 初始化方法

4.1 魔法方法

1）魔法方法特点：

• 函数名以’‘开头，并且以’'结尾

• 魔法方法不需要程序员自己调用，系统会在在特定条件条件下自动调用

2）两个常见魔法方法

a. init:

• 如果在类中添加了__init__方法，那么在创建对象的时候就会自动调用；不需要创建对象后使用调用函数的方法调用
• 创建对象的时候需不需要实参，需要几个实参，由类中的__init__决定

b. repr:

• 如果类中添加了__repr__方法，打印类的对象的时候会自动调用这个方法，并且将这个方法的返回值作为打印结果进行打印

• 在类中添加__repr__方法的时候，这个方法的返回值必须是字符串

class A:
    def __init__(self):
        print('init被调用')

a1 = A()    # init被调用
a2 = A()    # init被调用
print(a1)   # <__main__.A object at 0x0000026EA6B34BB0>
# 无需使用a1.__init__调用

print('------------------------------华丽分割线-----------------------------')

class B:
    def __init__(self, m, n):
        print(f'm:{m}, n:{n}')

    def __repr__(self):
        return '<B的对象>'

# b1 = B()  # 报错
b1 = B(10, 20)
print(b1)   # <B的对象>

class Students:
    def __init__(self, name, age=18, gender='男'):
        self.name = name
        self.age = age
        self.gender = gender

    def __repr__(self):
        # self = stu1
        return f'姓名：{self.name}, 年龄：{self.age}, 性别：{self.gender}'

stu1 = Students('小明')
stu2 = Students('小花', 17, '女')
print(stu1)
print(stu2)

5. 类中属性

属性 - 定义在类中的变量

• 类中的属性分为两种：类属性、对象属性

5.1 类属性

1）怎么定义：直接在类中定义的变量就是类属性
2）怎么使用：以’类名.xxx()'的方式使用
3）什么时候用：如果属性值不会因为对象不同而不一样，就定义成类属性

5.2 对象属性

1）怎么定义：以’self.属性名 = 属性值’ 的形式定义在__init__方法中
2）怎么使用：以’对象.xxx()'的形式使用
3）什么时候用：如果属性值会因为对象不同而不一样，就定义成对象属性

class A:
    # a、name是类属性
    m = 10
    n = '张三'

    #x,n就是对象属性
    def __init__(self):
        self.x = 10
        self. n = 'hello'

# 通过类使用类属性
print(A.m)      # 10
print(A.n)   # 张三

# 通过对象使用对象属性
# 需要先创建对象
a1 = A()
print(a1.x)     # 10
print(a1.n)     # hello

class Circle:
    # 类属性
    pi = 3.1415926

    # 对象属性
    def __init__(self):
        self.r = 1

print('------------------------------华丽分割线-----------------------------')

class Dog:
    # 也可以添加默认值
    def __init__(self, name, age, breed, gender='公'):
        self.name = name
        self.age = age
        self.breed = breed
        self.gender = gender

dog1 = Dog('小黑', 2, '金毛')
# dog2 = Dog('小小')
print(dog1.name)

class Circles:
    # 类属性
    pi = 3.1415926

    # 对象属性
    def __init__(self, r=0):
        self.r = r

    # 面积
    # 如果对象方法用到对象属性，有self提供
    def area(self):
        return Circles.pi * self.r ** 2

    # 周长
    def perimeter(self):
        return Circles.pi * (self.r * 2)

c1 = Circles(10)
print(c1.area())
print(c1.perimeter())

c1 = Circles(20)
print(c1.area())
print(c1.perimeter())

6. 继承

6.1 继承

继承：让子类直接拥有父类的属性和方法

子类 - 继承者
父类 - 被继承的类

6.2 继承语法

语法：

class 类名(父类1, 父类2, 父类3, ...):
    类的说明文档
    类的内容

• 注意：如果定义类的时候没有写父类，那么这个类会继承object（基类）

class A:
    m = 100

    def __init__(self):
        self.n = 200

    def func1(self):
        print('对象方法')

    @classmethod
    def func2(cls):
        print('类方法')

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

class  B(A):
    # 添加新的类属性
    x = 'hello'

    # 添加新对象 父类继承的__init__不调用时失效
    # def __init__(self):
    #     self.p = 1000

    def __init__(self):
        super().__init__()  # 调用当前父类的__init__，使子类和父类的__init__都可以使用
        self.p = 1000

    # 添加新的对象方法
    def func11(self):
        print('对象方法2')

    @classmethod
    def func22(cls):
        print('类方法2')

    @staticmethod
    def func33():
        print('静态方法2')

b1 = B()
print(B.m)
print(b1.n)
print(b1.func1())
print(B.func2())
print(B.fenc4())

print(B.x)
print(b1.p)
print(b1.func11())
print(B.func22())
print(B.func33())