方法重载

不像其它语言（如JAVA），在Python中没有方法的重载，定义多个同名的方法，只有最后一个生效

方法的动态性

Python是动态语言，我们可以动态地为类添加新的方法，或者动态地修改类已有的方法

操作示例：

'''
测试方法的动态性
'''
class Person:
	def work(self):
		print("work hard!")

def play(s):
	print("play hard!")
def work2(s):
	print("work harder!")

>>>p=Person()
>>>p.play() # 此时p对象中没有play方法
AttributeError: 'Person' object has no attribute 'play'

>>>Person.play=play  # 为类添加新方法
>>>p.play()
play hard!

>>>Person.work=work2  # 修改类原有的方法
p.work()
work harder!

'''
注意，play(s)和work(s)函数中带有参数s，这是必须得有的，因为当把它们
添加到类中时，该参数相当于self
'''

私有属性和私有方法（实现封装）

！方法的本质也是属性，只不过可以通过()调用而已

Python对于类的成员没有严格的访问控制限制，这与其它面向对象的语言有区别（如JAVA），关于私有属性和私有方法，其要点如下：

1. 约定两个下划线开头的属性是私有属性（private），其它是公共属性（public）
2. 类内部可以直接访问私有属性（方法）
3. 类外部不能直接访问，若想访问，可通过如下形式访问：

_类名__私有属性（方法）名

操作示例：

'''
测试私有属性
'''
class Person:
	def __init__(self,name,age):
		self.name=name
		self.__age=age
>>>e=Person("Tom",18)
>>>print(e.name)
Tom
>>>print(e.age)  # 因为age已经私有化，所以无法直接访问
AttributeError: 'Person' object has no attribute 'age'
>>>e._Person__age
18

@property 装饰器

@property可以将一个方法的调用方式变成“属性调用”

操作示例：

'''
测试@property装饰器
'''
class Person:
	
	@property
	def work(self):
		print("work hard!")

>>>a=Person()
>>>a.work
work hard!  # 看起来就像是属性一样，但是这里不能赋值哦！

'''
稍微复杂一些
'''
class Person:
	
	def __init__(self,name,age):
		self.__name=name
		self.__age=age
	
	@property
	def age(self):
		return self.__age
	
	@age.setter
	def age(self,age):
		if age>=0:
			self.__age=age
		else:
			print("wrong age!")
	#@age.setter用于表示这里要给age赋值了
	
'''		
	def getAge(self):
		return self.__age
		
	def setAge(self,age):
		if age>=0:
			self.__age=age
		else:
			print("wrong age!")
'''		
>>>p=Person("Tom",18)
>>>p.age
18
>>>p.age=20
>>>p.age
20

面向对象三大特征

1. 封装（隐藏）
   隐藏对象的属性和实现细节，只对外提供必要的方法，Python追求简洁的语法，通过私有属性和方法实现封装，但是没有严格的“访问控制符”
2. 继承
   使子类具有父类的特性，提高了代码的重用性，在原有父类功能设计不变的情况下，可以增加新功能
3. 多态
   同一方法调用由于对象不同会产生不同的行为，比如说，同样是休息方法，由于人的不同而产生不同的行为

继承

语法格式：

class 子类名(父类1[,父类2，...]):
	类体

一个子类可以有多个直接的父类

要点：

1. 如果在类的定义中没有出现父类，则默认父类是object类，即，object类是所有类的父类
2. 定义子类时，逻辑上必须在其构造函数中调用父类的构造函数，格式：

父类名.__init__(self,参数列表)

操作示例：

class Person:
	
	def __init__(self,name,age):
		self.name=name
		self.age=age
		
	def getAge(self):
		print("age is: ",self.age)

class Student(Person):  # 继承父类
	
	def __init__(self,name,age,score):
	# 必须显式地调用父类构造函数，不然解释器不会自动调用
		Person.__init__(self,name,age)  
		self.score=score
'''
注意：对于父类中私有的属性和方法，子类可以继承，但无法直接使用，但可以
通过_类名__属性名方式访问
'''

类成员的继承和重写

1. 成员继承：子类继承了父类除构造方法之外的所有成员
2. 方法重写：子类可以重新定义父类的方法，这样就会覆盖父类的方法，称为“重写”

操作示例：

'''
重写父类中的方法
'''
class Person:
	
	def __init__(self,name,age):
		self.name=name
		self.age=age
		
	def getAge(self):
		print("age is: ",self.age)

class Student(Person):  # 继承父类
	
	def __init__(self,name,age,score):
	# 必须显式地调用父类构造函数，不然解释器不会自动调用
		Person.__init__(self,name,age)  
		self.score=score
	
	def getAge(self):
		print("cannot get age!")

>>>p=Student("Tom",18,20)
>>>p.getAge()
cannot get age!
>>>dir(p)  # dir()方法获取子类中所有的成员信息
['_Person__age', '__class__', '__delattr__', '__dict__', \
'__dir__', '__doc__', '__eq__', '__format__', '__ge__', \
'__getattribute__', '__gt__', '__hash__', '__init__', \
'__init_subclass__', '__le__', '__lt__', '__module__',\
 '__ne__', '__new__', '__reduce__', '__reduce_ex__',\
  '__repr__', '__setattr__', '__sizeof__', '__str__', \
  '__subclasshook__', '__weakref__', 'getAge', 'name', 'score']

重写__str__()方法

object类中有一个__str__() 方法，可以返回一个对于“对象的描述”，对应于内置函数str()经常用于print()方法，帮助我们查看对象的信息，__ str __() 可以被重写

操作示例：

class Person:
	
	def __init__(self,name):
		self.name=name
	
	def __str__(self):
		return "the name is: {0}".format(self.name)

>>>p=Person("Tom")
>>>print(p)
the name is: Tom

super()方法

在子类中，如果想要获得父类的方法时，我们可以通过super()来做
super()代表父类的定义，而不是父类对象

操作示例：

'''
测试super()方法
'''
class A:
	
	def say(self):
		print("A:")
	
class B(A):
	
	def say(self):
		# A().say()
		super().say()
		print("B:")

>>>B().say()
A
B

多重继承

Python支持多重继承，一个子类可以有多个“直接父类”，这样，就具备了多个父类的特点，但是，这样会被“类的整体层次”搞的非常复杂，所以应该谨慎使用

操作示例：

'''
多重继承
'''
class A:
	def aa(self):
		print("aa")
	
class B:
	def bb(self):
		print("bb")

class C(B,A):
	def cc(self):
		print("cc")

>>>k=C()
>>>k.aa()
aa
>>>k.bb()
bb
>>>k.cc()
cc

Python中支持多重继承，如果父类中有相同名字的方法，在子类没有指定父类名时，解释器将按“从左向右”的顺序搜索

多态

多态时指同一种方法调用由于对象不同可能产生不同的行为。需要注意的是：

1. 多态是方法的多态而不是属性的多态
2. 多态的存在有两个必要条件，即继承和方法重写

操作示例：

class Man:

	def eat(self):
		print("eat")

class Chinese(Man):
	
	def eat(self):
		print("chopsticks")
	
class English(Man):
	
	def eat(self):
		print("forks")

class Indian(Man):
	
	def eat(self):
		print("hand")	

def manEat(m):
	if isinstance(m,Man):  # 判断对象是不是指定类型
		m.eat()
	else:
		print("no")

>>>manEat(Chinese())
chopsticks
>>>manEat(English())
forks
>>>manEat(Indian())
hand

组合

组合和继承：

1. 继承是“is-a”关系，继承使得子类拥有父类的方法和属性
2. 组合式“has-a”关系，实现的是一个类拥有另一个类的方法和属性

'''
测试组合
'''
class A1:
	def say(self):
		print("say")
	
class B1:
	def __init__(self,a):
		self.a=a

>>>a1=A1()
>>>b1=B1(a1)
>>>b1.a.say()
say

特殊属性

Python对象中包含了很多双下划线开始和结束的属性，这些是特殊属性，有特殊用法。常见的特殊属性有：

# 查看对象的属性与方法
obj.__dict__

# 查看对象所属的类
obj.__class__

# 查看类的基类元组
class.__bases__

# 查看类的基类,哪个父类写在前就返回哪个
class.__base__

# 查看类的层次结构
class.__mro__

# 查看子类列表
class.__subclasses__()