【Python】面向对象：封装，接口，多态，多态性

r囧r小猫 2023-10-04 08:00 8阅读 0赞

## 封装 ##

封装来了：封装是啥？封装就好像把你需要的东西装到盒子里然后用封口胶把空封起来。照这种逻辑看，封装=“隐藏”。

哪在Python中怎么看出来隐藏呢？

在Python中用双下划线开头的方式将属性隐藏起来（设置成私有的）

类中所有双下划线开头的都会自动变形成：\_\_类名\_\_x的形式

"""
    就是把函数跟方法给封装起来
    定义里两个类，封装
    """
    class xiaoxin:
        __A="shimmer"
    #类的数据属性一个是共享的，但是语法上可以是把类的数据属性设置成私有的如_xiaoxin__A
        def __Foo(self):
            print("from xiaoxin")
        def bar(self):
            self.__Foo()#只有在类的内部才能被访问到
    
    class xiaoting(xiaoxin):
        def __FOO(self):
            print("from xiaoting")
    
    d=xiaoting()
    d.bar()

![在这里插入图片描述][20210310211407687.png]  
注意：  
1、这种机制也并没有真正意义上限制我们从外部直接访问属性，知道了类名和属性名就可以拼出名字：\_类名\_\_属性，然后就可以访问了，如a.\_A\_\_N  
2、变形的过程只在类的定义是发生一次,在定义后的赋值操作，不会变形  
3、在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的

### 封装的意义： ###

**\#一：封装数据属性：明确的区分内外，控制外部对隐藏的属性的操作行为**

class  People:
        def __init__(self,name,age):
            self.__name=name
            self.__age=age
    
        def tell_info(self):
            print("name: %s,age: %s"%(self.__name,self.__age))
    
        def set_info(self,name,age):
            if not isinstance(name,str):
                print("姓名需要为字符串类型！！！")
            if not isinstance(age,int):
                print("年龄需要为整型！！！")
            self.__name=name
            self.__age=age
    
    p=People("shimmer",21)
    p.tell_info()
    
    p.set_info("EGON",38)
    p.set_info(38,"EGON")
    p.set_info(111,222)

**\#二、 封装方法：隔离复杂度**

class ATM:
        def __card(self):
            print("插卡")
        def __auth(self):
            print("用户认证")
        def __input(self):
            print("输入取款金额")
        def __print_bill(self):
            print("打印账单")
        def __take_money(self):
            print("取款")
    
        def withdraw(self):
            self.__card()
            self.__auth()
            self.__input()
            self.__print_bill()
            self.__take_money()
    
    a=ATM()
    a.withdr

**3：封装也能体现面向对象的可扩展性高这一点**

"""
    定义一个房类：有长宽高，拥有者，类型
    """
    class Room:
        def __init__(self,name,owner,length,width,height):
            self.name=name
            self.owner=owner
            self.__length=length
            self.__width=width
            self.__height=height
    
        def area(self):#对外提供的接口，隐藏了内部的实现细节，此时我们想求的是面积
            res=self.__length*self.__width*self.__height
            print(res)
    
        def info(self):
           print("房子类型：%s"%self.name)
    
    d=Room("两房一厅","shimmer",10,20,10)
    d.area()#使用者调用接口
    d.info()

直接从内部定义函数方法，给外部提供接口进行访问。

封装在于明确区分内外，使得类实现者可以修改封装内的东西而不影响外部调用者的代码；而外部使用用者只知道一个接口(函数)，只要接口（函数）名、参数不变，使用者的代码永远无需改变。这就提供一个良好的合作基础——或者说，只要接口这个基础约定不变，则代码改变不足为虑。

## 接口 ##

昨天上课的时候老师跟我泛泛而谈了一下接口，听说有的人懵了，接口定义广吗？接口定义不广吗？那就让我们一起来看看，它是个啥吧》》》

**接口：函数内部给外部提供的一个衔接工具，外部访问不需要提供源码就能使用**

API（Application Programming Interface，应用程序接口）是一些预先定义的接口（如函数、HTTP接口），或指软件系统不同组成部分衔接的约定。 \[1\] 用来提供应用程序与开发人员基于某软件或硬件得以访问的一组例程，而又无需访问源码，或理解内部工作机制的细节。

class Room:
        def __init__(self,name, owner, length, width,height):
            self.name=name
            self.owner=owner
            self.__length=length
            self.__width=width
            self.__height=height
    
        def area(self):
            res=self.__length*self.__width*self.__height
            print(res)
    
    d=Room("两房一厅","shimmer",10,20,10)
    d.area()

例如：上面的这段封装代码，函数在内部定义了一个方法area,就相当于在函数内部定义了一个接口area，在函数外部使用d.area()进行调用，然后访问到这个房间的面积

**普通的类中实现的方法，对于子类没有限制，而在父类中使用abc装饰了某个方法，这么做就限制子类必须实现装饰器方法，这种强制规范和约束，这种就可以称之为接口**

import abc
    class File(metaclass=abc.ABCMeta):
        @abc.abstractmethod
        def click(self):
            pass
    
    class Text(File):
        def click(self):
            print("open file")
    
    class ExeFile(File):
            def click(self):
                print("execute file")
    
    
    
    
    d=ExeFile()
    d.click()

## 多态，多态性 ##

1：多态：指的是同一类事物有多种形态  
例：动物可存在的形态：人，狗，猪

import abc
    class Animal(metaclass=abc.ABCMeta):
        all_type="animal"
        @abc.abstractmethod
        def run(self):
            pass
    class People(Animal):
        def run(self):
            print('people is running')
    class Dog(Animal):
        def run(self):
            print("Dog is running")
    class  Pig(Animal):
        def run(self):
            print("Pig is running")

文件可存在的形态：文本文件，可执行文件

2：多态性：指的是不考虑对象类型的情况下直接使用对象，例如：人狗猪都属于动物类，都有talk的功能，那我就可以直接调用

"""
    定义动物类：抽象基类：人狗猪，他们都有父类的功能talk
    """
    import abc
    class Animal(metaclass=abc.ABCMeta):
        @abc.abstractmethod
        def talk(self):
            pass
    
    class People(Animal):
        def talk(self):
            print("people is talking!!!!")
    
    class Dog(Animal):
        def talk(self):
            print("Dog is talking!!!!")
    
    class Pig(Animal):
        def talk(self):
            print("Pig is talking!!!!")
    
    
    #多态性：指的是在不考虑对象类型的情况下直接使用对象
    pig=Pig()
    dog=Dog()
    people=People()
    
    pig.talk()
    dog.talk()
    people.talk()
    
    # 也可以定义一个函数直接调用：
    def func(Animal):
        Animal.talk()
    
    func(pig)
    func(dog)
    func(people)

最后：  
Python崇尚鸭子类型，啥是鸭子类型，也就是：‘如果看起来像、叫声像而且走起路来像鸭子，那么它就是鸭子’  
例：

#二者都像鸭子,二者看起来都像文件,因而就可以当文件一样去用
    class TxtFile:
        def read(self):
            pass
    
        def write(self):
            pass
    
    class DiskFile:
        def read(self):
            pass
        def write(self):
            pass

在例如：序列类型有多种形态：字符串，列表，元组，但他们直接没有直接的继承关系。但是都可以使用len来统计大小  
这就是Python的多态性，Python的鸭子类型

[20210310211407687.png]: https://img-blog.csdnimg.cn/20210310211407687.png