Python 面向对象的三大特征

面向对象的三大特征

面向对象编程有三大特征：封装、继承、多态。

一、封装

封装是面向对象编程的另一个基本概念，它指的是将一个对象的状态和行为封装在一个统一的单元中，并限制外界访问该对象的方式。

通过封装，可以保护对象的内部状态和行为不被外界随意访问和修改，提高了程序的安全性和可维护性。

将类的属性和方法等信息隐藏在类的内部，在外部就不能直接访问这些隐藏的属性和方法，只能用未隐藏的方法来间接操作这些隐藏的属性和方法，这就是一种封装。

类属性、实例属性、私有属性 就是一种封装。

二、继承

Python⾯向对象的继承指的是多个类之间的所属关系，即⼦类默认继承⽗类的所有属性和⽅法。

如果一些类具有相同的属性和方法，那么就可以把这些相同的属性和方法提出来，单独作为一个父类。继承该父类就可以继承这些属性和方法。

继承提高了代码了复用性。

在Python中，所有类默认继承object类，object类是顶级类或基类；其他⼦类叫做派⽣类。

Python中，继承又有单继承、多继承和多层继承。

1.单继承

单继承指的是子类只继承一个父类。

示例：

class Dog(object):　　　　# object可以不写
    def __init__(self):
        self.color = '白色'
        self.age = 2

    def show_info(self):
        print(f'颜色：{self.color}  年龄：{self.age}')


class Husky(Dog):
    pass

husky1 = Husky()
print(husky1.color)     # 白色
husky1.show_info()      # 颜色：白色  年龄：2

2.多继承

多继承指的是一个类同时继承多个父类。

Python允许多继承，但和单继承相比，多继承容易让代码逻辑复杂、思路混乱，建议尽量不要使用多继承。

示例：

class FruitA():
    def __init__(self):
        self.size = 'big'

    def a_func(self):
        print('fruitA is big')

class FruitB():
    def __init__(self):
        self.flavor = 'sweet'

    def b_func(self):
        print('fruitB is sweet')

class FruitC(FruitA, FruitB):
    def __init__(self):         # 如果不定义该方法并调用FruitB.__init__(self) ，后续print(fc.flavor)会报错
        FruitA.__init__(self)   #
        FruitB.__init__(self)   #

fc = FruitC()
print(fc.size)      # big       # FruitC是定义了__init__()方法，本行代码都能正常执行
print(fc.flavor)    # sweet     # 如果FruitC没有在__init__()方法中调用FruitB.__init__(self)，本行代码会报错
fc.a_func()         # fruitA is big
fc.b_func()         # fruitB is sweet

3.多重继承

class Animal():
    def move(self):
        print('动物会动')

class FlyAnimal(Animal):
    def fly(self):
        print('飞行动物会飞')

class Bird(FlyAnimal):
    def borth(self):
        print('鸟是卵生')

bird = Bird()
bird.move()     # 动物会动
bird.fly()      # 飞行动物会飞
bird.borth()    # 鸟是卵生

4.super()

super() 是python 中调用父类的一种方法，在子类中可以通过super()方法来调用父类的方法。

class Father():
    def __init__(self, name):
        self.name = name
        print('father init')

    def say(self):
        print(f'i m {self.name}')

class Son(Father):
    def __init__(self, name):
        print('son init')
        super().__init__(name)

    def say(self):
        super().say()
        print('i m son')

son = Son('tom')
son.say()
# son init
# father init
# i m tom
# i m son

三、多态

多态是⼀种使⽤对象的⽅式，⼦类重写⽗类⽅法，调⽤不同⼦类对象的相同⽗类⽅法，可以产⽣不同的执⾏结果。

一个父类，他具有多个子类，不同的子类在调用相同的方法，执行的时候产生不同的形态，这个叫多态。

多态的实现步骤：

• ​ 定义⽗类，并提供公共⽅法
• ​ 定义⼦类，并重写⽗类⽅法
• ​ 传递⼦类对象给调⽤者，可以看到不同⼦类执⾏效果不同

class Pet():
    def say(self):
        print('pet say')

class Dog(Pet):
    def say(self):
        print('汪~汪~汪')

class Cat(Pet):
    def say(self):
        print('喵~喵~喵')

def pet_say(pet):
    pet.say()

p = Pet()
d = Dog()
c = Cat()
pet_say(p)  # pet say
pet_say(d)  # 汪~汪~汪
pet_say(c)  # 喵~喵~喵