面向对象组合及三大特性

组合

在一个类中以另外一个类的对象作为数据属性，称为类的组合

class Role:
    def __init__(self, name, hp, ad):
        self.name = name
        self.hp = hp
        self.ad = ad
    def attack(self):
        pass
    def wea(self,w):
        self.w=w

class Weapon:
    def __init__(self,name,ad):
        self.name = name
        self.ad = ad
    def da(self,r1):
        print("{}得到了{}".format(r1.name,self.name))
r1=Role("亚瑟",1000,30)
w1=Weapon("大宝剑",50)
r1.wea(w1)
r1.w.da(r1)

组合的意义：
让类的对象与另一个类的对象产生关系，类与类产生关系。

继承

先抽象后继承

父类/超类/基类

子类/派生类

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

class Walkanimal:
    def __init__(self,name):
        self.name=name
    def walk(self):
        print("行走")
class Cat(Walkanimal):   #Walkanimal的派生类
    def catch_mouse(self):  #派生方法
        print("抓老鼠")
a=Cat("猫")
print(a.name)
a.walk()

当子类中有被调用的方法的时候，子类的对象直接选择子类中的方法，变量，父类中的方法不会被自动调用
如果我们既想执行子类的方法，也想执行父类的方法，那么要在子类中调用父类的方法

父类名.方法名（）

super（）.方法名（）

class A:
    def func(self):
        print("in A")
class B(A):
    def func(self,):
        print("in B")
        A.func(self)
# b1=B()
# b1.func()  # in B    in A


class A:
    def func(self):
        print("in A")
class B(A):
    def func(self,):
        print("in B")
        super().func()
b1=B()
b1.func()  # in B    in A
当用super时不用传入self

面试题

class Foo:
    def __init__(self):
        self.func()
    def func(self):
        print('in Foo')

class Son(Foo):
    def func(self):
        print("in Son")
s1=Son()     #in Son



class Foo:
    def __init__(self):
        self.func()
    def func(self):
        print('in Foo')

class Son(Foo):
    pass
s1=Son()    #in Foo

当self去调用某个方法的时候，不要看self在哪个类里，要看self到底是谁
继承与重用：子类中可以用父类中的属性和方法

继承与派生：子类在父类的基础上又创建了自己需要的方法和属性

父类中有的属性和方法，子类没有    ：子类对象直接调用就可以

父类中有，子类中也有：子类直接调用子类的

子类调用子类，同时调用父类         父类名.方法名（）

class Foo:
    country="china"
    def func(self):
        print(self.country)
class Son(Foo):
    country="english"
s=Son()
s.func()    #english

抽象类：抽象类是一个规范，它基本不会实现具体的功能，抽象类不能被实例化
from abc import ABCMeta,absttractmethod ,metaclass=ABCMeta

接口

多继承

新式类和经典类

python3中都是经典类

所有的新式类都有一个默认的父类：object

新式类搜索用的是广度优先算法，经典类用的是深度优先

新式类中采用mro和super

super不是单纯的找父类，而是遵循mro顺序

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=D()
d.func()   #ACBD

多态

一个类的多种形态，是通过继承实现

为什么要把多态单独列出来

class Animal:
    pass
class Dog(Animal):
    pass
class Cat(Animal):
    pass

在java中，函数的参数需要注明数据类型，当有两个以上的参数的时候，就需要有一个父类来统一子类对象的数据类型

在python中，函数的参数不需要注明数据类型，所以不需要通过继承来统一子类的数据类型

在python中，都有一个默认的父类object，所以说python处处是多态

鸭子类型：不是通过继承来实现多态，而是通过模糊的概念来判断。print，len是通过模糊的概念来判断某个数据类型能不能作为函数的参数。

封装

广义上的封装：在实例化一个对象的时候，会产生一个空间来存储属性

只有这个类的对象可以使用定义在类的方法

狭义上的封装：隐藏类的属性和方法，仅提供接口

在类的外部不能使用私有变量

类的私有成员：

私有的静态属性，私有的对象属性，私有的方法

从变成规范的角度出发，我们不能在类的外部使用私有变量

class Goods:
    __count=0.8
    def __init__(self,price):
        self.__price=price
    def price(self):
        return self.__price
g=Goods(10)
# print(g.__count)   #报错，类的私有变量不能在外部使用
# print(g.__price)     #报错
print(g.price())      #10

为什么要有私有变量？

1，我们不想让人看到这个值

2，我们不想让人修改这个值

3，修改这个值的时候有一些限制，保护数据的安全

4，有些方法和属性不希望子类继承

私有变量不能被子类继承

class Animal:
    __name="animal"
class Dog(Animal):
    pass
d=Dog()
print(d.__name)   #报错

property  把方法伪装成属性

class Goods:
    def __init__(self,name,price):
        self.name=name
        self.__price=price
    @property
    def price(self):
        return self.__price
    @price.setter
    def price(self,new_price):
        self.__price=new_price
        return self.__price
a=Goods('apple',10)
print(a.price)   #10
a.price=20
print(a.price)   #20