我的Python学习笔记--面向对象

定 义

＞　　把数据及对数据的操作方法放在一起，作为一个相互依存的整体–对象。对同类对象抽象其共性，形成类。类中的大多数数据，只能在本类的方法进行处理。类通过一个简单的外部接口与外界发生关系，对象与对象之间通过消息进行通信。程序流程由用户在使用中决定。简单讲就是说万物皆对象。

面向对象的三大特性

1. 封装

利用抽象数据类型将基本数据的操作封装在一起，使其构成一个不可分割的独立实体。数据被保护在抽象数据类型的内部，使其尽可能的隐藏内部的细节，只保留一些接口使之与外部发生联系。用户无需知道对象内部的细节，但可以通过对象对外提供的接口来访问该对象。

• 减少代码的耦合性,可以独立的开发测试和优化
• 减轻维护的负担,可以更容易的被理解,调试中不影响其它模块的开发
• 调试中更容易定位需要调试的模块所在
• 提高了复用性

2. 继承

在程序中，继承描述的是多个类之间的所属关系。如果一个类A里面的属性和方法可以复用，则可以通过继承的方式，传递到类B里。那么类A就是基类，也叫做父类；类B就是派生类，也叫做子类。

• 父类里没有的方法，在子类中有了，这样的方法就叫做派生方法。
• 父类里有，子类也有的方法，就叫做方法的重写（把父类里的方法重写）
  注意的几个概念

1. 子类可以使用父类的所有属性和方法
2. 如果子类有自己的方法，就执行自己的；如果子类没有自己的方法，就会找父类的。
3. 如果子类里面没有找到，父类里也没有找到，就会报错
4. 如果子类中实现了调用父类的方法
   　　　　在类内：super(子类,self).方法名() supper().init(参数)
   　　　　在类外：super(子类名,对象名).方法名()

实际运用 eg.1:

• 主动报错

# 有时候写的时候会把方法写错，自己定义一个主动报错
# 手动报异常：NotImplementedError来解决开发中遇到的问题


class Payment:
    def pay(self):
        raise NotImplementedError  # 主动让程序报错


class Wechatpay(Payment):  # 微信支付
    def pay(self, money):  # 重写父类方法
        print('微信支付了%s元' % money)


class QQchatpay(Payment):  # QQ支付
    def fuqian(self, money):
        print('QQ支付了%s元' % money)


p = Wechatpay()
p.pay(200)  # 不报错
q = QQchatpay()  # 不报错
q.pay()  # 报错

实际运用 eg.2:

• 只允许子类调用同名方法,也就是接口类.

# 接口类（就是为了提供标准，约束后面的子类）
from abc import ABCMeta, abstractmethod

class Payment(metaclass=ABCMeta):
    @abstractmethod
    def pay(self, money):
        pass

class Wechatpay(Payment):
    def fuqian(self, money):
        '''
        实现了pay的功能，但是方法名字不一样,不可调用
        '''
        print('微信支付了%s元' % money)

class Alipay:
    def pay(self, money):
        print('支付宝  支付了%s' % money)


# p = Wechatpay() #报错了（因为上面定义了一个接口类，接口类里面
# 定义了一个pay方法，而在下面的Wechatpay方法里没有pay方法，不能
# 调用，在接口类里面约束一下，接口类里的pay方法里面不能写其他，直接pass）
ali = Alipay()
ali.pay(200)
pay = Payment()  # 报错,接口类不能被实例化

接口也就是做约束，让下面的类的方法都按照接口类中给出的方法去定义。如果接口类里面有的方法类里面没有，那么那个类就不能被实例化。
继承的第二种含义非常重要。它又叫“接口继承”。
接口继承实质上是要求“做出一个良好的抽象，这个抽象规定了一个兼容接口，使得外部调用者无需关心具体细节，可一视同仁的处理实现了特定接口的所有对象”——这在程序设计上，叫做归一化。

这里又引出了一个抽象类:

from abc import abstractmethod, ABCMeta

class Payment(metaclass=ABCMeta):  
    @abstractmethod
    def pay(self):
        raise NotImplemented  # 未实现这个方法就会报错

class Wechat(Payment):
    def pay(self, money):
        print('已经用微信支付了%s元' % money)

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

class Applepay(Payment):
    def fuqian(self, money):
        print('已经用Applepay支付了%s元' % money)

def pay(pay_obj, money):  # 统一支付入口,这里就是多态的体现
    pay_obj.pay(money) 

wechat = Wechat()
ali = Alipay()
apple_pay = Applepay()

pay(wechat, 200)
pay(ali, 300)
pay(apple_pay, 100)

抽象类和接口类的相同点：都是用来做约束的，都不能被实例化

抽象类和接口类的使用：
当几个子类的父类有相同的功能需要被实现的时候就用抽象类
当几个子类有相同的功能，但是实现各不相同的时候就用接口类

抽象类实例

from abc import abstractmethod, ABCMeta

class Swim_Animal(metaclass=ABCMeta):
    @abstractmethod
    def swim(self):
        pass

class Walk_Animal(metaclass=ABCMeta):
    @abstractmethod
    def walk(self):
        pass

class Fly_Animal(metaclass=ABCMeta):
    @abstractmethod
    def fly(self):
        pass

class Tiger(Walk_Animal, Swim_Animal):
    def walk(self):
        print('Tigers can walk!')
    def swim(self):
        print('Tigers can swim!')

class Swan(Walk_Animal, Fly_Animal, Swim_Animal):
    pass

tiger = Tiger()
tiger.walk()
tiger.swim()
# swan = Swan()
# swan.wlak() # 不能直接调用,必须重写

继承要学的还有一部分，回头再继续深入吧．．．

3. 多态

多态性是指具有不同功能的函数可以使用相同的函数名，这样就可以用一个函数名调用不同内容的函数。在面向对象方法中一般是这样表述多态性：向不同的对象发送同一条消息，不同的对象在接收时会产生不同的行为（即方法）。也就是说，每个对象可以用自己的方式去响应共同的消息。所谓消息，就是调用函数，不同的行为就是指不同的实现，即执行不同的函数。

简单来说,我个人理解为调用方法名相同,但是实际调用的不是一个类里的方法

def foo(func, a):  
	func.foo(a) 

一个接口函数 多种实现

实例在前面的抽象类实例里面有

面向对象暂时先记到这里了