python之封装继承多态

---

一、面向对象的三大特征

1. 封装： 提高程序安全性，若不希望外部调用类属性，可以加两个下划线；
2. 继承： 提高代码复用性；
3. 多态： 提高程序的可扩展性和可维护性。

二、封装

2.1 私有化

定义：

将属性和方法写到类的内部，使实例获得较为全面的功能，并且可以将属性和方法设置私有权限，保证暴露接口的安全性。规则如下：
a. 隐藏对象的属性和实现细节，仅对外提供公共访问的方式
b. 封装原则：
       1.将不需要对外提供的内容隐藏起来
       2.把属性都隐藏，提供共公共方法对其访问；

优点：

1.可以找到一个对象能够完成所有的功能或者业务,迭代和维护较为方便
2.可以设置私有属性或方法,提高代码安全性,只暴露我们想要暴露的接口
3.可以降低模块或者类的使用难度,暴露少量接口即可完成全部功能

私有属性,私有方法：

当前属性或方法只能在类的内部进行调用,在类的外部无法使用,则称该属性,或者方法为私有属性,或者私有方法
格式: 在属性或方法前加上两个下划线 __属性名 或者 __方法名

注意：
以单划线开头的表示保护类型成员，只允许在类本身和子类中进行访问，不能通过 “ from module import * ”语句导入。

class Dog(object):
    def _eat(self):
        print('吃一根骨头')
 
    def bark(self):
        self._eat()
        print('汪汪汪'')
 
 
d1 = Dog()
d1.bark()

结果：

2.2私有属性的获取方式

# 一般情况下,我们不会强行调用私有属性和方法
# 我们会设置 get方法和set方法进行调用和修改
 
class Dog(object):
    def __init__(self, name, age):
        self.name = name
        self.__age = age
 
    # 如果一个数据只能存储数据,无法使用其中的数据,那这个数据存储方案将没有任何意义
    def get_age(self):
        return self.__age
 
    def set_age(self, age):
        self.__age = age

 
 
d1 = Dog('小黑', 18)
# 使用get方法,可以直接调用私有属性
print(d1.get_age())
# 在使用set方法时,可以对私有属性进行赋值
d1.set_age(45)
print(d1.get_age())

结论: 使用get，set方法可以对私有属性进行赋值和获取，在类的外部也可以使用

三、继承

继承顺序： 对象>子类>父类>父父类

3.1 单继承

单继承就是某个类只继承自一个父类，同时，继承关系中可以有多级继承
继承过程中，子类可以使用父类的所有非私有属性或方法
如果父类或更高级的父类，实现了init方法，并且进行了参数设定，实例化子类对象时必须传值。

# 单继承:一个子类,只继承一个父类,并且可以多级继承
 
# 定义一个Person类
class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.__age = age
 
# 定义一个Father类,继承Person
class Father(Person):
    def __sing(self):
        print('唱歌')
 
    def dance(self):
        print('跳舞')
 
# 定义一个Son类,继承Father
class Son(Father):
	# 继承父类时,只能继承父类中的非私有属性和方法
	pass
s1 = Son('小明', 26) 

结果：

结论：

1、在继承中可以多级继承，子类中可以使用父类及父类的父类中非私有的属性和方法
2、如果在父类或者更高级的父类中实现了init方法，并且书写了参数,则实例化对象时，必须传值

查询类的继承链条
Son.mro

(main.Son’>, main.Father’>, main.Person’>, )
使用 类名.mro 可以输出类的继承链条，同时这个 顺序也是方法或属性查找的顺序

3.2 多继承

一个子类，继承多个父类的过程就是多继承
在多继承中，子类可以调用多个父类中的非私有方法或者属性
多继承中，如果出现同名属性或方法，优先调用继承位置靠前的父类中的方法或属性

# 定义一个Person类
class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.__age = age
 
# 定义一个Father类,继承Person
class Father(Person):
    def father_sing(self):
        print('爸爸唱歌')
 
    def dance(self):
        print('爸爸跳舞')
# 定义一个math类,继承Person
class Mother(Person):
    def mom_sing(self):
        print('妈妈唱歌')
 
    def dance(self):
        print('妈妈跳舞')
 
# 定义一个Son类,继承Father
class Son(Mother, Father):
	# 继承父类时,只能继承父类中的非私有属性和方法
	pass
s1 = Son('小明', 26) 

结果：

结论：

如果存在同名方法，在继承时,谁的继承位置更靠前就调用谁内部的代码

3.3 子类重写父类方法

子类中重写父类方法重写父类方法，则调用方法时，直接调用子类中的方法，不会调用父类的（因为在调用方法或者属性时，会按照继承层级依次查找）
重写时只要方法名称*相等即可，不需要进行参数的校对

# 定义一个Person类
class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.__age = age
 
# 定义一个Father类,继承Person
class Father(Person):
    def sing(self):
        print('爸爸唱歌')
        
 
    def dance(self):
        print('爸爸跳舞')
 
# 定义一个Son类,继承Father
class Son(Father):
	# 继承父类时,只能继承父类中的非私有属性和方法
	def sing(self):
		print('儿子唱歌')

s1 = Son('小明', 26) 

结果：

3.4 super（）方法

super（）方法的存在就是为了解决多重继承的问题，在一个父类中使用super（）方法用于调用下一个父类的方法

# 定义一个Person类
class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.__age = age
        print('from init')
 
# 定义一个Father类,继承Person
class Father(Person):
    def sing(self):
        print('爸爸唱歌')
        super().sing()
 
    def dance(self):
        print('爸爸跳舞')
        
class Mother(Person):
    def sing(self):
        print('妈妈唱歌')
 
    def dance(self):
        print('妈妈跳舞')
 
# 定义一个Son类,继承Father
class Son(Father,Mother):
    # 继承父类时,只能继承父类中的非私有属性和方法
    def sing(self):
        print('儿子唱歌')
        super().sing()

s1 = Son('小明', 26) 

结果：

四、多态

4.1 概念

多态是指在执行相同代码情况下，根据对象所属类的不同去调用相应类的方法，从而执行不同效果。
两个前提：
1.继承----多态一定是发生在子类和父类之间；
2.重写----子类重写了父类的方法

实例一：

# 定义Person类
class Person(object):
    def __init__(self, name="小明"):
        # _name 为私有属性
        self._name = name
 
    def drink(self):
        print(self._name + "喝水")
 
 
# 定义一个Father类,继承Person
class Father(Person):
    # 对父类的 sleep 方法进行了扩展
    def drink(self, name):
        super().drink();
        print(name + "喝水")
  
        
class Mother(Person):
    def drink(self):
        print("妈妈喝水")
 
 
father = Father()
# 调用父类的 drink 方法
father.drink("小红");
 
mother = Mother()
# 调用父类的 drink 方法
mother.drink()

结果：

小明喝水
小红喝水

妈妈喝水

实例二：

class Animal(object):
    def run(self):
        print("Animal running")


class Bird(Animal):
    def run(self):
        print("a bird sleeps in tree")


class Fish(Animal):
    def run(self):
        print("a fish sleeps in water")


def goSleep(Animal):
    Animal.run()

fish = Fish()
bird = Bird()

goSleep(fish)
goSleep(bird)

结果：

a fish sleeps in water
a bird sleeps in tree

多态的意义：

1. 对于一个变量，我们只需要知道他是Animal类型，无需确切地知道它的子类型，就可以放心地调用run()方法（调用方只管调用，不管细节）
2. 当需要新增功能，只需要新增一个Animal的子类实现run()方法，就可以在原来的基础上进行功能扩展，这就是著名的“开放封闭”原则：​​​​​​​

“开放封闭”原则：

1. 对扩展开放：允许新增Animal子类
2. 对修改封闭：不需要修改依赖Animal类型的run()等函数

注意点： Python中函数的参数是没有类型限制的，所以多态在python中的体现并不是很严谨。多态的概念是应用于Java和C#这一类强类型语言中，而Python崇尚“鸭子类型”。
即：在Python中编写一个函数，传递实参前其参数的类型并不确定，在函数中使用形参进行操作时只要传入的对象能够支持该操作程序就可以正常执行。

4.2内置函数（isinstance、ssubclass、type）

4.2.1 isinstance

       用于判断一个对象所属的类是否是指定的类或指定类的子类
用法：
       isinstance(object, classinfo)

       object – 实例对象。
       classinfo – 可以是直接或间接类名、基本类型或者由它们组成的元组。
返回值：
       相同则返回 True，否则返回 False。
例：

# 定义一个Person类
class Person(object):
    pass
 
# 定义一个Father类,继承Person
class Father(Person):
    pass
 
father = Father() 

print(isinstance(father,Person))

print(issubclass(Father,Person))

print(type(father)==Father)

# 结果为Ture

print(type(father)==Person)
# 结果为False

4.2.2 issubclass

       用于判断一个类是不是另一类的子类
用法：
       issubclass(class, classinfo)
参数：
      class – 子类。
      classinfo – 父类。

返回值：
       相同则返回 True，否则返回 False。

4.2.3 type

       用于获取一个对象所属的类
用法：
       type(class)==classinfo
参数：
      class – 子类。
      classinfo – 父类。

返回值：
       相同则返回 True，否则返回 False。

五、类属性和类方法

通过 类名.类属性 或者 类名.类方法 来访问类属性和类方法

5.1 类属性

不需要创建类的对象，通过 类名. 的⽅式就可以访问类的属性或者调用类的方法 。

# 定义Cat类
class Cat:
    # name 为类属性，通过 Cat.name 访问
    name = "小黄" 
print(Cat.name)

5.2 类方法

1. 用 @classmethod 修饰的方法为类方法；
2. 类方法的参数为 cls，在类方法内部通过 cls.类属性 或者 cls.类方法 来访问同一个类中的其他类属性和类方法；
3. 类方法不需要实例化就可以调用，类方法只能访问同一个类中的类属性和类方法

@classmethod
def 静态⽅法名(cls):
       pass

# 定义Cat类
class Cat(object):
 
    def __init__(self, name="小白"):
        # _name 为私有属性
        self._name = name
 
    # drink 为类方法
    @classmethod
    def drink(cls):
        print(cls.name + "喝水")
 
Cat.drink()

5.3 静态方法

如果需要在类中封装⼀个⽅法，这个⽅法既不需要访问实例属性 或者调⽤实例⽅法，也不需要访问类属性或者调⽤类⽅法, 这个时候，可以把这个⽅法封装成⼀个静态⽅法。

1. 用 @staticmethod 修饰的方法为静态方法；
2. 静态方法是独立存在的，不能访问类或者实例的任何属性和方法；
3. 通过 类名.静态方法 调⽤静态⽅法 。

@staticmethod
def 静态⽅法名():
       pass

# 定义Cat类
class Cat(object):
    # drink 为类的静态方法
    @staticmethod
    def drink():
        print("喝水")
        
Cat.drink()

5.4 property属性

使用 @property 装饰器来创建只读属性，@property装饰器会将方法转换为相同名称的只读属性,可以与所定义的属性配合使用，这样可以防止属性被修改。

用法主要有两点：

1. 将方法当做属性来使用
2. 将属性设置为只读

5.4.1 修饰方法，是方法可以像属性一样访问。

class DataSet(object):
	@property
	def method_with_property(self): #含有@property
    	return 15
    
    #不含@property
    def method_without_property(self): 
    	return 15

data_set = DataSet()
# 加了@property后，可以用调用属性的形式来调用方法,后面不需要加（）。
print(data_set.method_with_property) 

#没有加@property , 必须使用正常的调用方法的形式，即在后面加()
print(data_set.method_without_property()) 

5.4.2 与所定义的属性配合使用，防止属性被修改

由于python进行属性的定义时，没办法设置私有属性，因此要通过@property的方法来进行设置。这样可以隐藏属性名，让用户进行使用的时候无法随意修改。

class DataSet(object):
	def __init__(self):
		#定义属性的名称
    	self._images = 1
    
    # 方法加入@property后，这个方法相当于一个属性，这个属性可以让用户进行使用，而且用户有没办法随意修改。
    @property
    def images(self): 
        return self._images 

data_set = DataSet()

#用户进行属性调用的时候，直接调用images即可，而不用知道属性名_images，因此用户无法更改属性，从而保护了类的属性。
print(data_set.images) 

注意点：

1. 属性名与方法名一定要区分开，不然会进入死循环
2. 实例化的对象使用属性时，不是调用属性，而是用的方法名
3. @property其实就是实现了getter功能； @xxx.setter实现的是setter功能；还有一个
   @xxx.deleter实现删除功能
4. 定义方法的时候 @property必须在 @xxx.setter之前，且二者修饰的方法名相同
5. 如果只实现了 @property（而没有实现@xxx.setter），那么该属性为 只读属性

class DataSet(object):
    def __init__(self):
        #定义属性的名称
        self._images = 1
    
    # 方法加入@property后，这个方法相当于一个属性，这个属性可以让用户进行使用，而且用户有没办法随意修改。
    @property
    def images(self): 
        return self._images 

    @images.setter
    def images(self, value): 
        self._images = value

data_set = DataSet()
# 输出images属性
print(data_set.images)
# 复制images属性
data_set.images = 3
print(data_set.images)


# 结果为：
1
3