面向对象编程之封装、继承和重写_封装好的程序,可以重写吗-优快云博客

本文链接：https://blog.youkuaiyun.com/holiday0/article/details/90301753

一、封装

封装的含义：对属性进行操作

将数据（属性）和行为（方法）包装到类对象中。在方法内部对属性进行操作，早类对象的外部调用方法。这样，无须关心方法内部的具体实现细节，从而隔壁了复杂度。
在类对象的内部通过访问控制把某些属性和方法隐藏起来，不允许在类对象的外部直接访问，而是在类对象的内部对外提供公开的接口方法（例如getter和setter）以访问隐藏的信息。这样，就对隐藏的信息进行了保护。

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

	def get_score(self):
	  	return self.__score

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

s = Student()
s.get_score()
返回结果：90

s = Student()
s.get_score(88)
print(s.get_score())
返回结果：88

二、继承

当几个类对象中有共同的属性和方法时，就可以把这些属性和方法抽象并提取到基类中，每个类对象特有的属性和方法还是在本类对象中定义，这样，只需要让每个类对象都继承这个基类，就可以访问基类中的属性和方法了。继承基类的每个类对象被称为派生类。基类也被称为父类或超类，派生类也被称为子类。
Python中的所有类对象都继承自一个统一的基类：object。这就是为什么我们在定义类对象时要在类对象后面添加（object）。

class Animal(object):
	def eat(self):
		print("吃饭" )
		
	def drink(self):
		print("喝水")
		
class Dog(Animal):
	def swim(seIf) :
		print(" 游泳’) 

dog = Dog()
dog. eat ()#返回结果：吃饭
dog. drink()#返回结果：喝水
dog. swim()#返回结果：游泳

class Bird(Animal):
	def fly(seif):
		print(”飞翔")

bird = Bird()
bird. eat ()#返回结果：吃饭
bird. drink ()#返回结果：喝水
bird. fly()#返回结果：飞翔

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

class ChildClass (ParentClass) :
	pass

多继承:子类有多个直接父类时称为多继承
假设子类是ChildClass,直接父类是ParentClassl, ParentClass2, …, ParentClassn子类继承父类的语法格式为:

class ChildClass ( ParentClassl, ParentClass2, ..., ParentClassn):
	pass

子类会继承所有父类(包括所有直接父类和所有间接父类)的所有属性和方法)

三、重写

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

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(cc. ca)
cc. im()
ChildClass. cm()
cc. cm()


返回结果：
__init__ ()被调用了(子类)
ca(子类)
ca(子类)
im()被调用了(子类) 
cm()被调用了(子类)
cm()被调用了(子类)

父类中被重写的名为xxx的方法，在子类重写后的方法中可以通过super().xxx()进行调用

四、RMO

MRO的全称是Method Resolution Order (方法解析顺序)，它指的是对于一颗类继承树，当调用最底层类对象所对应实例对象的方法时，Python解释器在类继承树上搜索方法的顺序。
对于一棵类继承树，可以调用最底层类对象的方法mro( )或访问最底层类对象的特殊属性__mro__,获得这棵类继承树的MRO。
在子类重写后的方法中通过super( )调用父类中被重写的方法时，在父类中搜索方法的顺序基于以该子类为最底层类对象的类继承树的MRO。
如果想调用指定父类中被重写的方法，可以给super()传入两个实参: super(a_ type, obj), 其中，第一个实参a_type是个类对象，第二个实参obj是个实例对象，这样，被指定的父类是:obj所对应类对象的MRO中，a_ type后面那个类对象。

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()
		super(B, self).f()

d=D()
d. f()
#返回结果：C. f

五、多态

多态就是"具有多种形态"，它指的是:即便不知道一个变量所引用的对象到底是什么类型，仍然可以通过这个变量调用方法，在运行过程中根据变量所引用对象的类型，动态地决定调用哪个对象中的方法。
如果子类中不存在指定名称的方法，回到父类中去查找，如果在父类中找到了，则调用父类中的方法。

class ParentClass (object):
	def do_sth(self) :
		print("do_sth() in ParentClass" )

class ChildClassl (ParentClass) :
	def do_sth(self) :
		print(do_sth() in ChildClassl")

class ChildClass2(ParentClass):
	def do_ ,sth(self):
		print("do_sth() in ChildClass2' )

def f (parent):
	parent. do_sth()

f(ParentClass())
f(ChildClass1())
f(ChildClass2())

#返回结果：
do_sth() in ParentClass
do_sth() in ChildClass1
do_sth() in ChildClass2

class SomeClass (object):
	 def do_ sth(self) :
	 	 print("do_sth() in SomeClass" )

f(SomeClass())
#返回结果：do_sth() in SomeClass