Python 面向对象学习整理 （看这一篇就足够了）

学完了 Python 基础之后，当我想要把自己的一些小项目通过 Python OOP 的方式来编写的时候，却发现很难很难，于是这次重新回过头来重新学习 Python 中面向对象的思想

学习资料参考：传送门

一、面向对象中的几点概念

1.1 什么是类？

类：用户定义的对象原型（prototype），该原型定义了一组可描述该类任何对象的属性，属性是数据成员（类变量 和 实例变量）和方法，可以通过 ‘.’ 来访问。说简单一点，类是一个模板，我们可以使用该模板生成不同的具体的对象，来完成我们想要的操作

1.2 什么是实例？

实例：某一个类的单个对象，例如我们定义了一个 Person 类，而具体的人，比如小明，小黄就是 Person 类的实例

1.3 什么是属性？

属性：描述该类具有的特征，比如人类具备的属性，身份证，姓名，性别，身高，体重等等都是属性

1.4 什么是方法？

方法：是该类对象的行为，例如这个男孩会打篮球，那个女孩会唱歌等等都是属于方法，常常通过方法改变一些类中的属性值

二、Python 使用面向对象编程

这是早期学习基础的时候编写的文章，仅供参考学习
Python 面向对象编程（OOP）—— 类
Python 面向对象编程（OOP） ——取值，赋值方法and逻辑
Python面向对象编程（OOP） —— 继承、使用槽

2.1 定义一个类

Python 中定义类是使用关键字 class，一个简单的实例

class Student:
    pass

# 创建对象实例
stu = Student()
print(stu)
print(property(stu))
print(type(stu))

在定义一个类的时候，我们常常会使第一个字母大写，当然小写也是可以的，但是使用大写是因为这是一种规范问题，打印的结果也可以看得到，我们创建的实例在我的计算机的 内存地址

2.2 给类添加基本属性

在类中属性，包含两种

1. 类 属性
2. 对象属性

下面来看一看基本用法

# 细心的同学会发现，我这里给 类加上了括号，其实这个括号如果传参的话，我们可以传入另一类，这样的话就变成了 继承的关系
class Student():

    student = "大学生"
    def __init__(self,name,age):
        # 定义两个对象属性，这个属性在不同的对象中是不一样的
        self.name = name
        self.age = age

stu1 = Student("小红",18)
stu2 = Student("小黄",19)

print(f"{stu1.name}今年{stu1.age}岁,是{stu1.__class__.student}")
print(f"{stu2.name}今年{stu2.age}岁,是{stu1.__class__.student}")

• 类中定义了一个 student 属性student 是类属性，可以他通过 对象.class.student 访问，如果对象属性 在一个地方被改变了，那么其他的地方也会改变
• 类中定义了一个名为 init 的方法，我们成这个方法为构造方法，在 python 中创建对象的时候，这个方法会自动调用。
  在 构造方法 中，我定义了两个对象属性，所以我在下面创建对象的时候，就要传入这两个对象的属性，后面就可以通过 对象. 的方式得到我们设置的对象属性

2.3 给类添加方法

添加方法也很简单，使用 def 关键字定义一个方法，然后在方法体编写方法具体的功能即可，看下边的示例

class Student():

    student = "大学生"
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def sing(self):
        print(f"{self.name} 会唱歌")

    def basketbal(self):
        print(f"{self.name} 会打篮球")

stu1 = Student("小红",18)
stu2 = Student("小黄",19)

print(f"{stu1.name}今年{stu1.age}岁,是{stu1.__class__.student}")
print(f"{stu2.name}今年{stu2.age}岁,是{stu1.__class__.student}")

stu1.sing()
stu2.basketbal()

类中的方法的定义中，第一个参数必须是 self，这个 self 就相当于 java 构造方法中的 this 关键字，它指的是当前对象，比如 stu1 是当前对象，self 指的就是 stu1。

当我们需要调用对象方法的时候，只需要使用 对象.方法([参数]) 即可，也就是上面的 stu1.sing()

2.4 访问权限控制

在学习 java 的过程中，我们知道 java 拥有 public > default > protected > private 的四大访问修饰符。

在 Python 中也访问权限修饰符，在 Python 中修改一个属性值，可以直接通过 对象.属性 直接修改，这样是有问题的，比如我们把一个人的年龄 设置为 200，正常人都知道，一个人的最长寿命也不会超过 150 岁，所以为了防止这种情况的出现，我们可以把人的年龄设置为 私有变量，这样年龄属性就无法在外面直接访问得到了。因此我们只需要把 age字段前面加上 ‘__’ 即可，这样在外面，我们就无法使用 对象.age 或 对象.__age 访问到年龄了

class Student():

    # student 是类属性，可以他通过 对象.__class__.student 访问
    student = "大学生"
    # init 是类的构造方法，在对象被创建的时候，就会自动调用这个方法
    def __init__(self,name,age):
        # 定义两个对象属性，这个属性在不同的对象中是不一样的
        self.name = name
        if age>150:
            raise ValueError("人的年龄无法达到 150 岁以上")
        self.__age = age

    def sing(self):
        print(f"{self.name} 会唱歌")

    def basketbal(self):
        print(f"{self.name} 会打篮球")

stu1 = Student("小红",18)
stu2 = Student("小黄",19)

print(stu1.age)
print(stu2.__age)

这样 age 属性就无法被直接访问了，所以，我们就需要创建两个方法，和 java 中的 setter 和 getter 方法很像

1. 用来提供设置属性的值
2. 用来提供访问属性的值

class Student():

    student = "大学生"
    def __init__(self,name,age):
        self.name = name
        if age>150:
            raise ValueError("人的年龄无法达到 150 岁以上")
        self.__age = age

    def getAge(self):
        return self.__age

    def setAge(self, age):
        if age > 150:
            raise ValueError("人的年龄无法达到150岁")
        self.__age = age


stu1 = Student("小红",18)
stu2 = Student("小黄",19)
stu1.setAge(20)

print(stu1.getAge())

我们还可以使用 ‘__’ 修饰一个方法，使其外部不可访问

三、使用继承和多态

3.1 使用继承

示例代码如下

class Dog():

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

    # 定义公共方法
    def bark(self):
        print(f"{self.name} can bark")

class pipi(Dog):

    def play(self):
        print(f"{self.name} 会打滚")

class dandan(Dog):

    def other(self):
        print(f"{self.name} 会杂技")

dog1 = pipi("皮皮",2)
dog2 = dandan("蛋蛋",3)
dog1.play()
dog1.bark() # 调用公共的方法
dog2.other()

我们在上面的代码找那个分别编写了 pipi 类 和 dandan 类，它们分别继承于 Dog 类，因此他们都会具备 Dog 类具有的属性和方法，然后他们也可以拥有他们独有的属性和方法

3.2 方法的覆盖

3.2.1 一般的方法覆盖情况

假设有这种情况，子类和父类拥有同样的方法名，但是我们调用的方法是属于父类的还是子类的呢？我们改一下代码看看。

class Dog():

    def __init__(self,name,age):
        self.name = name
        self.age = age
        
    def bark(self):
        print(f"{self.name} can bark")

    def eat(self):
        print(f"{self.name} 喜欢吃鸡肉")

class pipi(Dog):

    def play(self):
        print(f"{self.name} 会打滚")

    def eat(self):
        print(f"{self.name} 喜欢吃火腿")


dog1 = pipi("皮皮",2)
dog1.eat()

运行结果：

所以我们发现，当子类和父类方法同名时，子类方法会覆盖父类的方法。

3.2.2 init 方法覆盖

• 当子类没有 init 方法的时候，它会直接继承 父类的 init 方法
• 当子类 定义了 init 方法的时候，在子类的 init() 中调用父类的 init()方法，和上面情况类似，区别就是调用父类 init() 方法的时机
• 子类定义了 init()，子类__init__() 中没有调用父类的方法，这时候注意，父类的私有属性无法调用，子类调用私有属性的 get 和 set 方法会报错

3.3 多态

多态：它指的是一个声明为 A类型的变量，可能是指 A类型的对象，也可以是 A类型的任何子类对象

class Dog():

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

        if age > 100:
            raise ValueError("狗狗的年龄不可能这么大")
        self.__age = age

    def getAge(self):
        return self.__age

    def setAge(self,age):
        if age > 100:
            raise ValueError ("狗狗的年龄不可能这么大")
        self.__age = age

    # 定义公共方法
    def bark(self):
        print(f"{self.name} can bark")

    def eat(self):
        print(f"{self.name} 喜欢吃鸡肉")

class pipi(Dog):

    def play(self):
        print(f"{self.name} 会打滚")

    def eat(self):
        print(f"{self.name} 喜欢吃火腿")

    # 方法覆盖
    def bark(self):
        print(f"{self.name} 在叫,嘻嘻....")
class dandan(Dog):

    def other(self):
        print(f"{self.name} 会杂技")

def dog_bark(dog):
    if isinstance(dog, Dog):
        dog.bark()

d = Dog("阿拉斯加",3)
dog_bark(d)

d1 = pipi("小皮",2)
dog_bark(d1)

d2 = dandan("蛋蛋",1)
dog_bark(d2)

在上面的代码中，我们定义了一个 dog_bark() 方法，它可以介绍父类的对象，也可以接受子类的对象

使用多态，我们并不需要给每一个 子类定义一个调用 bark() 的方法，pipi_bark(), dandan_bark()，只需要定义一个 dog_bark()， 在调用的时候给它传递对应的子类对象即可。