继承,抽象类,多态,封装

继承:
　　继承的优点:

　　　　　　优化代码,节省代码.
　　　　　　提高代码的复用性.
　　　　　　提高代码的维护性.
　　　　　　让类与类之间发生关系.

    初识继承:
        只执行本类的方法
        只执行父类的方法.
        既执行本类又执行父类的方法
            父类名.方法名(参数)
            super().方法名(参数(self自动传值))

    单继承,多继承.
    类:新式类,经典类.

    单继承;
        新式类经典类一样.
    多继承:
        新式类:广度优先  类名.mro()查询类的查找顺序
        经典类:深度优先.
抽象类:

　　python 没有接口这个概念
   接口类,抽象类: 制定一个规范.

单继承:

class Animal:
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
    def run(self):
        print('就爱乱跑')
    def sleep(self):
        print('%s就爱睡觉' % self.name)

class Dog(Animal):
    def __init__(self):
       pass
class Cat(Animal):
    def __init__(self):
        pass
class Chick(Animal): #继承Animal类
    def __init__(self,name,age,sex,wing):
        # Animal.__init__(self,name,age,sex)  #一般不用类名调用父类内容
        super(Chick,self).__init__(name,age,sex) #调用父类方法 super内容可省略,后面要对应传参
        self.wing=wing

    def sleep(self):
        super().sleep()  #调用父类函数 self参数自动传
        print('%s还挺好看' % self.name)

c1=Chick('bitch',20,'女','隐形的翅膀')
print(c1.__dict__)
c1.sleep()

　　

多继承:

class H:
    def bar(self):
        print('F.bar')
class G(H):
    def bar(self):
        print('F.bar')
class F(H):
    def bar(self):
        print('F.bar')
class E(G):
    def bar(self):
        print('E.bar')
class D(F):
    def bar(self):
        print('D.bar')
class C(E):
    def bar(self):
        print('C.bar')
class B(D):
    def bar(self):
        print('B.bar')
class A(B,C,D):
    def bar(self):
        print('A.bar')
a = A()
print(A.mro()) #查询查找顺序 a→b→c→d→f→e→g→h

　　

抽象类:

from abc import ABCMeta,abstractmethod
class Parent(metaclass=ABCMeta): #抽象类 实际内容可有可无
    @abstractmethod
    def pay(self):pass   #制定规范,强制执行  本类的所有子类都要有pay()方法

class Alipay(Parent):
    def __init__(self,money):
        self.money=money

    def pay(self):
        print('使用支付宝支付了%s元' % self.money)
class Jdpay(Parent):
    def __init__(self,money):
        self.money=money
    def pay(self):
        print('使用京东支付支付了%s元' % self.money)
class Wechat(Parent):
    def __init__(self,money):
        self.money=money
    # def huaqian(self):pass # 必须要有pay方法,否则会报错
    def pay(self):
        print('使用微信支付支付了%s元' % self.money)
def pay(obj):
    obj.pay() #归一化设计,统一接口
p1=Alipay(100)
# p1.pay()
p2=Jdpay(200)
# p2.pay()
pay(p1)
pay(p2)
p3=Wechat(256)
pay(p3)

　　

多态:
　　Python处处是多态,所有没有专门的多态概念
封装:

    广义的封装: 实例化一个对象,给对象空间封装一些属性.
    狭义的封装: 私有制.
        私有成员:私有静态字段,私有方法,私有对象属性

私有静态字段

class B:
    __money = 100000

class A(B):
    name = 'alex'
    __age = 1000

    def func(self):
        print(self.__age)
        print(A.__age)    # 对于私有静态字段,类的内部可以访问.
        print('func....')
    def func1(self):
        print(self.__money)
        print(A.__money)
a1 = A()
print(a1.name)
print(A.name)

　　

print(a1.__age)  # 实例化对象不能访问私有静态字段
print(A.__age)  # 类名不能访问私有静态字段
对于私有静态字段,类的外部不能访问.

a1.func()

对于私有静态字段,类的内部可以访问.

a1.func1()

对于私有静态字段来说,只能在本类中内部访问,类的外部,派生类均不可访问.

可以访问,但应尽量避免使用.
print(A._A__age)
print(A.__dict__)

私有方法

class B:
    __money = 100000
    def __f1(self):
        print('B')

class A(B):
    name = 'alex'

    def __func(self):
        print('func....')

    def func1(self):
        # self.__func()   # 类的内部可以访问
        self.__f1()
a1 = A()
a1.__func()  # 类外部不能访问
a1.func1()  # 类的内部可以访问
a1.func1()  # 类的派生类也不能访问.

　　

私有封装补充:

 class Parent:
     def __func(self):  #内部保存的是_Parent__func()
         print('in Parent func')

     def __init__(self):
         self.__func() #实际执行 _Parent__func()

 class Son(Parent):
     def __func(self): #内部保存的是_Son__func()
         print('in Son func')

 son1 = Son() #类的私有字段在生成的时候会自动改成 _类名__字段名