面向对象编程 2

1. 封装

1.1 封装的定义

  根据需求将属性和方法封装到一个抽象的类中
  在使用的时候，只要按照自己的需求去调用，不必了解实现的细节

1.2 封装的含义

  封装是面向对象编程的三大特征之一
  封装有两方面的含义：
  1、将数据（属性）和行为（方法）包装到类对象中，在方法内部对属性进行操作，在类对象的外部调用方法。这样，无需关心方法内部的具体实现细节，从而隔离了复杂度。
  2、在类对象的内部通过访问控制吧默写属性和方法隐藏起来，不允许在类对象的外部直接访问，而是在类对象内部对外提供公开的借口方法（例如getter和setter）以访问隐藏的信息。这样，就对隐藏的信息进行了保护。

class Student(object):
    def __init__(self):
        self._score = 90
   
   def get_score(self)：
       return self._score

   def set_score(self)：
       if 0 <= score <= 100:
           self.score = score
       else:
           raise ValueEorre:"成绩必须在0~100之间"

2. 继承

  当几个类对象中有共同的属性和方法时，就可以把这些属性和方法抽象并提取到一个基类中，每个类对象特有的属性和方法还是在本类对象中定义，这样，只需要让每个类对象都继承这个基类，就可以访问基类中的属性和方法了。继承基类的每个类对象被称为派生类。基类也被称为父类或超类，派生类也被称为子类。

  Python中的所有类对象都继承自一一个统一的基类: object。 这就是为什么我们在定义类对象时要在类名后面添加( object)。

  除了封装，继承也是面向对象编程的三大特征之-。继承是实现代码复用的重要手段。

2.1 单继承

  子类只有一个直接父类为单继承
  假设子类和父类分别为ChildClass和ParentClass，子类继承父类的语法格式为：

class ChildClass(ParentClass):
    pass

2.2 多继承

  子类有多个直接父类时成为多继承

class ChildClass(ParentClass1, ParentClass2):
    pass

  子类会继承所有父类（包括所有父类和所有间接父类）的所有属性和行为.

3. 重写

  如果子类对继承自父类的某个属性或方法不满意，可以在子类中对其进行重写，从而提供自定义的实现。重写的方式为：在子类中蒂尼与父类中同名的属性或方法（包括装饰器）。
  子类重写父类的属性后，通过子类或其实例对象只能访问子类中重写后的属性，而无法再访问父类被重写的属性。
  子类重写父类的方法后，通过子类或其实例对象只能调用子类中重写后的方法，而无法再调用父类中被重写的方法。
  父类中被重写的名为xxx的方法，在子类重写后的方法中可以通过super().xxx()进行调用。

class ParentClass (object) :
	ca="ca(父类)”

	def_ init__ (self):
		print("_ init_ ()被调用了 (父类)”)

	def im(self):
		print(" im()被调用了(父类) ")

	@classmethod
	def cm(cls):
		print(" cm()被调用了(父类)”)


class ChildClass(ParentClass) :
	ca ="ca (子类)"

	def _ init_ (self):
		print("_ init ()被调用了(子类)”)

	def im(self):
		print("im()被调用了(子类) ")

	@classmethod
	def cm(cls) :
		print("cm()被调用了(子类) ")

cc = ChildClass ()
print (ChildClass. ca)
print(c. ca)
cc. im()
ChildClass. cm()
cc. cm()

$$\Downarrow$$

_ init_ _()被调用了(子类)
ca(子类)
ca(子类)
im()被调用了(子类)
cm()被调用了(子类)
cm()被调用了(子类)

4. MRO

Method Resolution Order(方法解析顺序)

  MRO是指的是对于一颗类继承树，当调用最底层类对象所对应实例对象的方法时，Python 解释器在类继承树上搜索方法的顺序。
  对于一棵类继承树，可以调用最底层类对象的方法mro( )或访问最底层类对象的特殊属性mro__,获得这棵类继承树的MRO。

class A(object) :
	def f(self):
		print(A.f")

class B(A) :
	def f(self):
		print(B.f)

class C(A) :
	def f(self):
		print(C.f")
	
class D(B, C):
	def f(self):
		print("D.f )

$$\Downarrow$$

例如：

>>> class A(object) :
       		def f(self):
				print(A.f")

>>> class B(A) :
			def f(self):
				print(B.f")

>>> class C(A) :
			def f(self):
				print(C.f")

>>> class D(B, c):
			def f(self):
				super(). f()

>>> d=D()
>>> d. f()
B.f


>>> class A(object):
			def f(self):
				print(A.f")

>>> class B(A) :
			pass

>>> class C(A) :
			def f(self):
				print("C.f)

>>> class D(B, c):
			def f(self):
				super(). f()

>>> d=D()
>>> d. f()
C.f

  如果想调用规定弗雷中被重写的方法，可以给super()传入两个实参：super(a_type, obj)，其中，obj所对应类对象的MRO中，a_type后面那个类对象。

多态

  在不考虑对象类型的情况下使用对象

  除了封装和继承，多态也是面向对象编程的三大特征之一。
  简单地说，多态就是"具有多种形态"，它指的是:即便不知道一 个变量所引用的对象到底是什么类型，
  仍然可以通过这个变量调用方法，在运行过程中根据变量所引用对象的类型，动态地决定调用哪个对象中的方法。

  如果子类中不存在指定名称的方法，回到父类中去查找，如果在父类中找到了，则调用父类中的方法。

>>> class ChildClass3 (ParentClass) :
			pass
>>> f(ChildClass3())
>>> do_sth() in ParentClass

  Python是动态语言，在调用函数时不会检查参数的类型
  动态语言的多态崇尚"鸭子类型":当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。
  在鸭子类型中，我们并不关心对象是什么类型，到底是不是鸭子，只关心对象的行为。
  在上面的程序中，我们并不关心变量parent所引用的对象是什么类型，到底是不是ParentClass或其子类类型，只关心变量parent所引用的对象是否有do_ sth()这个方法。
  鸭子类型:
  如果一只生物走起路来像鸭子，游起泳来像鸭子，叫起来也像鸭子，那么它就可以被当作鸭子。
  也就是说，它不关注对象的类型，而是关注对象具有的行为。