继承

类的三大特性

• 继承
• 多态
• 封装

继承

在面向对象编程中，当我们定义一个新类的时候，可以从某个现有的类继承，新的类被称为子类

（SubClass），而被继承的类则被称为基类，父类，超类(Base Class,Father Class,Super Class)

比如，我们定义一个动物类(Animal),其有一个run()，方法如下：

class Animal(object):#定义父类
    def run(self):
        print("Animal is running")
class Animal2():
    pass
class Dog(Animal):#单继承
    pass
class Cat(Animal):#单继承
    pass
class Husky(Anlmal,Animal2):#多继承，用逗号分隔开
    pass
dog=Dog()
cat=Cat()
husky=Husky()
print(dog.run())
print(cat.run())
print(husky.run())

#如果不指定基类，Python类会默认继承object类
#object是所有Python类的基类，提供一些常见方法的实现。

继承的查看

ClassName.__bases__

多态

当子类和父类存在相同的方法时，子类的方法会覆盖父类的方法，再运行代码时，总会调用子类和父类的方法。

这样，就是继承的另外一个好处，多态。

理解多态，首先要对数据类型再进行说明。定义一个类的时候实际上就是定义了一种数据类型。我们自定义的数据类型和Python自带的数据类型，比如str，list，dict没什么区别。

用isinstance()来判断某个变量是否是某个类型

class Animal(object):#定义父类
    def run(self):
        print("Animal is running")
class Animal2():
    pass
class Dog(Animal):#单继承
    def run(self):
        print("Dog is running")
class Cat(Animal):#单继承
    def run(self):
        print("Cat is running")
class Husky(Anlmal,Animal2):#多继承，用逗号分隔开
    pass

dog=Dog()
cat=Cat()
dog.run()
cat.run()


def run_twice(animal):
    animal.run()
    animal.run()
    
run.twice(test)

鸭子类型

鸭子类型不要求有严格的继承关系，一个对象，只要“看起来像鸭子，走起路来也像鸭子”

也就是说，如果要编写现有对象的自定义版本，可以继承该对象，也可以创建一个外观和行为像的对象。

比方说，利用标准库中定义的各种“与文件类似的”对象，尽管这些对象的工作方式像文件，但他们并没有继承内置文件对象的方法。

class TestFile:
    def read(self):
        pass
    
    def write(self):
        pass
    
class OperFile:
    def read(self):
        pass
    
    def write(self):
        pass

对于一个变量，我们只要知道他的父类型，无需确切知道子类型，就可以放心调用相关的方法。运行时具体的方法是作用在子类型上还是父类型上，由我们运行的对象决定。

也就是说，调用时只管调用，不管细节。

当我们新增一个子类时，只要保证相关的方法编写正确，就不用管原来的代码如何调用的。

—> ”开闭“原则

• 对拓展开放：允许新增子类
• 对修改封闭：不需要修改依赖父类型的函数。

总结：

继承可以一级一级的继承下来，类比人类，就好比，爷爷奶奶到父母，再到子女，任何类都可以追溯到跟类object

私有属性

在类的内部，可以有属性和方法，而外部代码可以通过直接调用实例变量的方法来操作数据。这样，隐藏内部的复杂逻辑。

比如Student类：

class Student:
    school="ZUCC"
    def __init__(self,name,score):
        self.name=name
        self.score=score
        
    def find_score(self):
        print(self.name,":",self.score)
        
        
stu1=Student("Tom",99)
stu2=Student("Jack",89)
print(stu1,score)
stu1.score=97
print(stu1.score)

从这里可以看出，外部代码可以自由修改一个实例的属性(name,score)

如果要让内部属性不被外部访问，我们可以在属性名称前加两个下划线。

在Python中，实例的变量名如果以双下划线开头，就变成了一个私有变量，只有内部可以访问，外部不能

so，let’s change the Student Class!

封装

隐藏对象的属性和实现细节，仅对外提供公共访问的方式。

这样做的优点在于：

1.可以将变化隔离；

2.便于使用；

3.提高安全性；

4.提高复用性。

封装的原则：

• 将不需要对外提供的内容隐藏起来；
• 隐藏属性，提供公共方法对其进行访问。

—>私有方法,私有变量——–>私有属性

用双下划线开头的方式将属性隐藏起来，设置为私有的。

class Student:
    school="ZUCC"
    def __init__(self,name,score):
		

        self.__score=score
    def get_name(self):
        return self.__name
    def get_score(self):
        return self.__score
    def set_score(self,score):
        if 0<=score<=100:
            self.__score=score
        else:
            raise ValueError("Bad score")
    def find_score(self):
        print(self.__name,":",self.__score)

stu1=Student("Tom",99)
stu2=Student("Jack",89)

print(stu1.__Student__score)