Python面向对象三大特征之继承

青旅半醒 2022-01-28 04:19 420阅读 0赞

![@数据分析 - jacky][- jacky]

> 面向对象有三大特征，本文分享第二篇：继承

**继承实现代码的重用，相同的代码不需要重复的编写**

# 01 单继承 #

## 1.1 继承的概念、语法和特点 ##

继承的概念：子类拥有父类的所有方法和属性  
![@数据分析-jacky][-jacky]

##### 1）继承的语法 #####

class 类名(父类名):
    	pass

*  子类继承父类，可以直接享受父类中已经封装好的方法，不需要再次开发
 *  子类中应该根据职责，封装子类特有的属性和方法

##### 2）继承的传递性 #####

*  C类从B类继承，B类又从A类继承
 *  那么C类就具有B类和A类的所有属性和方法
 *  子类拥有父类以及父类的父类中封装的所有属性和方法

## 1.2 方法的重写 ##

*  子类拥有父类的所有方法和属性
 *  子类继承自父类，可以直接享受父类中已经封装好的方法，不需要再次开发

应用场景

*  当父类的方法实现不能满足子类需求时，可以对方法进行重写（override）

![@数据分析-jacky][-jacky 1]  
重写父类方法有两种方法：

1.  覆盖父类的方法
2.  对父类方法进行扩展

##### 1）覆盖父类的方法 #####

*  如果在开发中，父类的方法实现和子类的方法实现，完全不同，就可以使用覆盖的方式，在子类中重新编写父类的方法实现
 *  具体的实现方式，就相当于在子类中定义了一个和父类同名的方法并且实现
 *  重写之后，在运行时，只会调用子类中重写的方法，而不再去调用父类封装的方法

##### 2）对父类方法进行扩展 #####

*  如果在开发中，子类的方法实现中包含父类的方法实现
    
     *  父类原本封装的方法实现是子类方法的一部分
 *  就可以使用扩展的方式
    
    1.  在子类中重写父类的方法
    2.  在需要的位置使用 super().父类方法 来调用父类方法的执行
    3.  代码其他的位置针对子类的需求，编写子类特有的代码实现

关于 super

*  在 Python 中 super 是一个特殊的类
 *  super() 就是使用 super 类创建的对象
 *  最常使用的场景就是在重写父类方法时，调用 在父类中封装的方法实现

## 1.3 私有属性和私有方法 ##

##### 1） 应用场景及定义方式 #####

应用场景

*  在实际开发中，对象的某些属性或方法可能只希望在对象的内部被使用，而不希望在外部被访问到
 *  私有属性就是对象不希望公开的属性
 *  私有方法就是对象不希望公开的方法

定义方式

*  在定义属性或方法时，在属性名或者方法名前增加两个下划线，定义的就是私有属性或方法

class Women:
    	
    	def __init__(self,name):
    		
    		self.name = name
    		self.age = 18
    	def secret(self):
    		print("%s 的年龄是 %d" % (self.name,self.age))
    
    xiaoli = Women("小丽")
    
    print(xiaoli.age)
    
    xiaoli.secret
    
    >>> 18
    >>> 小丽的年龄是18

class Women:
    	
    	def __init__(self,name):
    		
    		self.name = name
    		self.__age = 18
    	def secret(self):
    		print("%s 的年龄是 %d" % (self.name,self.__age))
    
    xiaoli = Women("小丽")
    
    # 私有属性，在外界不能够被直接访问
    print(xiaoli.__age)
    
    xiaoli.secret
    
    >>> AttributeError:'Women' object has no attribute '__age'

class Women:
    	
    	def __init__(self,name):
    		
    		self.name = name
    		self.__age = 18
    	def secret(self):
    		# 在对象的方法内部，是可以访问对象的私有属性的
    		print("%s 的年龄是 %d" % (self.name,self.__age))
    
    xiaoli = Women("小丽")
    
    # 私有属性，在外界不能够被直接访问
    #print(xiaoli.__age)
    
    xiaoli.secret
    
    >>> 小丽 的年龄是 18

class Women:
    	
    	def __init__(self,name):
    		
    		self.name = name
    		self.__age = 18
    	def __secret(self):
    		# 在对象的方法内部，是可以访问对象的私有属性的
    		print("%s 的年龄是 %d" % (self.name,self.__age))
    
    xiaoli = Women("小丽")
    
    # 私有属性，在外界不能够被直接访问
    #print(xiaoli.__age)
    
    # 私有方法，同样不允许在外界直接访问
    xiaoli.__secret
    
    >>> AttributeError:'Women' object has no attribute '__secret'

##### 2） 伪私有属性和私有方法（了解） #####

> 提示：在日常开发中，不要使用这种方式，访问对象的私有属性或私有方法

Python 中，并没有真正意义的私有

*  在给属性、方法命名时，实际是对名称做了一些特殊处理，使得外界无法访问到
 *  Python 解释器处理方式：在名称前面加上 \_类名 => \_类名\_\_名称

# 私有属性，外部不能直接访问到
    print(xiaoli._Women__age)
    
    # 私有方法，外部不能直接调用
    xiaoli._Women__secret()

##### 3）父类的私有属性和私有方法 #####

1.  子类对象不能在自己的方法内部，直接访问父类的私有属性或是有方法
2.  子类对象可以通过父类的公有方法直接访问到私有属性或私有方法

*  私有属性、方法 是对象的隐私，不对外公开，外界以及子类都不能直接访问
 *  私有属性、方法 通常用于做一些内部的事情

class A:
    
    	def __init__(self):
    		
    		self.num1 = 100    # 定义公有属性
    		self.__num2 = 200    # 定义私有属性
    	
    	def __test(self):
    		print("私有方法 %d %d" % (self.num1,self.__num2))
    
    	def test(self):
    		# 这一步是关键，要认真体会: 在父类的公有属性（方法），调用父类的私有属性（方法）
    		print("父类的公有方法 %d" % self.__num2)
    		
    		# 自己的私有方法是可以调用自己的公有方法
    		self.__test
           
    
    class B(A)
    
       def demo(self):
    
    		# 1.在子类的对象方法中不能访问父类的私有属性
    		# print("访问父类的私有属性 %d" % self.__num2)   #会报错
    
    		# 2.在子类的对象中，不能调用父类的私有方法
    		# self.__test()    #会报错
    
    		# 3.访问父类的公有属性
    		print("子类方法 %d" % self.num1)
    
    		# 4.调用父类的公有方法
    		self.test()
    		pass
    		
    
    # 创建一个子类对象
    b = B()
    print(b)
    b.demo()
    
    # 在外界不能直接访问对象的私有属性/调用私有方法
    # print(b.__num2)  # 会报错
    # b.__test()   # 会报错
    
    >>> 子类方法 100
    >>> 父类的公有方法 200
    >>> 私有方法 100 200

--------------------

# 02 多继承 #

概念

*  子类可以拥有多个父类，并且具有所有父类的属性和方法
 *  多继承可以让子类对象，同时具有多个父类的属性和方法

语法

class 子类名(父类名1，父类名2 ... )
    	pass

class A:
    	
    	def test(self):
    		print("test 方法")
    
    class B:
    
    	def demo(self):
    		print("demo 方法")
    
    # 定义 A类和B类的子类 C 类
    class C(A,B):
    
    	pass
    
    # 创建子类对象
    c = C()
    
    c.test()
    c.demo()

[- jacky]: /images/20220128/72041d0e1abe44d4babb0a456c0b5a8d.png
[-jacky]: /images/20220128/389877347684404ebe303d647302f344.png
[-jacky 1]: /images/20220128/11a64f31170144689e4467acd9ad91d5.png