Python-面向对象之单继承

、基本概念

　　面向对象三要素之一：继承inheritance

　　继承表达式：class Cat(Anaimal),继承可以让子类从父类获取特征（属性和方法）

　　父类：Anaimal 就是Cat的父类，也称为基类，超类

　　子类：Cat就是Anaimal的子类，也称为派生类

2、定义

　　格式如下：

class 子类名(父类名):
    语句块

　　如果类定义时，没有基类列表，等同于继承自object，在Python3中，object类是所有对象的根基类

只在python3 中是可以等价的，python2中不同的
class A:
    pass

等同于

class A(object):
    pass　　

　　注意：python支持多继承，继承也可以多级。

　　　　查看继承的特殊属性和方法有：

特殊属性和方法	含义	示例
__base__	类的基类
__bases__	类的基类元组
__mor__	显示方法查找顺序，基类的元组
mro()方法	同上，返回列表
__subclassedd__()	类的子类列表	print(Anaimal.__subclasses__())

 3、继承中的访问控制：

　　举例：

class Anaimal:
    __COUNT = 100
    HEIGHT = 0

    def __init__(self, age, weight, height):
        self.__COUNT += 1
        self.age = age
        self.__weight = weight
        self.HEIGHT = height

    def eat(self):
        print('{} eat'.format(self.__class__.__name__))

    def __getweight(self):
        print(self.__weight)

    @classmethod
    def showcount1(cls):
        print(cls)
        print(cls.__dict__)
        print(cls.__COUNT)

    @classmethod
    def __showcount2(cls):
        print(cls.__COUNT)

    def showcount3(self):
        print(self.__dict__)
        print(self.__COUNT)

from t1 import Anaimal

class Cat(Anaimal):
    NAME = 'CAT'
    __COUNT = 200

# c = Cat()  缺参数，报错
c = Cat(3, 5, 15)# 使用父类初始化函数进行初始化
# print(c.HEIGHT) # 自己没有，调用父类的属性
# c.eat()# 调用父类的方法
# print(c._Anaimal__weight)# 获取父类初始化函数中的属性
# c._Anaimal__getweight()

c.showcount3()

 

 

 

　　总结：

1. 从父类继承，自己没有的，就可到父类中找
2. 私有的都是不可以访问的，但是本质上依然是改了名称放在这个属性所在类或示例的__dict__中，知道这个名称就可以直接找到这个隐藏的变量，这个是黑魔法，慎用
3. 继承时，公有的，子类和实例都可以随意访问，私有成员被隐藏，子类和实例不可直接访问，但私有变量所在的类内的方法可以访问这个私有变量
4. Python通过自己一套实现，实现和其他语言一样的面向对象的继承机制
5. 私有的只个自己用，并不是给其他的类或实例用的，出去的，也就是可以直接在类外调用的，都是共有的
6. 事实上，在类内部是可以随便访问的，直接  .__xx 调用的，但事实上，在外部，看到的不是这个名字
7. 如果想获取私有属性，可以给一个调用方法 如：getage 返回 self.__age，或者使用属性装饰器property，从而不需要知道隐藏属性的真是名称，直接访问
8. 私有方法，就不要调来调去了，虽然是可以的！

　　属性查找顺序：

　　　　　实例的__dict__ ----> 类的 __dict__ ---> 如果有继承 -----> 父类的__dict__

　　　　　　如果一直没找到，抛异常，找到了，立即返回

4、方法的重写、覆盖override　

　　举例：　

class Anaimal:
    def shout(self):
        print('Animal')

class Cat(Anaimal):
    def shout(self):
        print(super())
        print(super(Cat, self))
        super().shout()
        super(Cat, self).shout()
        self.__class__.__base__.shout(self)
        print('miao')

# a = Anaimal()
# a.shout()
c = Cat()
c.shout()
# print(a.__dict__)
# print(c.__dict__)
# print(Anaimal.__dict__)
# print(Cat.__dict__)

　　对于类方法和静态方法也是一样的：

class Animal:
    @classmethod
    def class_method(cls):
        print('class_Animal')

    @staticmethod
    def static_method():
        print("static_Animal")

class Cat(Animal):pass
    # @classmethod
    # def class_method(cls):
    #     print('class_Cat')
    #
    # @staticmethod
    # def static_method():
    #     print("static_Cat")

c = Cat()
c.class_method()
c.static_method()

　　　

5、继承中的初始化

　　举例：

 

　　从上面的代码可以看出：

　　　　如果类B 定义时声明继承 类A，则在类B 中__bases__中是可以看到类A的，但是这和是否调用类A 的构造方法时两回事

　　　　如果B中调用了A 的构造方法，就可以拥有父类的属性了，

　　举例：

class A:
    def __init__(self, a, d=10):
        self.__d = d
        self.a = a

class B(A):
    def __init__(self, b, c):
        super().__init__(b+c, b-c)
        # 等价 A.__init__(self, b+c, b-c)
        self.b = b
        self.c = c

    def printv(self):
        print(self.b)
        print(self.a)
        print(self._A__d)

f = B(200, 300)
print(f.__dict__)
print(f.__class__.__bases__)
f.printv()

 　　

　　　　总结：

　　　　　　作为好习惯，如果分类定义了__init__方法，要在子类的__init__中调用它。显式的调用

　　　　除非：子类没有定义__init__，会隐式去调用或者继承父类的__init__，子类一旦定义了__init__，就不会自动调用父类的init

　　

　　如何正确的初始化：　

class Animal:
    def __init__(self, age):
        print('Animal')
        self.age = age

    def show(self):
        print(self.age)

class Cat(Animal):
    def __init__(self, age, weight):# 没有调用父类的init，这就导致没有实现继承效果
        print('Cat')       
        self.age = age + 1
        self.weight = weight

c = Cat(10, 5)
print(c.__dict__)
c.show()

print('-' * 30)
class Animal:
    def __init__(self, age):
        print('Animal')
        self.age = age

    def show(self):
        print(self.age)


class Cat(Animal):
    def __init__(self, age, weight):
        print('Cat')
        super().__init__(age)
        self.age = age + 1 # 覆盖之前的self.age
        self.weight = weight


c = Cat(10, 5)
print(c.__dict__)
c.show()


print('-' * 30)
class Animal:
    def __init__(self, age):
        print('Animal')
        self.age = age

    def show(self):
        print(self.age)


class Cat(Animal):
    def __init__(self, age, weight):
        print('Cat')
        self.age = age + 1
        self.weight = weight
        super().__init__(age)


c = Cat(10, 5)
print(c.__dict__)
c.show()

Cat
{'age': 11, 'weight': 5}
11
------------------------------
Cat
Animal
{'age': 11, 'weight': 5}
11
------------------------------
Cat
Animal
{'age': 10, 'weight': 5}
10

　　例子中打印10 的，原因看__dict__ 就知道了，因为父类Animal的show方法中_age会被释放为_Animal__age，因此。显式10，而不是11，这样的设计不会，子类应该显式自己的属性值最好

　　解决办法：

　　　　　　一个原则，自己的私有属性，就该自己的方法读取和修改，不要借助其他类的方法，即使是父类或者派生类。