【Python技能树】面向对象详解

1、什么是面向对象编程？

面向对象编程（Object-Oriented Programming，OOP）是一种常用的编程思想，它强调万物皆对象，因此在编程时我们可以将现实世界中的事物抽象成程序中的对象，从而更好实现软件的设计与开发。与传统的基于函数的编程不同，面向对象编程注重于将数据与行为封装在一起，即对象既包含数据状态，还包含可调用的行为方法。

面向对象是一种编程范式，它将程序中的数据和操作封装在一个对象中，从而使得程序更加模块化、可重用和易于维护。在面向对象编程中，对象是类的实例化，类是一种抽象的数据类型，它定义了一组属性和方法。

面向对象编程的特点在于，它具有封装、继承和多态三大特性。

封装意味着将对象的状态和行为进行封装，使其对外只暴露必要的接口，从而提高了安全性和可维护性；

继承指的是某个对象可以继承另一个对象的特性，从而快速构建具有相似属性的对象；

多态是指同一种行为在不同的对象上具有不同的表现形式，即在不同的情境下，同一个方法可以被不同的对象进行调用。

总之，面向对象编程是一种强大的编程方式，它具有高度封装性、灵活的继承性和强大的多态性，通过使用对象作为程序的基本处理单元，实现了数据和行为的有机结合，可以使程序更加高效、结构清晰，并方便管理和扩展。

2、 类与对象

类与对象是面向对象编程中的两个重要概念。

类是一种抽象的数据类型，它定义了一组属性和方法，描述了一类对象的共同特征和行为。

对象是类的实例化，是具体的数据实体，具有类所定义的属性和方法。

类与对象的关系我们可以用一个案例类比，假设你要买一张飞机票，并且你需要填写一份订票表格。这份订票表格就相当于一个类，它有一些属性（如你的姓名、航班编号、起点和终点等信息），而你填写的表格就是对象。在填写表格时，你需要根据表格的属性来输入相关信息，就像在使用类时需要调用类的属性和方法一样。

类与对象的关系

类是一个模板，对象是根据这个模板创建的具体实例。如果将类比喻为蛋糕模具，那么对象就是蛋糕。一个类可以创建多个对象，它们之间是独立的，互相不影响。

类和对象的定义

类是一种用户自定义的数据类型，它由数据和方法组成。数据表示属性，方法表示行为。一个类可以包含多个属性和方法。属性是类的成员变量，可以存储数据。方法是一组操作数据的代码，它们可以实现某些功能或者改变属性的值。

例如：

class 类名:
    类属性 = 值
    def __init__(self, 参数):
        self.属性1 = 参数1
        self.属性2 = 参数2
    def 方法1(self, 参数):
        # 方法代码
    def 方法2(self, 参数):
        # 方法代码

• class是声明类的关键字。

• __init__是类的构造方法，当创建类的对象时，会自动调用这个方法。self表示对象本身，其他参数就是对象的属性。

• 属性是类的成员变量，可以在类内部和外部使用。可以在类外使用类名访问类属性，如：类名.类属性。

• 方法是类的成员函数，接受的第一个参数是self，表示对象本身。在类内使用方法时，不需要传递这个参数。外部访问方法时，需要在对象后面加上方法名，如：对象.方法名()。

class Dog:
    # 类属性
    species = '犬科'
    
    # 构造方法
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    # 方法
    def bark(self):
        print("汪汪汪")
        
# 创建对象
dog1 = Dog('大黄', 2)
dog2 = Dog('二黄', 1)
 
# 访问属性
print(dog1.name)
print(dog2.age)
 
# 调用方法
dog1.bark()

3、面向对象的特征和优点

3.1 封装

封装是OOP中最基本的特征之一，它将数据和方法封装在一个单独的单元中。对于实现封装，可以使用类来描述一个对象，类包括数据成员和成员函数。在类的定义中，可以使用关键字public、protected和private来指定成员访问权限，以保护数据的安全性。

封装是指将数据和行为打包到一个类中，并可以控制外部访问的级别。封装可以保护数据和方法的访问，并且提高代码的可维护性。我们可以利用访问控制修饰符来实现封装，包括公有、私有、受保护和包访问等四种级别。

简单的来说其实就是， 封装就是不让人靠近自己的东西，保护自己的隐私

Python中的封装可以通过以下方式实现：

class Student:
    def __init__(self, name, age):
        # 公共成员变量
        self.name = name
        # 私有成员变量
        self.__age = age
 
    def info(self):
        print('姓名：' + self.name)
        print('年龄：' + str(self.__age))
 
# Student类包括了两个成员变量（name和age）和一个成员函数（info()）。
# 其中，name是公共成员变量，可以被外部访问；而age被定义成私有成员变量，只能在类内部访问。
# 通过封装，可以保证数据不被外部随意修改，保证代码的安全性。

Python中的封装可以通过以下方式实现：

1. 使用私有变量和方法：在变量或方法名称前加上双下划线“__”即可将其定义为私有的，外部程序无法直接访问。需要注意的是，Python中的私有变量和方法并非完全无法访问，而是通过一定的方式进行访问。

2. 使用属性：Python中的属性是一种特殊的方法，可以用来控制对类的成员变量的访问。通过属性，可以在访问成员变量时进行一些逻辑判断和处理，从而保护数据的完整性和安全性。

3. 使用访问器和修改器：访问器和修改器分别是用来获取和设置私有变量的方法，可以在方法内部进行一些逻辑判断和处理，从而保护数据的完整性和安全性。

4. 使用装饰器：装饰器是Python中一种特殊的语法结构，可以用来修改或扩展函数或类的功能。通过装饰器，可以在类或方法定义时对其进行修饰，从而实现封装的目的。

3.2 继承

继承是指一个类可以从父类中继承方法和属性。如果父类的某个属性或方法也在子类中定义了，那么子类会重写父类的属性或方法，这样子类可以更好地针对自己的特定要求来实现相应的功能。有人说继承可以使代码更加简洁，但是过度的继承反而会使代码变得非常复杂。---- 继承其实就像是血缘关系，你可以从你的祖先那里继承一些好的特点，但也不能完全成为他们。

class Animal:
    def __init__(self, name):
        self.name = name
 
    def eat(self):
        print(self.name + '在吃东西')
 
class Dog(Animal):
    def __init__(self, name):
        super().__init__(name)
 
    def bark(self):
        print(self.name + '在汪汪叫')
 
dog = Dog('小狗')
dog.eat()
dog.bark()

3.2.1 单继承与多继承

3.2.1.1 单继承

在Python中，单继承是指一个子类只能继承一个父类的属性和方法。Python中的类可以通过继承来扩展父类的功能，并添加自己的属性和方法。

下面是一个简单的Python单继承的例子：

class Animal:
    def __init__(self, name):
        self.name = name
    
    def eat(self):
        print(self.name + " is eating.")

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)
        self.breed = breed
    
    def bark(self):
        print(self.name + " is barking.")

dog = Dog("Tom", "Husky")
dog.eat()  # 输出"Tom is eating."
dog.bark()  # 输出"Tom is barking."

# 这段代码定义了一个Animal类和一个继承自Animal类的Dog类。
# Animal类有一个构造函数__init__()和一个eat()方法，eat()方法输出动物正在吃东西的信息。
# Dog类有一个构造函数__init__()和一个bark()方法，bark()方法输出狗正在叫的信息。

    

3.2.1.2 多继承

多继承是指一个类可以同时继承多个父类的特性和方法。

多继承的语法非常简单，只需要在定义类时在类名后面添加括号，括号中写上要继承的所有父类的名称，用逗号隔开即可。

例如，下面的代码定义了一个名为MyClass的类，它同时继承了父类A和B：

class A:
    def method1(self):
        print("Method 1 of A called.")

class B:
    def method2(self):
        print("Method 2 of B called.")

class MyClass(A, B):
    def method3(self):
        print("Method 3 of MyClass called.")

my_object = MyClass()
my_object.method1()  # 输出"Method 1 of A called."
my_object.method2()  # 输出"Method 2 of B called."
my_object.method3()  # 输出"Method 3 of MyClass called."
# 在这个例子中，我们定义了两个父类A和B，它们分别有一个方法method1和method2。
# 然后，我们定义了一个名为MyClass的类，它同时继承了A和B两个父类，并添加了一个方法method3。

3.2.1.3 多重继承

在Python中，一个类可以同时继承多个父类，这被称为多重继承。多重继承可以形成多层继承，即一个类继承了另一个类，而另一个类又继承了另一个类，以此类推。

假设我们有3个类，分别是Animal（动物）、Bird（鸟）和Fish（鱼）。Animal类是基类，它包含了所有动物都具有的属性和方法，例如eat、sleep等等。Bird和Fish类都是继承自Animal类的子类，并且它们分别添加了自己独有的属性和方法，例如Bird类具有fly方法，而Fish类具有swim方法。

那么，如果我们需要创建一个Penguin（企鹅）类，它既需要继承Bird类的fly方法，又需要继承Fish类的swim方法，该怎么办呢？这时候，就需要使用多重继承了。

class Animal:
    def __init__(self, name):
        self.name = name
        
    def eat(self):
        print(self.name + "正在吃东西...")
        
    def sleep(self):
        print(self.name + "正在睡觉...")
        
class Bird(Animal):
    def fly(self):
        print(self.name + "正在飞翔...")
        
class Fish(Animal):
    def swim(self):
        print(self.name + "正在游泳...")
        
class Penguin(Bird, Fish):
    def __init__(self, name):
        super().__init__(name)
        
    def run(self):
        print(self.name + "正在奔跑...")

3.3 多态

多态指的是同一个行为在不同情况下有不同的表现形式。在OOP中，多态是一种通过继承、重写和接口实现的机制，它可以让不同类的对象对同一消息做出不同的响应。这种特性可以提高代码的灵活性和可扩展性，使程序更加易于维护和扩展。

class Animal:
    def __init__(self, name):
        # 私有成员变量
        self.__name = name
 
    def make_sound(self):
        # 抽象方法
        pass
 
 
class Cat(Animal):
    def __init__(self, name):
        # 调用父类的构造函数
        super().__init__(name)
 
    def make_sound(self):
        print(self.__name + '猫叫')
 
 
class Dog(Animal):
    def __init__(self, name):
        # 调用父类的构造函数
        super().__init__(name)
 
    def make_sound(self):
        print(self.__name + '狗叫')
 
 
# Animal类包含一个抽象方法make_sound()，它在子类中被重写，实现了多态。
# Cat类和Dog类都是Animal类的子类，它们重写了make_sound()方法
# 使得同一个行为（make_sound()）在不同情况下有不同的表现形式。

在Python中，实现多态的方式主要有两种：

    1.方法重写：方法重写是指在子类中重新定义父类的方法，从而实现对该方法的重载。这种方式可以让子类对父类的方法进行扩展或修改，从而实现多态。

    2.方法重载：方法重载是指在同一类中定义多个同名的方法，但是它们的参数列表不同。这种方式可以让同一个方法名实现不同的功能，从而实现多态。

例如，假设有一个动物类Animal，其中定义了一个speak()方法，不同的动物可以根据自己的特点进行不同的叫声。我们可以定义一个Dog类和一个Cat类继承自Animal类，并且重写speak()方法，使得它们能够发出不同的叫声：

class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        print("汪汪汪！")

class Cat(Animal):
    def speak(self):
        print("喵喵喵！")
# 以上代码实现了多态，因为不同的对象（Dog和Cat）对相同的方法（speak()）做出了不同的响应。
# 在调用speak()方法时，可以根据对象的类型来决定调用哪个子类的方法，从而实现多态。

4、实例应用

4.1 重写与调用

python重写
在Python中，子类可以重写（覆盖）父类的方法，以实现自己的功能。
重写方法时，需要注意以下几点：

    · 子类的方法名与父类的方法名相同。
    · 子类的方法参数与父类的方法参数相同。
    · 子类的方法返回值类型与父类的方法返回值类型相同或者是父类方法返回值类型的子类型。

例如，下面的代码定义了一个名为Animal的父类和一个名为Dog的子类，子类重写了父类的方法：

class Animal:
    def make_sound(self):
        print("The animal makes a sound.")

class Dog(Animal):
    def make_sound(self):
        print("The dog barks.")

my_dog = Dog()
my_dog.make_sound()  # 输出"The dog barks."

python调用
在Python中，调用父类的方法有两种方式：

    · 使用super()函数调用父类的方法。
    · 直接使用父类的类名调用父类的方法。

使用super()函数调用父类的方法是比较常用的方式，它可以自动识别出哪个父类的方法需要被调用。例如：

class Animal:
    def __init__(self, name):
        self.name = name
    
    def eat(self):
        print(self.name + " is eating.")

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)
        self.breed = breed
    
    def bark(self):
        print(self.name + " is barking.")

my_dog = Dog("Tom", "Husky")
my_dog.eat()  # 输出"Tom is eating."

直接使用父类的类名调用父类的方法也是一种有效的方式。例如：

class Animal:
    def __init__(self, name):
        self.name = name
    
    def eat(self):
        print(self.name + " is eating.")

class Dog(Animal):
    def __init__(self, name, breed):
        Animal.__init__(self, name)
        self.breed = breed
    
    def bark(self):
        print(self.name + " is barking.")

my_dog = Dog("Tom", "Husky")
my_dog.eat()  # 输出"Tom is eating."