组合、封装、多态、抽象类、鸭子类型

目录

• 1. 组合
  • 1. 什么是组合：
  • 2. 组合有什么用
  • 3. 如何实现组合
• 2. 封装
  • 1. 什么是封装
  • 2. 封装有什么用
  • 3. 如何实现封装
• 3. 访问限制机制
  • 1. 什么是访问限制机制
  • 2. 访问限制机制有什么用
  • 3. 如何访问以__开头的属性
• 4. property
  • 1. 什么是property
  • 2. property 有什么用
  • 3. 如何使用property
• 5. 多态
  • 1. 什么是多态
  • 2. 多态的作用
  • 3. 如何实现
• 6. 抽象类
  • 1. 什么是抽象类
  • 2. 有什么用
  • 3. 如何使用
• 7. 鸭子类型
• 8. 多态和多态性

1|01. 组合

1|11. 什么是组合：

• 组合指的是一个对象中的属性为另一个对象（就是把一个对象1赋值给了另一个对象2的一个属性，对象2就可以通过对象2.属性名.对象2中的属性名 ，来获取对象2 中的属性）
• 继承是类与类之间的关系，而组合是对象与对象之间的关系

1|22. 组合有什么用

• 组合的目的和继承一样，都是为了减少代码的冗余

1|33. 如何实现组合

class A:
    pass
class B:
    pass
a = A()
b = b()
a.obj = b #这样就实现了组合,a对象里的obj属性的属性值是对象b

2|02. 封装

2|11. 什么是封装

• 封装指的是把一堆属性放在一个对象中

2|22. 封装有什么用

• 封装方便了数据的存取，封装后，可以使用对象名.属性名 的方式获得属性值

2|33. 如何实现封装

• 在定义类后，实例化类产生一个对象，这个类和他继承的父类的内部的所有属性就会被封装在这个对象中。

3|03. 访问限制机制

3|11. 什么是访问限制机制

• 在类的内部，凡是以__开头的数据属性与方法属性，都会被python内部隐藏起来，让外部不能直接访问内部的__开头的属性

3|22. 访问限制机制有什么用

• 通过使用__来定义的属性，可以隐藏起来，不被外部直接调用。
• 好处： 对重要数据获取的逻辑更加严谨，进而保证数据的安全

3|33. 如何访问以__开头的属性

1. 在类的内部定义一个接口，在接口内做业务逻辑的处理，再把数据返回给调用者

2. 在类的外部使用，_类名__属性名直接访问这个以__开头的属性

   class A:
       def __init__(self,name)
       	self.__name = name
       def get_name(self):
           user_name = input('输入用户名：')
           if user_name == 'nick':
               print(self.__name)
   a = A('123')
   a.get_name()  # 方法一
   print(a._A__name) # 方法二
   

• 通过对属性名的前面加上__的方法，还可以实现，程序的按规定步骤运行。

  class ATM:
      # 1.插卡
      def __insert_card(self):
          print('插卡')
          pass
  
      # 2.输入密码
      def __input_pwd(self):
          print('密码验证')
          pass
  
      # 3.输入取款金额
      def __input_money(self):
          print('输入金额')
          pass
  
      # 4.开始吐钱
      def __get_money(self):
          print('执行吐钱')
          pass
  
      # 5.打印账单
      def __print_flow(self):
          print('打印账单')
          pass
  
      # 取钱直接接口
      def withdraw(self):
          self.__insert_card()
          self.__input_pwd()
          self.__input_money()
          self.__get_money()
          self.__print_flow()
          print('取款程序执行完毕!')
  
  atm = ATM()
  atm.withdraw()
  
  

4|04. property

4|11. 什么是property

• property是python内置的装饰器，主要是给类内部的方法使用。

4|22. property 有什么用

• 使用这个装饰器的方法，将类内部的一个 def 方法名() 变成了 def方法 在进行调用该方法的时候，不用再方法名后面加上括号。就是让他看上去从动词变成了名词。

4|33. 如何使用property

class A:
    
    @property
    def foo(self):
        print('daada')
a = A()
a.foo  # daada

5|05. 多态

5|11. 什么是多态

• 多态指的是同一种事物的多种形态

5|22. 多态的作用

• 父类: 定义一套统一的标准.
  子类: 遵循父类统一的标准（不是必须遵循，抽象类是必须遵循父类的一套标准）
• 统一子类内部的编写的规范, 为了让使用者更方便调用相同功能的方法

5|33. 如何实现

• 通过继承来实现

• 在python中,不会强制要求子类必须遵循父类的一套标准,所以出现了抽象类

6|06. 抽象类

6|11. 什么是抽象类

• abc模块 abstract_class

6|22. 有什么用

• 强制子类必须遵循父类的一套标准（子类中必须要有父类中被装饰的方法，可以改变这些方法的顺序，但是不能少，少了就会报错，也可有自己的新的方法）

6|33. 如何使用

• 1. 导入 abc 模块
  2. 父类加上括号，括号内要加上一些东西
  3. 加上装饰器

• import abc   # 1. 导入 abc 模块
  class Animal(metaclass=abc.ABCMeta): # 2. 父类加上括号，括号内要加上一些东西
  
      # 吃
      @abc.abstractmethod   # 3.加上装饰器
      def eat(self):
          pass
  
      # 喝
      @abc.abstractmethod
      def drink(self):
          pass
      # 叫
      @abc.abstractmethod
      def speak(self):
          pass
  
  # 猪
  class Pig(Animal):
      # 吃
      def eat(self):
          print('猪在吃饭')
          pass
  
      # 喝
      def drink(self):
          pass
  
      def speak(self):
          print('哼哼哼~~~')
  
      # 派生
      def run(self):
          pass
  
  pig = Pig()  # 只有实例化的时候才会检测抽象类。不符合的报错。没有实例化一定不会报错。
  

7|07. 鸭子类型

• 鸭子类型就是不通过继承，一个类自动的遵循某种标准，这样的类就可以叫做鸭子类型。

1.什么是鸭子类型?
在不知道当前对象是何物的情况下,但是你长得像鸭子,那么你就是鸭子类型.

在python中,不推荐使用抽象类强制限制子类的定义,但是推荐类都遵循鸭子类型.

• 继承:
  耦合性太高,程序的可扩展性差
• 鸭子类型:
  耦合度低,程序的可扩展性强

8|08. 多态和多态性

• 多态和多态性是两种不同的概念
• 多态性依赖于：继承
• 多态性：定义统一的接口，（类似抽型类中的统一的方法名）
• 多态：同一种事物的多种形态，动物分为人类，猪类（在定义角度） 多态性：一种调用方式，不同的执行效果

__EOF__

本文作者：BigSun丶
本文链接：https://www.cnblogs.com/Mcoming/p/11654688.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！