抽象类,接口类,多态,封装

1,抽象类,接口类:制定一个规范.

1.1>继承有两种用途:1>继承基类的方法,并且做出自己的改变或者拓展(代码重用) 2>声明某个子类兼容于基类,定义一个借口类Interface,接口类中定义了一些接口名(就是函数名),并且为实现借口的功能,子类继承接口类,并且实现接口中的功能
1.2>抽象类:抽象类是一个特殊的类,他的特殊之处在于只能被继承,不能被实例化

import abc
class Payment(metaclass=abc.ABCMeta):
    all_type = "file"
    @abc.abstractclassmethod  # 定义抽象方法
    def pay(cls):  # 指定一个规范
        pass
    @abc.abstractclassmethod
    def func(cls):
        pass


class Alipay(Payment):
    def __init__(self, money):
        self.money = money
    
    def pay(self):
        print("使用京东支付了%s" % self.money)
        

class JingDDong(Payment):
    
    def __init__(self, money):
        self.money = money
    
    def pay(self):
        print("使用京东支付了%s" % self.money)


class Wechat(Payment):
    def __init__(self, money):
        self.money = money
    
    def pay(self):
        print("用微信支付了%s" % self.money)


a1 = Alipay(300)
b1 = JingDDong(200)
c1 = Wechat(100)


def pay(obj):  # obj实例化对象
    obj.pay()  # 归一化设计(对象调用父类中的方法)
pay(a1)
pay(b1)
pay(c1)

2,多态:python中处处是多态(是有他的弱类型语言决定的,也又他的灵活性的体现)

在python中,不管是什么类型,传入函数,封装到对象中都可以
python有多态,值不过处处体现,也就不提多态的概念了,他有鸭子类型
鸭子类型:具有相同属性或特征的类称为互为鸭子类型

class Str:
    def index(self):
        pass
class Lst:
    def index(self):
        pass
class Tuple:
    def index(self):
        pass

字符串,列表,元组他们共有的特性是都有index索引

3,封装:就是把把属性等内容封装起来,以后再去调用封装起来的内容

3.1>广义的封装:实例化一个对象,给对象空间封装一些属性

class Person:
    def __init__(self, name, age, sex, hobby ):
        self.name = name
        self.age = age
        self.sex = sex
        self.hobby = hobby
# 以上是给name, age, sex, hobby广义封装了属性

3.2>狭义的封装:私有制
- 私有制成员:私有静态字段,私有放法,私有对象属性
- 3.2.1>私有静态字段

class A:
    __money = 1000
    def __func1(self):
        print("随心所欲")
    def func2(self):
        print(A.__money)
class B(A):
    name = "老郑"
    __age = 500
    def func3(self):
        print(self.__money)
        print("in B")
    def func4(self):
        print(self.__age)
        print("in C")
b = B()
print(b.__money)  # 对象不能访问父类的私有字段
print(b.__age)  # 对象不能访问子类的私有字段
b.func4()  # 对象可以通过子类的方法访问子类的私有静态字段
b.func3()  # 对象不能通过子类的方法访问父类的私有静态字段
b.func2()  # 对象可以通过访问父类的方法去访问父类的私有静态字段

3.2.2>私有方法

class A:
    __money = 1000

    def __func1(self):
        print("随心所欲")

    def func2(self):
        self.__func1()
        print(A.__money)

class B(A):
    name = "老郑"
    __age = 500

    def func3(self):
        print(self.__money)
        print("IN B")

    def func4(self):
        print(self.__age)
        print("IN  C")

    def __func5(self):
        print("心随我动")

    def func6(self):
        self.__func5()
        print("心随我动")


b = B()
b.__func5()  # 对象不能访问子类(本类)的私有方法
print(B.__func5)  # 子类名(本类)不能访问本类的私有方法
b.fonc6()  # 象可以通过本类(子类)的方法访问本类(子类)的私有方法
b.func2()  # 对象可以通过父类的方法去访问父类的私有方法
A.__func1()  # 父类名不能访问父类的私有方法
B.__func5()  # 子类名(本类)不能访问子类的私有方法

3.2.3>私有对象属性

class A:
    def __init__(self):
        self.__name = "老郑"
        self.__age = 28

    def func1(self):
        print("self.__name")


class B(A):
    def __init__(self):
        self.__sex = "女"
        self.__hobby = "闹腾"

    def func2(self):
        print(self.__sex)

    def func3(self):
        print(self.__age)
b = B()
print(b.__sex)  # 对象不能再外部访问子类(本类)的私有对象属性
print(b.__name)  # 对象不能在外部访问父类的私有对象属性
print(B.__hobby)  # 子类不能访问子类(本类)的私有对象属性
print(A.__hobby)  # 父类不能访问父类(本类)的私有对象属性
b.func2()  # 对象可以同过子类的方法来访问子类的私有对象的属性
b.func3()  # 对象不能通过子类的方法去访问父类的私有属性
b.func1()  # 对象可以通过父类的方法去访问父类的私有对象属性

对于这些私有成员,他们只能在类的内部使用,不能在类的外部使用,或者派生来中使用

抽象类,接口类,多态,封装

帅爆太阳的男人