继承封装_sliots-CSDN博客

本文链接：https://blog.csdn.net/weixin_44806438/article/details/98850114

文章目录

- 属性的动态绑定和限制绑定
封装
继承

属性的动态绑定和限制绑定

__ sliots __ = ()

封装

1. 概念

广义的封装：函数的类和定义，都是封装的体现
狭义的封装：一个类的某些属性，在使用的过程中，如果不希望被外界直接访问，而是将该属性设置为私有的【只有当前类持有】，然后暴露给外界一个访问的函数即可,==私有变量,用公有的方法封装私有属性,方法叫封装==
封装的本质：将属性和方法私有化的过程
封装的好处：提高了代码的安全性，提高了数据的复用性
举例：插排，不需要关心属性在类的内部做了什么样的操作，只需要关心如何将值传递进去，如和将值获取出来

2. 属性私有化

private ： 私有的  public ：公开的
只需要在构造函数中定义的变量名的前面添加两个下划线，则该属性就是一个私有属性
私有化属性的特点：只能在当前类中直接访问，不能在外界直接访问

#1.属性未被私有化
class Person1():
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def show(self):
        print("name;%s,age:%d" % (self.name,self.age))

p1 = Person1("111",11)
#直接访问
print(p1.name,p1.age)
p1.name = "aaa"
p1.age = 12
print(p1.name,p1.age)

p1.show()

#2.属性被私有化
class Person2():
    def __init__(self,name,age):
        self.name = name
        self.__age = age
    def show(self):
        print("name;%s,age:%d" % (self.name,self.__age))

p2 = Person2("222",22)
#直接访问
print(p2.name)
#注意：如果一个属性被私有化，则在类的外面不能直接访问
#print(p2.age)
#print(p2.__age)

#动态绑定
# p2.age = 18
# print(p2.age)

#私有化属性的工作原理
#__xxx,在计算机的底层，该变量被Python解释器解释成了_类名__xxx
#使用_类名__xxx虽然可以访问到被私有化的属性，但是不建议这么访问，，Python语言是跨平台的，
# 在不同的平台下，Python解释器对同一条语句解释的结果可能不同
#print(p2._Person2__age)

p2.show()

3. get函数和set函数

get和set不是系统函数，都是自定义的，为了和封装的概念吻合，起名为getXxx和SetXxx
get：获取，获取私有属性的值
set：设置，给私有属性传值

#问题：在外界不能直接访问私有属性，但是非要访问？
#解决办法：提供给外界一个访问的接口即可
#3.get函数和set函数
class Person3():
    def __init__(self,name,age):
        self.__name = name
        self.__age = age
    def show(self):
        print("name;%s,age:%d" % (self.__name,self.__age))

    #get函数：
    #作用：将私有属性的值返回给外界
    #命名格式：getXxx,xxx表示被私有化属性的名称
    #特点：设置返回值
    def getAge(self):
        return self.__age

    #set函数
    #作用：给私有化型重新赋值
    #命名格式：setXxx
    #特点：设置参数
    def setAge(self,age):
        self.__age = age

    def getName(self):
        return self.__name
    def setName(self,name):
        self.__name = name

p3 = Person3("333",33)
#获取值
print(p3.getAge())
#传值，给私有化属性重新赋值
p3.setAge(35)
print(p3.getAge())

print(p3.getName())
p3.setName("hello")
print(p3.getName())

4. @property装饰器

#4.使用装饰器间接访问私有属性
#@property装饰器，可以将函数当做属性访问
#@xxx.setter装饰器
#4.1@property的作用：处理私有化属性
class Person4():
    def __init__(self,name,age):
        self.__name = name
        self.__age = age
    def show(self):
        print("name;%s,age:%d" % (self.__name,self.__age))

    #@property装饰器，相当于get函数，设置返回值，将私有化属性的值返回
    #注意：函数名可以是任意的标识符，但是，为了提高代码的可读性，一般命名一致
    @property
    def name(self):
        return self.__name

    #@name.setter装饰器，相当于set函数，设置参数，给私有属性赋值
    #注意：@xxx.setter,xxx的命名必须和@property修饰的函数的名称完全一致
    @name.setter
    def name(self,name):
        self.__name = name

    @property
    def age(self):
        return self.__age

    @age.setter
    def age(self,age):
        if age < 0:
            age = -age
        self.__age = age

p4 = Person4("4444",10)
# print(p4.name())
print(p4.name)     #调用的是@property修饰的函数
p4.name = "hfajhf"   #调用的是@xx.setter修饰的函数
print(p4.name)

print(p4.age)
p4.age = -19
print(p4.age)

#面试题
#注意：@property可以单独使用，可以将任意一个成员函数转化为属性使用
class MyClass():
    @property
    def show(self):
        print("showing")
        return "fahjkfh"

m = MyClass()
print(m.show)

5.属性的其他形式
"""
【面试题】解释下面定义在类中的不同形式变量的含义
a:普通的变量【public】，在类的内部和外部都可以直接访问
_a:受保护的变量【Protected】，只能在子类中直接访问，建议在类的外面不要直接访问
__a：私有化属性【private】，只能在当前类的内部访问，在外界不能直接访问
__a__：系统的变量，如：__init__,__del__,__name__,__slots__等，自定义的变量尽量不要这种形式
"""
class Person5():
    def __init__(self,name,age):
        self._name = name
        self.__age__ = age
    def show(self):
        print("name;%s,age:%d" % (self._name,self.__age__))

p5 = Person5("555",5)
print(p5._name)
print(p5.__age__)

5.函数私有化

#6.函数私有化
#和属性的私有化相同，如果想让一个函数只能在类的内部被调用，可以在函数名的前面添加两个下划线
class Person6():
    def __init__(self,name,age):
        self.__name = name
        self.__age = age
    def __show(self):
        print("name;%s,age:%d" % (self.__name,self.__age))

    def func(self):
        #注意：在类的内部，任意两个函数之间进行调用，调用格式为：self.xxx()
        self.__show()

p6 = Person6("66",6)
#p6.show()   #AttributeError: 'Person6' object has no attribute 'show'
p6.func()

继承

1. 概念

类和类之间的关系：
　　is-a：继承或者泛化，比如：学生类和人类
　　has-a：关联，部门和员工的关系，整体和部分的关联
　　use-a：依赖，司机有一个驾驶的行为
如果两个或者两个以上的类中存在相同的属性或者函数，我们可以抽象一个类，在抽取出来的类中定义公共的属性或者函数
　　被抽取出来的类：父类　　超类　　基类
　　两个或者两个以上的类：子类　派生类
　　关系：子类　继承自　父类　或者　父类　派生了　子类

2. 单继承

一个子类只有一个父类，被称为单继承
语法：
父类：
class 父类类名
　类体
子类：
　class 子类类名（父类类名）：
　类体

a.如果子类中没有定义构造函数
注意1：如果子类中没有定义构造函数，创建子类对象的时候，会默认调用父类中的构造函数同时通过子类对象访问父类中未被私有化的属性和成员函数

b.如果子类中定义了构造函数
注意2：如果子类中定义了构造函数,创建子类对象的时候，会调用子类中的构造函数，但是，如果想要使用父类中的属性，则在子类IDE构造函数中需要手动调用父类的构造函数

c.注意3：不管是什么类型的继承，创建对象的时候，都要保证参数的匹配

d.父类的对象访问子类中特有的数据
注意4：父类不能访问子类中特有的属性或者方法

在子类的构造函数中调用父类的构造函数
方式一：super(当前类,self).init(属性列表)
super(Worker,self).init(name,age)

    方式二：父类名.__init__(self,属性列表)
    Person.__init__(self,name,age)

    方式三:super().__init__(属性列表)
    注意：在父类中限制属性的动态绑定，该操作对子类没有任何作用，如果子类也需要限制绑定，必须手动在子类中设置

函数的重写

系统函数

重写object类中的__str__
1.未重写

class Animal(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def show(self):
        print("父类~~~show")

    #重写object类中的__str__
    def __str__(self):
        #return 199   #__str__ returned non-string (type int)
        return  "name=%s,age=%s" % (self.name,self.age)

    # def __repr__(self):
    #     return "fajkfgah"

    __repr__ = __str__

a = Animal("aaa",10)

需求：打印对象，获取对象的信息
print(a) #<main.Animal object at 0x0000021ED10A9128>
注意1：打印一个对象的时候，默认调用object中的__str__,该函数默返回当前对象的地址
print(a.str()) #<main.Animal object at 0x0000021ED10A9128>
2.重写
__repr__和__str__一样，只不过__str__是给用户识别的，__repr__是给计算机识别的
“”"
1.当repr和str都未被重写，打印对象，优先调用的是str
2.当str被重写，repr未被重写，打印对象，优先调用的是str
3.当repr被重写，str未被重写，打印对象，优先调用的是repr
4.当repr和str都被重写，打印对象，优先调用的是str

自定义函数

class Animal(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def show(self):
        print("父类~~~show")

class Cat(Animal):
    pass

class Dog(Animal):
    def __init__(self,name,age,color):
        super().__init__(name,age)
        self.color = color

    #重写：如果父类中的函数满足不了子类的需求，则在子类中需要重新实现指定的函数
    def show(self):
        print("子类~~~~show")

#创建子类的对象
d = Dog("大黄",5,"黄色")
#结论：如果在子类中重写了父类中的函数，则通过子类的对象调用，优先调用子类中的函数
d.show()

3. 多继承

一个子类可以有多个父类,被称为多继承
语法:
class 子类类名(父亲1,父亲2,…):
　　类体
基本使用
创建子类的对象

1.父类和子类中都没有定义构造函数，默认调用的是父类列表中第一个父类中的构造函数
2.如果父类中定义了构造函数，子类中没有定义，默认调用的是父类列表中第一个父类中的构造函数
注意：如果在多个父类中出现了重名的函数，使用子类对象调用，默认调用父类列表中第一个父类中的函数

调用父类中的构造函数
注意：如果在子类中要调用所有父类的构造函数，则使用父类类名.init(属性列表)

#父类
class BaseClass(object):
    def show(self):
        print("baselass")

#子类
class SubClassA(BaseClass):
    def show(self):
        print("enter subclass~~~~A")
        super().show()
        print("exit subclass~~~~A")

class SubClassB(BaseClass):
    def show(self):
        print("enter subclass~~~~B")
        super().show()
        print("exit subclass~~~~B")

class SubClassC(SubClassA):
    def show(self):
        print("enter subclass~~~~C")
        super().show()
        print("exit subclass~~~~C")

class SubClassD(SubClassB,SubClassC):
    def show(self):
        print("enter subclass~~~~D")
        super().show()
        print("exit subclass~~~~D")

s = SubClassD()
s.show()

"""
继承树：
    在多继承树中，如果在中间某层有向上一层解析的迹象，则会按照父类列表中父类的顺序解析，
    将所有类中的方法全部解析完毕，然后从本层继续向上解析，这种现象被称为从子类到超类的反向树中广度优先解析

    在上面的代码中，先从D开始进入B，因为B有向上一层解析的迹象，所以先解析C,然后由C进入了A,最后直接解析根类BaseClass


经典类：Py2.x，没有继承object的类以及它的子类，采用的深度优先解析
新式类：py3.x，继承自object的类以及它的子类，采用的广度优先解析

"""