继承:
继承的优点:
优化代码,节省代码.
提高代码的复用性.
提高代码的维护性.
让类与类之间发生关系.
初识继承:
只执行本类的方法
只执行父类的方法.
既执行本类又执行父类的方法
父类名.方法名(参数)
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() #类的私有字段在生成的时候会自动改成 _类名__字段名