zoukankan      html  css  js  c++  java
  • 继承,抽象类,多态,封装

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

    初识继承:
    只执行本类的方法
    只执行父类的方法.
    既执行本类又执行父类的方法
    父类名.方法名(参数)
    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() #类的私有字段在生成的时候会自动改成 _类名__字段名
    

      

  • 相关阅读:
    Python获取Linux的家目录
    Python 批量安装包、查看当前程序依赖的包
    获取linux目录下最新的文件
    Linux破解navicat
    Linux添加PATH
    Linux下文件分析 | 命令行
    ROP | 蒸米 -x86
    Jarvis OJ | guess
    杂项入门
    Whale ctf | misc
  • 原文地址:https://www.cnblogs.com/luxiangyu111/p/9374314.html
Copyright © 2011-2022 走看看