11.类的继承机制，私有方法与私有属性

1.方法没有重载

​ Python中，方法的的参数没有生命类型（调用时确定参数的类型），参数的数量也可以由可变参数控制。因此， Python中是没有方法的重载的。定义一个方法即可有多种词用方式，相当于实现了其他语言中的方法的重载。

如果我们在类体中定义了多个重名的方法，只有最后一个方法有效。

建议：不要使用重名的方法！ Python中方法没有重载

例如：

#python中没有方法的重载，定义多个重名方法，只有最后一个有效

class Person:
    
    def say_hi(self):
        print('hello')
        
    def say_hi(self,name):
        print("{}.hello".format(name))
        
p1 = Person

#p1.say_hi（）	#不带参数，报错

2.方法的动态性

​ python是动态语言，可以动态的为类添加新方法，或者动态的修改类的已有方法。

#测试方法的动态性

class Person:
    
    def work(self):
        print('努力上班')
        
def play_game(s)：
	print("{0}在玩游戏".format(s))
    
def work2(s):
    print('好好工作')
Person.play = play_game	#python一切都是对象，等号左边定义了Person的play属性，右边即将方法函数play_game赋给了play属性，从而实现了方法的动态添加
p = Person()
p.work()
p.play()

Person.work = work2	#实现了方法的动态修改
p.work()

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

​ python对于类的成员没有严格的访向控制限制，这与其他面向对象语言有区别。关于私有属性和私有方法，有如下要点

1.通常我们约定，两个下划线开头的属性是私有的（ private）。其他为公共的（ public）

2.类内部可以访问私有属性（方法）

3.类外部不能直接访问私有属性（方法）

4.类外部可以通过“-类名-私有属性（方法）”访私有属性（方法）

PS:方法本质上也是属性！只不过是可以通过（）执行而已。所以，此处讲的私有属性和公有属性，也同时讲了私有方法和公有方法的用法。

#测试私有属性

class Employee:
    
    def __init__(self,name,age):
        self.name = name
        self.age = age
        
        
e = Employee('gaoqi',18)

print(e.name)
print(e.age)

#如果想要把年龄私有化，那么设置__init__时可以这样：
class Employee:
    
	def __init__(self,name,age):
        self.name = name
        self.__age = age
        
    def __work(self):#私有方法
        print('好好工作')
        
e = Employee('gaoqi',18)

print(e.name)
print(e.age)	#此处就会报错说没有age属性。要访问他应该用print(e._Employee__age)

e._Employee__work()	#私有方法的调用

4.@property的使用

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

#测试@property的用法
class Employee:
    
    @property
    def salary(self):
        print("salary run...")
        return
    
emp1 = Employee()
print(emp1.salary)    #变成属性调用了


#@property的装饰器用法

5. 面向对象的三大特征

Python是面向对象的语言，也支持面向对象编程的三大特性：继承、封装（隐藏）、多态。

1. 封装（隐藏）

​ 隐藏对象的属性和实现细节，只对外提供必要的方法。相当于将“细节封装起来”，只对外暴露“相关调用方法。

​ 通过前面学习的“私有属性、私有方法”的方式，实现“封装”。 Python追求简洁的语法，没有严格的语法级别的"访问控制符”″，更多的是依靠程序员自觉实现。

2.继承

​ 继承继承可以让子类具有父类的特性，提高了代码的重用性。从设计上是一种增量进化，原有父类设计不变的情况下，可以增加新的功能，或者改进已有的算法。

3.多态

​ 多态是指同一个方法调用由于对象不同会产生不同的行为。生活中这样的例子比比皆是：同样是休息方法，人不同休息方法不同。张三休息是睡觉，李四休息是玩游戏，程序员休息是“敲几行代码”。

6.继承

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

6.1 语法格式

python支持多类继承，一个子类可以继承多个父类。继承的语法格式如下：

class 子类类名（父类1，父类2，...）:
    类体

​ 如果在类定义中没有指定父类，则默认父类是 object类。也就是说， object是所有类的父类，里面定义了一些所有类共有的默认实现，比如：new_()

​ 定义子类时，必须在其构造函数中调用父类的构造函数。调用格式如下父类名，init_（self，参数列表）

class Person:
    def __init__(self,name,age):
        self.name = name
        self.__age = age
        
    def say_age(self):
        print(self.name,'的年龄是：'，self.__age)
        
class Student(Person):#Student就继承了Person类
    def __init__(self,name,age,score):
        self.name = name
        self.__age = age
        #上面两行等价于Person.__init__(self,name,age)
        self.score = score

s = Student('gaoqi',18,60)
s.say_age()
print(s.name)
print(s._Person__age)

6.2 类成员的继承和重写

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

Eg. 继承与重写的案例

class person：
	 def init (self, name, age）：
    	 self.name = name 
         self.__age = age 
        
     def say age(self)
    	print（ self.name，"的年龄是：" self.__age）
              
	 def say_name(self)：
          print('我的名字是'.format(self.name))
              
class Student(Person):
      def __init__(self,name,age,score):
           Person.__init__(self,name,age)
           self.score = score
               
      def say_name(self):
           """重写父类的方法"""
           print('大家好，我的名字是'.format(self.name))
               
s = Student('gaoqi',18,60)
s.say_age()
s.say_introduce()     #这个时候就是调用了子类的方法，实现了修改          

7.多重继承

python支持多重继承，一个子类可以继承多个“直接父类”。这样就具备了“多个父类”的特点。但由于这样会把类的整体层次搞得异常复杂，尽量避免使用。