Python学习——Day11--封装、继承、多态

一、封装

 1.1封装的目的：

1：封装数据：保护隐私
2：封装方法：隔离复杂度（只保留部分接口对外使用）

1.2封装的方式

私有属性和方法:

• 私有成员变量：变量名以__开头（2个下划线）

• 私有成员方法：方法名以__开头（2个下划线）

class Phone:
    __current_voltage = None # 当前电压 私有成员变量
 

    def call_by_5g(self):    
        print("5g通话已开启")
    def __keep_single_core(self):      # 私有成员方法
        print("让CPU以单核模式运行以节省电量") 

在Python中，可以使用_和__来定义属性的访问级别:

• 以_开头的属性被视为受保护的属性，即它们不应该在类外部被直接访问。但是，它们可以在类的子类和内部方法中被访问。
• 以__开头的属性被视为私有属性，即它们不应该在类的外部被访问。但是，它们也可以在类的内部方法中被访问。

1.3按照python中的规则，在类外部不能访问类内受保护的属性或方法

class Phone:

    __current_voltage = None #当前电压

    def call_by_5g(self):
        print("5g通话已开启")

    def __keep_single_core(self):
        print("让cPU以单核模式运行以节省电量")


phone = Phone() # 创建对象
phone.__current_voltage=33 # 私有变量赋值 不报错，但无效
print(phone.__current_voltage)#获取私有变量值 报错，无法使用

对于私有属性，如果我们要在类外进行访问的话，会抛出 AttributeError 的错误

1.4私有成员无法被类对象使用，但是可以被其它的成员使用

class Phone:

    __current_voltage = 0.5


    def __keep_single_core(self):
        print("让CPU以单核模式运行以节省电量")

    def call_by_5g(self):
        if self.__current_voltage >= 1:
           print("5g通话已开启")

        else:
           self._keep_single_core()
           print("让CPU以单核模式运行以节省电量")

1.5案例

class Phone:
    # 设计私有成员变量
    __is_5g_enable = True   # 5G状态
 
    # 私有成员方法
    def __check_5G(self):
        if self.__is_5g_enable = True:
            print("5G开启")
        else:
            print("5G关闭，使用4G网络")
 
    # 提供公开成员方法
    def call_by_5G(self):
        self.__check_5G()
        print("正在通话中")
 
phone = Phone()
phone.call_by_5G()

1.6属性装饰器

属性装饰器是一种特殊的函数，它可以被用来修改属性的访问方式。在Python中，我们可以使用@property 和 @属性名.setter装饰器来定义属性的访问器和修改器

• @property装饰器：用于定义属性的访问器，它会将属性定义为一个只读属性。当外部代码试图修改这个属性时，会触发一个AttributeError异常。
• @属性名.setter装饰器：用于定义属性的修改器，它可以让外部代码修改这个属性的值。当外部代码试图读取这个属性时，会触发一个AttributeError异常。

1.7案例

class MyClass:
    def __init__(self,value):
        self. __value = value

    @property           #读取
    def value(self):
        return self. __value

    @value.setter       #修改
    def value(self,new_value):
        self. __value = new_value

a = MyClass("哈哈哈哈")
print(a.value)

a.value = "啦啦啦啦"
print(a.value)

二、继承

面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。

通过继承创建的新类称为子类或派生类，被继承的类称为基类、父类或超类

2.1继承的基本语法

class 派生类名(基类名)
    ...

 2.2单继承案例

class Parent:        # 定义父类
   parentAttr = 100
   def __init__(self):
      print "调用父类构造函数"
 
   def parentMethod(self):
      print '调用父类方法'
 
   def setAttr(self, attr):
      Parent.parentAttr = attr
 
   def getAttr(self):
      print "父类属性 :", Parent.parentAttr
 
class Child(Parent): # 定义子类
   def __init__(self):
      print "调用子类构造方法"
 
   def childMethod(self):
      print '调用子类方法'
 
c = Child()          # 实例化子类
c.childMethod()      # 调用子类的方法
c.parentMethod()     # 调用父类方法
c.setAttr(200)       # 再次调用父类的方法 - 设置属性值
c.getAttr()          # 再次调用父类的方法 - 获取属性值

运行结果：

调用子类构造方法
调用子类方法
调用父类方法
父类属性 : 200

2.3多继承

基本语法：

class 类名（父类1,父类2,……,父类N):

案例:

class Phone:
    IMEI = None # 序列号
    producer = None # 厂商
    def call_by_5g(self):
        print("5g通话")

class NFCReader:
    nfc_type = "第五代"
    producer = "HM"
    def read_card(self):
        print("读取NFC卡")

    def write_card(self):
        print("写入NFC卡")

class Remotecontrol:
    rc_type = "红外遥控"
    def control(self):
        print("红外遥控开启")


class Myphone(Phone, NFCReader, Remotecontrol):
    pass

多继承注意事项

• 多个父类中，如果有同名的成员，那么默认以继承顺序（从左到右）为优先级。
• 即：先继承的保留，后继承的被覆盖

pass

2.4复写：

复写案例

class Phone:
    IMEI = None # 序列号
    producer="ITCAST" # 厂商
    
    def call_by_5g(self):
        print("父类的5g通话")

class MyPhone(Phone):
    proucer = "ITHEIMA" # 复写父类属性
    
    def call_by_5g(self): # 复写父类方法
    print("子类的5g通话")

2.5调用父类同名成员

一旦复写父类成员，那么类对象调用成员的时候，就会调用复写后的新成员

如果需要使用被复写的父类的成员，需要特殊的调用方式:

方式1：

• 调用父类成员      

• 使用成员变量：父类名.成员变量      

• 使用成员方法：父类名.成员方法(self)

方式2：

• 使用super()调用父类成员      

• 使用成员变量：super().成员变量      

• 使用成员方法：super().成员方法()

实例：

class Phone:
    IMEI = None # 序列号
    producer="ITCAST" # 厂商
    def call_by_5g(self):
        print("父类的5g通话")


class MyPhone(Phone):
    proucer = "ITHEIMA"
    
    def call_by_5g(self):
        # 方式1调用父类成员
        print(f"父类的品牌是：{Phone.producer}")
        Phone.call_by_5g(self)

        #方式2调用父类成员
        print(f"父类的品牌是：{super().producer}")
        super().call_by_5g()
        
        print("子类的5g通话")

三、多态

3.1什么是多态

举一个现实中的例子，同样的一件事情，不同的人处理起来，他们的实现过程是完全不同的，会表现出不同的形态。比如：都是吃饭这个事情，中国人表现的是用筷子吃饭，而美国人表现的是用叉刀吃饭。这个就是相同的事情，表现出了不同的“形态”。

3.2实例

定义了一个 animal 类，其中有一个方法 speak 表示动物发出声音

定义了两个子类——狗和猫，它们都继承了 animal 类并且复写了 speak 方法

• 定义了一个函数，该函数需要接收一个类型为 animal 的对象
• 调用 speak 方法，动物叫
• 创建狗和猫这两个子类的对象
• 调用函数时，传入狗和猫，然后输出“汪汪汪”和“喵喵喵”

这就是多态的体现，我们完成了某个具体的行为——即调用函数，但是我们传入了不同的对象，从而得到了不同的状态。比如，我们传入狗就会输出“汪汪汪”，传入猫就会输出“喵喵喵”

3.4抽象类（接口）

• 抽象类：含有抽象方法的类称之为抽象类
• 抽象方法：方法体是空实现的（pass）称之为抽象方法

父类Animal的speak方法，是空实现

这种设计的含义是：

• 父类用来确定有哪些方法
• 具体的方法实现，由子类自行决定

抽象类就好比定义一个标准，包含了一些抽象的方法，要求子类必须实现

四、isinstance()方法

4.1描述

isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。

isinstance() 与 type() 区别：

• type() 不会认为子类是一种父类类型，不考虑继承关系。
• isinstance() 会认为子类是一种父类类型，考虑继承关系。

4如果要判断两个类型是否相同推荐使用 isinstance()

4.2语法 

isinstance(object, classinfo)

• object -- 实例对象。
• classinfo -- 可以是直接或间接类名、基本类型或者由它们组成的元组。

如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False

4.3案例

a = 10086
isinstance (a,int)  # true

isinstance (a,str) # false

isinstance (a,(str,int,list))    # 只要满足元组类型中的其中一个即可，答案是满足，所以为true

class A:
    pass
 
class B(A):
    pass
 
isinstance(A(),A) # True
type(A()) == A    # True
isinstance(B(),A) # True
type(B()) == A    # False