首页 > 其他 > 详细

面向对象的三大特性:继承、封装、多态

时间:2020-01-28 17:43:40      阅读:366      评论:0      收藏:0      [点我收藏+]

标签:执行   使用   面向对象思想   __main__   固定   码代码   

一、python面向对象的三大特性:继承、封装、多态

  封装:把很多数据封装到一个对象中。把固定功能的代码封装到一个代码代码块、函数、对象、打包成模块。这都属于封装的思想。具体的情况具体分析,比如,你写了一个很NB的函数,那这个也可以被称之为封装。在面向对象思想中,是把一些看似无关紧要的内容组合到一起统一进行存储和使用,这就是封装。

  继承:子类可以自动拥有父类中除了私有属性外的其他所有内容。先有父类再有子类。在python中实现继承非常简单,在声明类的时候,在类名后面添加一个小括号,就可以完成继承关系。

  多态:同一个对象,多种形态。

二、封装

封装:将内容封装到某个地方,以后再去调用被封装在某处的内容

# 创建类
class Foo():
    def __init__(self,name,age):
        self.name = name
        self.age = age
        
    def detail(self):
        print(self.name)
        print(self.age)
# 根据类Foo创建对象
# 自动执行Foo类的__init__方法
obj1 = Foo("agen",15)
print(obj1.name)  # 直接调用obj1对象的name属性
print(obj1.age)   # 直接调用obj1对象的age属性
# 通过self间接调用被封装的内容
obj1.detail()   # Python默认会将obj1传给self参数,所以此时方法内部的 self = obj1


# 根据类Foo创建对象
# 自动执行Foo类的__init__方法
obj2 = Foo("alex",15)
print(obj2.name)   # 直接调用obj1对象的name属性
print(obj2.age)   # 直接调用obj1对象的age属性
# 通过self间接调用被封装的内容
obj2.detail()   # Python默认会将obj1传给self参数,所以此时方法内部的 self = obj1

对于面向对象的封装来说,其实就是使用构造方法将内容封装到对象中,然后通过对象直接或者self间接获取封装的内容。

二、多态

多态:同一个对象,多种形态。python默认支持多态。(创建一个变量a=10,此时a是整数类型,通过程序让a="alex",a又变成了字符串类型,这就是多态性,同一个变量可以是多种形态)

鸭子类型:长得像鸭子,走路像鸭子,叫声也像鸭子,那么你就是鸭子。

三、类的约束

对类的约束有两种:

1、提取父类,然后在父类中定义好方法。在这个方法中什么都不用干,就抛一个异常就可以了,这样所有的子类都必须重写这个方法,否则,访问的时候出错。

2、使用元类来描述父类,在元类中给出一个抽象方方法,这样子类就不得不给出抽象方法的具体实现,也可以起到约束的效果。

第一种方法解决:

class Payment:
    """
    此类什么都不做,就是制定一个标准,谁继承我,必须定义我里面的方法。
    """
    def pay(self,money):
        raise Exception("你没有实现pay方法")

class QQpay(Payment):
    def pay(self,money):
        print(使用qq支付%s元 % money)

class Alipay(Payment):
    def pay(self,money):
        print(使用阿里支付%s元 % money)

class Wechatpay(Payment):
    def fuqian(self,money):
        print(使用微信支付%s元 % money)


def pay(obj,money):
    obj.pay(money)

a = Alipay()
b = QQpay()
c = Wechatpay()
pay(a,100)
pay(b,200)
pay(c,300)

第二种方法:引入抽象类的概念处理。

from abc import ABCMeta,abstractmethod
class Payment(metaclass=ABCMeta):    # 抽象类 接口类  规范和约束  metaclass指定的是一个元类
    @abstractmethod
    def pay(self):pass  # 抽象方法

class Alipay(Payment):
    def pay(self,money):
        print(使用支付宝支付了%s元%money)

class QQpay(Payment):
    def pay(self,money):
        print(使用qq支付了%s元%money)

class Wechatpay(Payment):
    # def pay(self,money):
    #     print(‘使用微信支付了%s元‘%money)
    def recharge(self):pass

def pay(a,money):
    a.pay(money)

a = Alipay()
a.pay(100)
pay(a,100)    # 归一化设计:不管是哪一个类的对象,都调用同一个函数去完成相似的功能
q = QQpay()
q.pay(100)
pay(q,100)
w = Wechatpay()
pay(w,100)   # 到用的时候才会报错



# 抽象类和接口类做的事情 :建立规范
# 制定一个类的metaclass是ABCMeta,
# 那么这个类就变成了一个抽象类(接口类)
# 这个类的主要功能就是建立一个规范

四、super()深入学习

super是严格按照类的继承顺序执行!!!

class A:
    def f1(self):
        print(in A f1)
    
    def f2(self):
        print(in A f2)


class Foo(A):
    def f1(self):
        super().f2()
        print(in A Foo)
        
        
obj = Foo()
obj.f1()
class A:
    def f1(self):
        print(in A)

class Foo(A):
    def f1(self):
        super().f1()
        print(in Foo)

class Bar(A):
    def f1(self):
        print(in Bar)

class Info(Foo,Bar):
    def f1(self):
        super().f1()
        print(in Info f1)

obj = Info()
obj.f1()

‘‘‘
in Bar
in Foo
in Info f1
‘‘‘
print(Info.mro())  # [<class ‘__main__.Info‘>, <class ‘__main__.Foo‘>, <class ‘__main__.Bar‘>, <class ‘__main__.A‘>, <class ‘object‘>]
class A:
    def f1(self):
        print(in A)

class Foo(A):
    def f1(self):
        super().f1()
        print(in Foo)

class Bar(A):
    def f1(self):
        print(in Bar)

class Info(Foo,Bar):
    def f1(self):
        super(Foo,self).f1()
        print(in Info f1)

obj = Info()
obj.f1()

 

面向对象的三大特性:继承、封装、多态

标签:执行   使用   面向对象思想   __main__   固定   码代码   

原文:https://www.cnblogs.com/youhongliang/p/12238390.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
? 2014 bubuko.com 版权所有 鲁ICP备09046678号-4
打开技术之扣,分享程序人生!
             

鲁公网安备 37021202000002号

快三必中的十大规律