LearnPython3theHardWay__Excercise 44 Inheritance versus Composition

**ex40- 44都是类的知识 **

绝大多数继承都能简化成组合或者被组合替代，而且，避免使用多继承。

什么是继承？
当你编写 class Child(Parent)时，子类就继承了父类的属性和功能

class Parent(object):
	def implicit(self):		# implicit 隐性
		print("PARENT implicit()")

class Child(Parent):
	pass

dad = Parent()
son = Child()

dad.implicit()
son.implicit()

=========result=========
PARENT implicit()
PARENT implicit()

我们注意到，Child类下面并没有任何方法和属性，我们有son = Child()建立了个实例，Child还能继续工作，因为继承了Parent的方法。这是一种隐式继承。

有时候，你想要个性一些，不要执行父类的方法。只需要在子类下定义同名的方法即可

class Parent(object):
	def override(self):		# override 覆盖，重写
		print("PARENT override()")

class Child(Parent):
	def override(self):
		print("CHILD override()")

dad = Parent()
son = Child()

dad.override()
son.override()

==========result==========
PARENT override()
CHILD override()

还有一种特殊的继承。
您希望在执行子类的中途使用父类的方法来执行。您首先像在上一个示例中那样重写同名函数，然后使用名为super的python内置函数来调用的父类的方法。看下面的例子来理解：

class Parent(object):
	def altered(self):
		print("PARENT altered()")

class Child(Parent):
	def altered(self):
		print("CHILD, BEFORE PARENT altered()")	# 子类有altered()，先执行这一行
		super(Child,self).altered()	# 用super寻找Child的父类，并执行父类.altered()
		print("CHILD, AFTER PARENT altered()") # 上述执行完毕后，回来继续执行

dad = Parent()
son = Child()

dad.altered()
son.altered()

==========result==========
PARENT altered()
CHILD, BEFORE PARENT altered()
PARENT altered()
CHILD, AFTER PARENT altered()

综合以上，再写一段代码，理解它们：

class Parent(object):
	def override(self):
		print("PARENT override()")

	def implicit(self):
		print("PARENT implicit()")

	def altered(self):
		print("PARENT altered()")

class Child(Parent):
	def override(self):
		print("CHILD override()")
	def altered(self):
		print("CHILD, BEFORE PARENT altered()")
		super(Child,self).altered()
		print("CHILD, AFTER PARENT altered()")

dad = Parent()
son = Child()

dad.implicit()
son.implicit()

dad.override()
son.override()

dad.altered()
son.altered()

===========result==========
PARENT implicit()
PARENT implicit()
PARENT override()
CHILD override()
PARENT altered()
CHILD, BEFORE PARENT altered()
PARENT altered()
CHILD, AFTER PARENT altered()

为什么会有super()
类有多重继承的特性，如：

class SuperFun(Child, Badstuff):
	pass

SuperFun 同时继承了 Child 和 Badstuff 这两个类。当对任何SuperFun实例进行隐性操作时，python都要查找父类，按先后顺序调用（先Child后Badstuff）里面可能的方法。我们不用管是哪个父类，用super，python会自动寻找并为你调用父类方法
最常见的是跟__init__配合使用。

class Child(Parent):
	def __init__(self, stuff):
		self.stuff = stuff
		super(Child,self).__init__()

继承是很有用，但不依赖于隐性继承，通过创建其他的类和模块也能做到同样的事情。

class Other():
	def override(self):
		print("OTHER override()")
	def implicit(self):
		print("OTHER implicit()")
	def altered(self):
		print("OTHER altered()")

class Child():
	def __init__(self):
		self.other = Other()
	def implicit(self):
		self.other.implicit()
	def override(self):
		print("CHILD override()")
	def altered(self):
		print("CHILD, BEFORE OTHER altered()")
		self.other.altered()
		print("CHILD, AFTER OTHER altered()")

son = Child()

son.implicit()
son.override()
son.altered()

===========result============
OTHER implicit()
CHILD override()
CHILD, BEFORE OTHER altered()
OTHER altered()
CHILD, AFTER OTHER altered()

这个例子没有用继承。两个类的代码大部分相同

---

Study Drill

读下面的链接，相信没人会读
http://www.python.org/dev/peps/pep-0008/