15面向对象特性

卐風卐

面向对象特性

封装

• 在程序设计中，封装（Encapsulation）是对具体对象的一种抽象，即将某些部分隐藏起来，在程序外部看不到，其含义是其他程序无法调用。要了解封装，离不开“私有化”，就是将类或者是函数中的某些属性限制在某个区域之内，外部无法调用。
  
• 封装的作用：
  
  
  
  • 1、保护隐私（把不想别人知道的东西封装起来）
    
  • 2、隔离复杂度（比如：电视机，我们看见的就是一个黑匣子，其实里面有很多电器元件，对于用户来说，我们不需要清楚里面都有些元件，电视机把那些电器元件封装在黑匣子里，提供给用户的只是个按钮接口，通过按钮就能实现对电视机的操作。）
    
  
  
• 封装其实分为两个层面，但无论哪种层面的封装，都要对外界提供好访问你内部隐藏内容的接口（接口可以理解为入口，有了这个入口，使用者无需且不能够直接访问到内部隐藏的细节，只能走接口，并且我们可以在接口的实现上附加更多的处理逻辑，从而严格控制使用者的访问）
  
  
  
  • 第一个层面的封装（什么都不用做）：创建类和对象会分别创建二者的名称空间，我们只能用类名.或者obj.的方式去访问里面的名字，这本身就是一种封装。
    
  • 第二个层面的封装：类中把某些属性和方法隐藏起来(或者说定义成私有的)，只在类的内部使用、外部无法访问，或者留下少量接口（函数）供外部访问。
    
  
  

1. class Person:
2.     def __init__(self, name, age):
3.         self.__name = name
4.         self.age = age
6.     # 私有方法
7.     def __getname(self):
8.         # print(self.__name)
9.         print(f'{self.__name}')
11.     # 实例方法
12.     def printinfo(self):
13.         print(f'{self.__name},{self.age}')
15. p = Person('zhangsan', 18)
16. p.printinfo()

复制代码

继承

• 继承是面向对象程序设计的重要特征，也是实现代码复用的重要手段，如果一个新类继承自一个设计好的类，就直接具备了已有类的特征，就大大降低了工作难度。已有的类，我们称为父类或者基类，新的类，我们称为子类或者派生类。
  

单继承

单继承指的是子类只继承一个父类 当对象调用方法时，查找顺序先从自身类找，如果自身没找到，则去父类找，父类无，再到父类的父类找，直到object类，若还无，则报错。这也称为 深度优先机制。

1. # 单继承
2. class Grandfather:
3.     def __init__(self):
4.         print('Grandfather')
6.     def sleep(self):
7.         print("sleep")
9. class Father(Grandfather):
10.     def eat(self):
11.         print("eat")
13.     def drink(self):
14.         print("drink")
16. class Son(Father):
17.     def study_python(self):
18.         print("python")
20. s = Son()
21. s.study_python()
22. s.eat()
23. s.sleep()

复制代码

多继承

多继承指的是子类继承了多个父类。并且具有它们的特征。

1. """情景1"""
2. class Father1:
3.     def run(self):
4.         print("father1 run")
6. class Father2:
7.     def run(self):
8.         print("father2 run")
10. class Son(Father1, Father2):  # 拥有相同方法时，左边优先执行
11.     pass
13. s = Son()
14. s.run()

复制代码

1. """情景2"""
2. class Grandfather:
3.     def sleep(self):
4.         print("Grandfather sleep")
6. class Father1(Grandfather):
7.     def run(self):
8.         print("father1 run")
10. class Father2:
11.     def sleep(self):
12.         print(" Father2 sleep")
14. class Son(Father1, Father2):  # 必须要左边的执行完了,才会执行右边的父类
15.     pass
17. s = Son()
18. s.sleep()

复制代码

1. """情景3"""
2. class Grandfather1:
3.     def sleep(self):
4.         print("sleep 12")
6. class Father1(Grandfather1):
7.     def run(self):
8.         print("father1 run")
10. class Father2(Grandfather1):
11.     def sleep(self):
12.         print("sleep 6")
14. class Son(Father1, Father2):  # 如果同根的话，根是最后才执行的
15.     pass
17. s = Son()
18. s.sleep()
21. print(Son.__mro__)  # 通过mro方法可以程序执行或者继承顺序的情况
22. # (<class '__main__.Son'>, <class '__main__.Father1'>, <class '__main__.Father2'>, <class '__main__.Grandfather1'>, <class 'object'>)

复制代码

方法的重写

当子类与父类拥有同名称的方法时，子类对象调用该方法优先执行自身的方法。那么实际上就是子类的方法覆盖父类的方法，也称为重写。实际的开发中，遵循开放封闭原则。我们并不会完全的重写父类的方法，而是希望同时实现父类的功能。

1. # 相对而言是我们B的父类
2. class A:
3.     # init同时也能够被继承
4.     def __init__(self):
5.         print('A')
7.     def test(self):
8.         print("aaaa")
10. # B继承了A 子类
11. class B(A):
12.     def __init__(self):
13.         print('B')
14.         # A.__init__(self)
15.         super(B, self).__init__()
17.     # 子类重写父类的同名方法
18.     def test(self):
19.         print("bbbb")
20.         # 对该方法进行重写，同时实现子类和父类的功能 三个方法都可以
21.         # super(B, self).test()
22.         # super().test()
23.         # A.test(self)   # 通过类名.方法名 强写 不推荐
26. b = B()  # 创建了B的对象
27. b.test()  # bbbb
28. """
29. 若将test方法里的注释放开，则也会打印A中test方法中的aaaa
30. """

复制代码

多态

Python中函数的参数是没有类型限制的，所以多态在python中的体现并不是很严谨。多态的概念是应用于Java和C#这一类强类型语言中，而Python崇尚“鸭子类型”。python是弱语言类型。

• 多态（polymorphism）：指的是一类事物有多种形态，一个抽象类有多个子类（因而多态的概念依赖于继承），不同的子类对象调用相同的方法，产生不同的执行结果，多态可以增加代码的灵活度
  

1、实现多态的步骤：

1）定义一个父类（Base），实现某个方法（比如：run）
2）定义多个子类，在子类中重写父类的方法（run），每个子类run方法实现不同的功能
3）假设我们定义了一个函数，需要一个Base类型的对象的参数，那么调用函数的时候，传入Base类不同的子类对象，那么这个函数就会执行不同的功能，这就是多态的体现。

1. class Animal(object):
2.     """动物类"""
3.     def func(self):
4.         print('动物发出了声音')
6. class Cat(Animal):
7.     """猫类"""
8.     def func(self):
9.         print('喵 喵 喵')
11. class Dog(Animal):
12.     """狗类"""
13.     def func(self):
14.         print('汪 汪 汪 ')
16. class Hero:
17.     def func(self):
18.         print('这个是英雄类的方法，不是动物类的对象')
20. def work01(Animal):
21.     Animal.func()
24. work01(Dog())  # 传入的对象 结果：汪 汪 汪
25. work01(Animal())  # 动物发出了声音
26. # 传入不同的对象，产生不同的结果
27. # 调用灵活 更容易编写出通用的代码

复制代码

多态的意义：
(1)在程序运行过程中展现出动态的特性，在程序编译的时候无法知道调用哪个函数
(2)函数重写必须多态实现，否则没有意义
(3)多态是面向对象组件化程序设计的基础特性
注意点：Python中函数的参数是没有类型限制的，所以多态在python中的体现并不是很严谨。多态的概念是应用于Java和C#这一类强类型语言中，而Python崇尚“鸭子类型”。
鸭子类型

• 鸭子类型概念：他并不要求严格的继承体系，关注的不是对象的类型本身，而是它是否具有要调用的方法（行为）
  

1. class Duck:
2.     def quack(self):
3.         print("嘎嘎嘎嘎。。。。。")
5. class Bird:
6.     def quack(self):
7.         print("bird imitate duck....")
9. class geese:
10.     def quack(self):
11.         print("geese imitate duck....")
13. def in_the_forest(duck):
14.     duck.quack()
17. duck = Duck()
18. bird = Bird()
19. geese = geese()
20. for x in [duck, bird, geese]:
21.     in_the_forest(x)
22. """
23. 嘎嘎嘎嘎。。。。。
24. bird imitate duck....
25. geese imitate duck....
26. """

复制代码

来源:https://www.cnblogs.com/daguo118/p/17347492.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！