Python类与对象----封装继承多态三大特性

---

三大特性

封装:提高程序的安全性
继承:提高代码的复用性
多态:提高程序的可扩展性和可维护性

封装

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('zhangsan',20)
stu.show()
print(stu.name)
#print(stu.__age) 这句话报错
print(dir(stu)) 
print(stu._Student__age)# 解除错误

继承

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

语法格式

class 子类类名(父类1,父类2...):
	pass

class Person(object):
    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,teachofyear):
        super().__init__(name,age)
        self.teachofyear=teachofyear


stu=Student("zhangsan",20,'101')
teacher=Teacher("lisi",50,1)
stu.info()
teacher.info()

方法重写

子类重写父类方法

class Person(object):
    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):
        super().info()
        print(self.stu_no)
class Teacher(Person):
    def __init__(self,name,age,teachofyear):
        super().__init__(name,age)
        self.teachofyear=teachofyear
    def info(self):
        super().info()
        print(self.teachofyear)

stu=Student("zhangsan",20,'101')
teacher=Teacher("lisi",50,1)
stu.info()
teacher.info()

object类

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

class A:
    pass

a=A()
print(dir(a))

[‘class’, ‘delattr’, ‘dict’, ‘dir’, ‘doc’, ‘eq’, ‘format’, ‘ge’, ‘getattribute’, ‘gt’, ‘hash’, ‘init’, ‘init_subclass’, ‘le’, ‘lt’, ‘module’, ‘ne’, ‘new’, ‘reduce’, ‘reduce_ex’, ‘repr’, ‘setattr’, ‘sizeof’, ‘str’, ‘subclasshook’, ‘weakref’]

class A:
    pass
a=A()
print(a)
class B:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __str__(self):
        return '我的名字{0},我的年龄{1}'.format(self.name,self.age)

b=B('小贺',20)
print(b)

多态

class Animal(object):
    def eat(self):
        print("动物吃饭")
class Dog(Animal):
    def eat(self):
        print("狗吃骨头...")
class Cat(Animal):
    def eat(self):
        print("猫吃鱼...")
class Person(object):#注意这里是object的子类
    def eat(self):
        print('人吃五谷杂粮')

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

fun(Cat())
fun(Dog())
fun(Animal())
#特殊
fun(Person())

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

静态语言实现多态的三个必要条件
1.继承
2.方法重写
3.父类引用指向子类对象
动态语言的多态崇尚’‘鸭子类型’'当看到一只鸟像鸭子,游泳起来像鸭子,那么这只鸟就可以被称为鸭子,在鸭子类型中,不需要关心对象是什么类型,到底是不是鸭子,只关心对象的行为

特殊方法和特殊属性

class A:
    pass
class B:
    pass
class C(A,B):
    def __init__(self,name,age):
        self.name=name
        self.age=age
x=C('Jack',20)
print(x.__dict__)#实例对象的属性字典
print(C.__dict__)
print(x.__class__)#输出对象所属的类
print(C.__bases__)#输出C类父类的元组
print(C.__base__)#输出C类第一个父类元组
print(C.__mro__)#查看层次结构
print(A.__subclasses__())#A的子类列表

a=20
b=100
c=a+b
d=a.__add__(b)
print(c)
print(d)
class Student:
    def __init__(self,name):
        self.name=name
    def __add__(self,other):
        return self.name+other.name

stu1=Student('zhangsan')
stu2=Student('lisi')
s=stu1+stu2
print(s)#报错,通过实现__add__特殊方法来实现
s=stu1.__add__(stu2)
print(s)

有关__new__和__init__方法的流程

类的赋值与深浅拷贝

变量的赋值操作:只是形成两个变量,实际上还是指向同一个对象
浅拷贝:Python拷贝一般都是浅拷贝,拷贝时,对象包含的子对象内容不拷贝,因此,源对象与拷贝对象会引用同一个子对象
深拷贝:使用copy模块的deepcopy函数,递归拷贝对象中包含的子对象,源对象和拷贝对象所有的子对象也不相同

class Cpu:
    pass
class Disk:
    pass
class Computer:
    def __init__(self,cpu,disk):
        self.cpu=cpu
        self.disk=disk

#(1)变量的赋值
cpu1=Cpu()
cpu2=cpu1
print(cpu1,id(cpu1))
print(cpu2,id(cpu2))
#(2)浅拷贝
disk=Disk()
computer=Computer(cpu1,disk)
import copy
computer2=copy.copy(computer)
print(computer,computer.cpu,computer.disk)
print(computer2,computer2.cpu,computer2.disk)

#(3)深拷贝
computer3=copy.deepcopy(computer)
print(computer,computer.cpu,computer.disk)
print(computer3,computer3.cpu,computer3.disk)

赋值
<main.Cpu object at 0x0000020FFB41CFD0> 2267663159248
<main.Cpu object at 0x0000020FFB41CFD0> 2267663159248
浅拷贝
<main.Computer object at 0x0000020FFB41CE50> <main.Cpu object at 0x0000020FFB41CFD0> <main.Disk object at 0x0000020FFB41CF70>
<main.Computer object at 0x0000020FFB41CD60> <main.Cpu object at 0x0000020FFB41CFD0> <main.Disk object at 0x0000020FFB41CF70>
深拷贝
<main.Computer object at 0x0000020FFB41CE50> <main.Cpu object at 0x0000020FFB41CFD0> <main.Disk object at 0x0000020FFB41CF70>
<main.Computer object at 0x0000020FFB41CC70> <main.Cpu object at 0x0000020FFB41C8E0> <main.Disk object at 0x0000020FFB41C880>

浅拷贝:

深拷贝