day2023-3-24-面向对象

一、编程思维

根据面对问题不同人呈现出的思维模式不同，可以将编程思维分为三种：

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

2.函数式编程（小资思想）—— 遇到问题马上想到的是有没有一个已经存在的函数可以解决这个问题，如果没有就造一个（一个函数只具备一个功能）

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

二、类和对象

1.什么是类？什么是对象？

类就是具有相同功能或者相同属性的对象的集合。（类是抽象的概念）
对象就是类的实例。（对象是类具体的表现）

如果人是类，lisa是人的对象，jenny是另一个对象。
车是类，lisa的车是对象，jenny的车是另一个对象。
用面向对象编程实现斗地主游戏，类是斗地主游戏，每一盘游戏是对象。

2.定义类 —— 创建类

1）定义类：用代码来描述你的这个类是拥有哪些相同功能（用函数）和哪些相同属性（用变量）的对象的集合。
2）语法：
class 类名(父类)：
类的说明文档
类的内容（包含方法和属性）

3）说明：
a.class —— 关键字，固定写法
b.类名 —— 由程序员自己命名
两个要求：是标识符，不是关键字
规范：见名知义；不使用系统的函数名、类名和模块名；采用驼峰式命名（大驼峰）
c.类的说明文档 —— 本质就是一个多行注释
d.类的内容 —— 包含定义在类中的函数（方法）和定义在类中的变量（属性）
方法包括：对象方法、类方法、静态方法
属性包括：类属性、对象属性

class Dog:
    """这是狗"""
    pass

3.创建对象

对象是通过类来创建的。

语法：
类名()

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

三、方法

1.什么是方法

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

2.不同的方法的使用

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

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

3）静态方法
a.怎么定义:定义函数前添加装饰器@staticmethod
b.怎么调用:以’类名.xxx()'的形式来调用
c.特点:没有特点

class A:
    # func1、func2是对象方法
    def func1(self):
        # self = a1
        print(f'self:{self}')
        print('对象方法')

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

    # func3是类方法
    @classmethod
    def func3(cls):
        print(f'cls:{cls}')
        print('类方法')

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


a1 = A()
a2 = A()
print(f'a1:{a1}')
print(f'a2:{a2}')
# 通过对象调用对象方法
a2.func1()             # 对象方法
a1.func2(100)          # 对象方法2, a:100, b:2
a1.func2(100, 200)     # 对象方法2, a:100, b:200

# 通过类调用类方法
print(f'A:{A}')
A.func3()

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


class Math:
    @staticmethod
    def sum(n1, n2):
        pass

    @staticmethod
    def factorial(num):
        pass

四、初始化方法

1.魔法方法

1）魔法方法的特点：
a.函数名以 __ 开头，并且以 __ 结尾
b.魔法方法不需要程序员自己调用，系统会在特定情况下自动调用

2）两个常见的魔法方法
a.init
如果在类中添加了__init__方法，那么在创建当前类的对象的时候就会自动调用它;
创建对象的时候需不需要实参，需要几个实参，由类中的__init__决定

b.repr
如果类中添加了__repr__方法，打印类的对象的时候会自动调用这个方法，并且将这个方法对应返回作为打印结果进行打印。
在类中添加__repr__方法的时候，这个方法的返回值必须是字符串。

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


a1 = A()     # init方法被调用
a2 = A()     # init方法被调用


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

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


b1 = B(10, 20)          # m:10, n:20
B(m=100, n=200)    # m:100, n:200
print(b1)               # <B的对象>

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

    def __repr__(self):
        return

stu1 = Student('小明')
stu2 = Student('小花', 19, '女')

五、属性

属性 —— 定义在类中的变量

类中的属性分为：类属性、对象属性

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

2）对象属性
a.怎么定义:以'self.属性名 = 属性值'的形式定义在__init__方法中
b.怎么使用:以'对象.xxx'的方式使用
c.什么时候用:属性值会因为对象不同而不一样，就定义成对象属性

class A:
    # a、name就是类属性
    m = 10
    name = 'lisa'

    # x和n是对象属性
    def __init__(self):
        self.x = 101
        self.n = 'hello'


# 通过类使用类属性
print(A.m)
print(A.name)

# 通过对象使用对象属性
a1 = A()
print(a1.x)
print(a1.n)


class Dog:
    def __init__(self, name, breed, age=3, gender='公'):
        self.name = name
        self.age = age
        self.gender = gender
        self.breed = breed


dog1 = Dog('喜喜', '泰迪')
print(dog1.name)         # 喜喜



class Circle:
    pi = 3.1415926

    def __init__(self, r=0):
        self.r = r

    # 如果对象方法中需要用到对象属性，由self来提供
    def area(self):
        return Circle.pi * self.r ** 2

    def length(self):
        return 2 * Circle.pi * self.r


c1 = Circle(10)
print(c1.area())

c1.r = 20
print(c1.area())

c1.r = 25
print(c1.length())

六、继承

1.继承

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

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

2.继承语法

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

注意：定义类的时候没有写父类，那么这个类会默认继承 object(基类)

class A:
    m = 100

    def __init__(self):
        self.n = 444

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

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

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


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

    # 添加新的对象属性
    def __init__(self):
        super().__init__()       # 调用父类的对象属性
        # super(B, self).__init__()
        self.p = 888

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


b1 = B()
# 使用A中的内容
print(B.m)
print(b1.n)
b1.func1()
B.func2()

# 使用B中的内容
print(B.x)
b1.func11()
print(b1.p)