Python学习系列之面向对象的三大特征（封装、继承、多态）（二十七）

面向对象的三大特征

1、封装：提高程序的安全性

• 将数据（属性）和行为（方法）包装到类对象中。在方法内部对属性进行操作，在类对象的外部调用方法。这样，无需关心方法内部的具体实现细节，从而隔离了复杂度。
• 在Python中没有专门的修饰符用于属性的私有，如果该属性不希望在类对象外部被访问，前边使用两个“_”。

2、继承：提高代码的复用性

3、多态：提高程序的可扩展性和可维护性

 

一、封装

一个类就是一个封装，将类的属性、变量、方法全部封装在类里面

代码示例：

'''封装'''
class Car:
    def __init__(self,brand):
        self.brand=brand
    def start(self):
        print('汽车已启动....')

car=Car('宝马X5')
car.start()
print(car.brand)

　　执行结果：

 

 如果属性不想在类外部使用，则只需要在属性前加"__"，示例代码如下：

#对象不想在类外部使用，在属性前使用__进行标记
class Student:
    def __init__(self,name,age):
        self.name=name
        self.__age=age

    def show(self):
        print(self.name,self.__age)

stu=Student('张三',20)
stu.show()
#在类之外使用name和age
print(stu.name)
# print(stu.__age)    #直接使用会报错AttributeError: 'Student' object has no attribute '__age'
#print(dir(std))
print(stu._Student__age)    #此种方法调用，能正确执行并返回

　　执行结果：

  说明：__age可以在外部被使用，此种写法就是告诉开发者不要在外部使用该属性

 

二、继承及其实现方式

继承

• 语法格式

　　　　class 子类类名（父类1，父类2...）：

　　　　　　pass

• 如果一个类没有继承任何类，则默认继承Object
• Python支持多继承
• 定义子类时，必须在其构造函数中调用父类的构造函数

代码示例：

'''继承'''
class Person():     #父类
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def info(self):
        print(self.name,self.age)

class Student(Person):      #子类
    def __init__(self,name,age,stu_no):
        super().__init__(name,age)
        self.stu_no=stu_no

class Teacher(Person):      #子类
    def __init__(self,name,age,tea_no):
        super().__init__(name,age)
        self.tea_no=tea_no

stu=Student('张三',20,'1001')
teacher=Teacher('李四',30,10)
stu.info()      #info方法是从父类Person类继承过来的
teacher.info()

　　执行结果：

  说明：stu调用的info()方法都是从父类中继承过来的

上面示例中的继承关系图如下：

  

• Python支持多继承

 

'''多继承'''
class A():
    pass

class B():
    pass

class C(A,B):
    pass

　　上述代码的示意图：

 

 说明：class C(A,B)表示C类既继承了A类，也继承了B类

三、方法重写

方法重写

• 如果子类对继承父类的某个属性或方法不满意，可以在子类中对齐（方法体）进行重新编写
• 子类重写后的方法中可以通过super().xxx()调用父类中被重写的方法

要输出学生的学生编号和教师的教龄，示例代码：

'''重写
重写父类的方法'''
class Person():     #父类
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def info(self):
        print(self.name,self.age)

class Student(Person):      #子类
    def __init__(self,name,age,stu_no):
        super().__init__(name,age)
        self.stu_no=stu_no
    def info(self):     #重写了父类的info()方法
        super().info()
        print(self.name+'的学生编号是：'+self.stu_no)

class Teacher(Person):      #子类
    def __init__(self,name,age,teachofyear):
        super().__init__(name,age)
        self.teachofyear=teachofyear
    def info(self):     #重写了父类的info()方法
        super().info()
        print(self.name+'的教龄是：',self.teachofyear)

stu=Student('张三',20,'1001')
teacher=Teacher('李四',30,10)
stu.info()
print('-----------------------')
teacher.info()

　　执行结果：

 说明：重写是子类在自己的类中重新定义父类的方法，即在子类中定义和父类一样的方法名的方法，然后添加自己的业务代码，这段示例代码中，Student类和Teacher类重写了父类的info()方法，重写父类的方法时需要使用super().info()来对父类方法进行调用，学生编号和教龄是通过重写父类方法来输出的

 

四、object类

 object类

• object类是所有类的父类，因此所有类都有object类的属性和方法。
• 内置函数dir()可以查看指定对象所有的属性
• object类有一个__str__()方法，用户返回一个对于“对象的描述”，对应于内置函数str()经常用于print()方法，帮我们查看对象的信息，所以我们经常会对__str__()进行重写

1. 查看object类的所有属性和方法

class Student:
    pass

stu=Student()
print(dir(stu))

　　执行结果：

 说明：使用dir()方法可以查看Object类的所有属性和方法，stu是Student类的实例对象，Student类默认继承自Object类，所以执行dir(stu)会将object类的属性和方法全部查询出来，这些属性和方法都不是Student类里定义的

2. __str__()方法，用户返回一个对于“对象的描述”

class Student:
    pass

stu=Student()
print(stu)

　　执行结果：

 说明：print(stu) 调用的是object类的 __str__()方法，输出的是stu这个对象的描述，包括对象类型和内存地址

我们可以通过重写__str__()方法，来输出自己的描述

'''重写__str__()方法来返回自己的描述'''
class Student:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __str__(self):      #重写object类的__str__()方法
        return '我的名字是{0}，今年{1}岁'.format(self.name,self.age)

stu=Student('张三',20)
# print(dir(stu))
print(stu)
print(type(stu))

　　执行结果：

 说明：__str__()方法默认返回的是对象的描述，在Student类中重写了object的__str__()方法，返回了自己的描述

 

五、多态的实现

 示例代码：

'''多态'''
class Animal:
    def eat(self):
        print('动物会吃')

class Dog(Animal):
    def eat(self):
        print('狗吃骨头....')

class Cat(Animal):
    def eat(self):
        print('猫吃鱼')

class Person:
    def eat(self):
        print('人吃五谷杂粮')

#定义一个函数
def fun(obj):
    obj.eat()

#开始调用函数
fun(Dog())
fun(Cat())
fun(Animal())
print('--------------')
fun(Person())

　　执行结果：

 说明：代码中Cat类和Dog类继承了Animal类，重写了Animal中的eat()方法，所以当输入Dog和Cat的对象时，会去执行Dog类和Cat类中的eat方法，但是Person类并没有继承Animal类，只是因为它有eat()方法，所以也会去执行Person类中的eat()方法，这就是和其它变成语言不一样的地方，这叫鸭子类型，Python是一门动态语言，可以动态地去绑定属性和绑定方法。

什么是动态语言

• 动态语言的多态崇尚“鸭子类型”，当看到一只鸟走起来像鸭子，游泳起来像鸭子，收起来像鸭子，那么这只鸟就可以被称为鸭子。在鸭子类型中，不需要关系对象是什么类型，到底是不是鸭子，只关心对象的行为。

静态语言和动态语言的区别：

静态语言实现多态的三个必要条件

• 继承
• 方法重写
• 父类引用指向子类对象

 java是静态语言，实现多态必须满足继承、方法重写、父类引用指向子类对象

 

六、特殊属性和特殊方法

	名称	描述
特殊属性	__dict__	获得类对象或示例对象所绑定的所有属性和方法的字典
特殊方法	__len__()	通过重写__len__()方法，让内置函数len()的参数可以是自定义类型
	__add__()	通过重写__add__()方法，可使用自定义对象具有“+”功能
	__new__()	用于创建对象
	__init__()	对创建的对象进行初始化

 1. __add__()

'''__add__'''
a=20
b=100
c=a+b   #两个整数类型的对象的相加操作
print(c)
d=a.__add__(b)
print(d)

　　执行结果：

  说明：当计算a+b时，底层其实执行的是a.__add__(b)

练习：使两个字符串相加

class Student:
    def __init__(self,name):
        self.name=name

stu1=Student('张三')
stu2=Student('李四')
s=stu1+stu2
print(s)

　　执行结果：

 说明：stu1和stu2是两个字符串，不能直接进行相加操作

 如果要使两个字符串相加，则需要自己重新定义相加的方法

class Student:
    def __init__(self,name):
        self.name=name

    def __add__(self, other):
        return self.name+other.name

stu1=Student('张三')
stu2=Student('李四')
s=stu1+stu2　　　　#实现了两个对象的加法运算（因为在Student类中，编写__add()__特殊的方法）
print(s)
s1=stu1.__add__(stu2)
print(s1)

　　执行结果：

  

2.__len()__方法

'''__len()__'''
lst=[11,22,33,44]
print(len(lst))     #len()是内置函数
print(lst.__len__())

　　执行结果：

  说明：使用len()和__len()__方法的执行结果一样，说明特殊方法__len()__和内置函数len()是对应的

联系：输出字符串的长度

'''__len()__'''
class Student:
    def __init__(self,name):
        self.name=name

    def __add__(self, other):
        return self.name+other.name

    def __len__(self):
        return len(self.name)

stu1=Student('jack')
print(len(stu1))       #会报错，提示TypeError: object of type 'Student' has no len()
#如果想要计算string类型的长度，则需要自己的手动写len()方法

　　执行结果：

 3. new和init方法

 

class Person(object):
    def __new__(cls, *args, **kwargs):
        print('__new__被调用执行了，cls的id值为{0}'.format(id(cls)))
        obj=super().__new__(cls)
        print('创建的对象的id为：{0}'.format(id(obj)))
        return obj

    def __init__(self,name,age):
        print('__init__被调用了，self的id值为：{0}'.format(id(self)))
        self.name = name
        self.age = age

print('object这个类对象的id为:{0}'.format(id(object)))
print('Person这个类对象的id为：{0}'.format(id(Person)))

#创建Person类的实例对象
p1=Person('张三',20)
print('p1这个Person类的实例对象的id：{0}'.format(id(p1)))

　　执行结果：

 

 说明：