python_面向对象-继承组合

一、组合

　　1、一个类的对象作为另一个类的对象的属性

　　2、让两个类之间产生关系

　　3、增加类的功能，提高代码的重用性

总结：静态属性就是类的属性，所有的对象共享这个变量

　　　对象名去修改类的属性，会在对象空间中又创建一个属性，而不能修改类中属性的值

　　   操作静态属性应该用类名操作

　　   当类中的属性发生改变的时候，而对象中没有同名的属性，方法的时候，对象使用属性名会跟着类中变量走

　　　只要某个对象的属性被直接复制，那么一定是对象的命名空间发生变化

　　　class Foo:

　　　　　count = 0

　　　　　def __init__(self):

　　　　　　Foo.count += 1

　　　f1 = Foo()

　　　f2 = Foo()

　　　f3 = Foo()

　　　print(Foo.count)  # 3统计类调用了几次

　　　class Fun1:

　　　　　count = [0]

　　　　　def __init__(self):

　　　　　　　pass

　　　f1 = Fun1()

　　　f1.count[0] = 1

　　　print(f1.count[0])  #1

　　　print(Fun1.count[0])　#1

　　　f1.count = 2

　　　print(f1.count) #2

　　　print(Fun1.count) #[1]

二、继承

　　1、重用性

　　　　父类中所有属性和方法都可以被子类使用

　　class Animal:

　　　　def __init__(self,name,age,food):

　　　　　　self.name = name

　　　　　　self.age = age

　　　　def eat(self):

　　　　　　print('%s吃%s' %(self.name,self.food))

　　　　def drink(self):

　　　　　　print('%s喝水' %(self.name))

　　class Dog(Animal):

　　　　def __init__(self,name,age,food):

　　　　　　super().__init__(name,age,food)

　　class Cat(Animal):

　　　　def __init__(self,name,age,food):

　　　　　　super().__init__(name,age,food)

　　dog1 = Dog('小黑',5,'狗粮')

　　dog1.eat()

　　car1 = Car('小花',3,'猫粮')

　　car1.drink()

　　2、派生

　　　　子类在父类的基础上又创建了自己需要的属性与方法

　　　　当子类中有要被调用的方法和变量的时候，子类的对象会直接选择子类中的方法和变量

　　　　父类中的方法不会被自动执行

　　　　如果我们既想要执行子类的方法，又想要执行父类的方法，那么需要在子类中调用父类的方法

　　　　父类名.方法名(self)            super().方法名()

　　　　当self在调用某个方法时 ，不要看self在哪个类里，要看self是谁　

class Animal:
    def __init__(self,name,food,language):
        self.name = name
        self.food = food
        self.language = language

    def eat(self):
        print('吃%s' %self.food)

    def drink(self):
        print('%s喝水' %self.name)

class Dog(Animal):
    def look_after_house(self):
        print('看门')

    def eat(self):
        # super(Dog, self).eat()
        Animal.eat(self)
        self.drink()

class Cat(Animal):
    def __init__(self,name,food,language,eye_color):
        self.eye_color = eye_color

    def eat(self):
        self.weight = 10  #派生属性

    def catch_mouse(self):  #派生方法
        print('抓老鼠')

xhei = Dog('小黑','狗粮','汪汪')
xhua = Cat('小花','猫粮','喵喵','蓝色')
xhei.eat()
xhua.eat()
print(xhua.weight)
xhua.catch_mouse()

　　

　　3、抽象

　　　　抽象类是一个规范，它基本不会实现具体的功能，抽象类不能被实例化

　　　　多人开发，复杂的需求，后期扩展

　　　　抽象类的语法：

　　　　　　from abc import ABCMeta,abstractmethod

　　　　　　在这个类创建的时候制定metaclass = ABCMeta

　　　　　　在你希望子类实现的方法上加一个@abstractmethod装饰器

　　　　使用抽象类

　　　　　　继承这个类

　　　　　　必须实现这个类中被@abstractmethod装饰器装饰的方法

from abc import ABCMeta,abstractmethod
class Payment(metaclass=ABCMeta):
    @abstractmethod
    def pay(self):
        pass

class Alipay(Payment):
    def pay(self,money):
        print('使用支付宝支付了%s元' %money)

class WechatPay(Payment):
    def pay(self,money):
        print('使用微信支付了%s元' %money)

a = Alipay()
a.pay(34)
w = WechatPay()
w.pay(29)

　　

　　4、多继承

class Animal:
    def __init__(self,name):
        self.name = name

class FlyAnial(Animal):
    def fly(self):
        print('%s在飞' %(self.name))

class WalkAnimal(Animal):
    def walk(self):
        print('%s在走路' %(self.name))

class SwimAnimal(Animal):
    def swim(self):
        print('%s在游泳' %(self.name))


class Tiger(WalkAnimal,SwimAnimal):
    pass

class Swan(FlyAnial,WalkAnimal,SwimAnimal):
    pass

class Parrot(FlyAnial,WalkAnimal):
    def talk(self):
        print('%s在说话' %(self.name))

swan = Swan('天鹅')
swan.fly()
swan.walk()
swan.swim()

　　5、经典类与新式类

　　　　在python3.x中所有的类都是新式类，默认继承object,继承顺序遵循广度优先原则

　　　　在python2.x中既有经典类，又有新式类，经典类的继成顺序遵循深度优先原则

　　　　只有继承了object的类才是新式类

　　　　只有在新式类中才有mro方法和super方法，super方法不是单纯的找父类，而是遵循mro

class A:
    def test(self):
        print('A')

class B(A):
    def test(self):
        print('B')

class C(B):
    def test(self):
        print('c')

class D(C):
    def tets(self):
        print('d')

class F(D,C):
    def test(self):
        print('f')

print(F.mro())  #线性列表，继承顺序
# [<class '__main__.F'>, <class '__main__.D'>, <class '__main__.C'>, 
# <class '__main__.B'>, <class '__main__.A'>, <class 'object'>]

class A:
    def func(self):
        print('A')

class B(A):
    def func(self):
        super().func()
        print('B')

class C(A):
    def func(self):
        super().func()
        print('C')

class D(B,C):
    def func(self):
        super().func()
        print('D')

D().func()
B().func()

#A C B D
#A B