敲黑板,面向对象的三大特征:
封装、继承和多态。
封装
封装性
封装就是隐藏底层的实现细节,只提供公有的接口供外界访问, 这样当底层实现细节改变的时候,就不会对外界造成影响。
私有属性
在类的设计角度,我们可以将属性或方法(类的成员)定义为私有,来实现封装。
私有成员只能在定义类的内部进行访问,在类外是无法进行访问的。
私有成员的定义方式:以_进行开头,但是不能以两个或多个进行结尾。
class Computer:def __init__(self,cpu):self.cpu = cpu# 私有属性(私有的实例属性)self.__memory = 1024# 在定义私有属性“类的内部”,可以访问私有成员#print(self.__memory)c = Computer("某cpu")c.__memory # 可以发现私有属性不能够在外部直接访问
结果如下:
class Computer:def __init__(self,cpu):self.cpu = cpu# 私有属性(私有的实例属性)self.__memory = 1024# 在定义私有属性“类的内部”,可以访问私有成员print(self.__memory)def x(self):pass# 如果想要采用公有的方法(在类的外部),访问私有属性。需要额外定义两个方法def set_memory(self,memory):self.__memory = memorydef get_memory(self):return self.__memoryc = Computer("某cpu")c.get_memory()
结果如下:
为什么非要定义为:私有属性呢?定义为一般的实例属性不是也可以吗?
原因在于:定义为私有属性后。当我们以后需要对类中某属性做出修改时,只需要在内部修改,而不会对外部的使用者,产生影响。
假如不将memory定义为私有属性
class Computer:def __init__(self, cpu):self.cpu = cpuself.memory = 1024c = Computer("某cpu")print(c.memory)# 1024c.memory = 6666print(c.memory)# 6666
假如说,由于某种业务要求,需要将memory改为memory2,那么,我们不仅需要在内部进行修改。同时外部调用者也需要进行修改。假如你有很多粉丝使用这个,估计都会骂你(假如代码中有很多行都需要将memory改为memory2)
其实,私有属性也并非真正的私有。只是将名称进行了一下伪装而已。
伪装成了:类名_私有属性的名称
这就意味着,在类的外部,我们可以通过真实名称对私有属性进行访问。
但是,不建议这么做。伪装就是为了保证封装性,而你非要去捅破。
class Computer:def __init__(self,cpu):self.cpu = cpuself.__memory = 1024c = Computer("某cpu")c.__memoryc._Computer__memory # 切记不要这么做。这样做破坏了封装性
结果如下:
继承
继承之前
class PythonTeacher:def __init__(self,name,group):self.name = nameself.group = groupdef introcude(self):print(f"我的名字是{self.name},所在小组是{self.group}")def teach(self):print("打开pycharm")print("输入代码")print("知识点讲解")class JaVaTeacher:def __init__(self,name,group):self.name = nameself.group = groupdef introcude(self):print(f"我的名字是{self.name},所在小组是{self.group}")def teach(self):print("打开eslipse")print("输入代码")print("知识点讲解")
实现继承
继承体现的是一般与特殊的关系。如果两个类A与B,A(苹果)是一种特殊的B(水果),则我们就称A继承了B,A就是子类,B就是父类。
子类一旦继承了父类,子类就会成为一种特殊的父类,子类就会具备父类的一切特征。因此,父类能够做的事情,子类也可以做到。
子类继承了父类,子类就会继承父类中定义的成员,就好象子类中自己定义了一样。
class Fruit:def show(self):print("水果")# 继承,在定义类时,给出继承的父类class Apple(Fruit):passf = Fruit()f.show()a = Apple()a.show()
结果如下:
定义类时,若没有显示的继承任何类,则表明继承object类,object是python中最根层次的类。
我们可以将公共的功能提取出来,放入父类中。然后使用每一个子类去继承父类。这样,就无需将这些公共的功能分别放在子类中实现。从而避免了代码的重复性。
子类继承父类,子类可以吸收“父类的功能”,此外,子类还可以增加自己特有的功能。如果父类的功能对于子类来说不适用,子类就可以改造(重写)父类中的功能。
class Bird:def fly(self):print("鸟飞")def describe(self):print("有羽毛,无牙齿,蛋生")class Ostrich(Bird):# 父类中的fly功能,不适合鸵鸟。因此,子类需要对父类的功能进行修改def fly(self):print("不会飞")# 子类增加自己特有的功能def run(self):print("高速奔跑")c = Ostrich()c.fly(),c.describe(),c.run()
结果如下:
成员继承
子类可以继承父类中定义的:类属性、实例属性;类方法、实例方法;静态方法。
class Father:class_attr = 1def __init__(self):self.instance_attr = 2def instance_method(self):pass@classmethoddef class_method(cls):pass@staticmethoddef static_method():passclass Son(Father):passs = Son()
然后子类就可以调用父类的类属性、实例属性;类方法、实例方法;静态方法。
对于父类中的实例属性,我们需要留意。如果子类中定义了自己的init方法,则不会调用父类的init方法。因此,父类方法中绑定的实例属性,就不会绑定到子类对象上,也就是说父类的实力属性,子类不会得到继承。
class Father:class_attr = 1def __init__(self):self.instance_attr = 2def instance_method(self):pass@classmethoddef class_method(cls):pass@staticmethoddef static_method():passclass Son(Father):def __init__(self):passso = Son()so.instance_attr
结果如下:
有时候,父类的初始化,可能"并不完全适合于"子类。这是,子类需要定义自己的init方法。
"并不完全适合于"指的是:父类中,有的实例属性适合雨子类,有的不适合于子类。子类中既要定义自己的init方法,又想使用父类中部分实例属性,那么该怎么做呢?
class Person():delf __init__(self,name,age):self.name = nameself.age = ageclass Student(Person):delf __init__(self,name,age,id):self.name = nameself.age = ageself.id = id# 父类的初始化不完全适合于子类,但是,也没有完全不适合于子类
整改:在子类的init方法中,去调用父类的init方法,这样可以"避免代码重复"。
super()方法登场
class Person():def __init__(self,name,age):self.name = nameself.age = ageclass Student(Person):def __init__(self,name,age,id):# 调用父类的__init__方法super().__init__(name,age) # 调用父类的__init__方法self.id = ids = Student("梁某人",18,2017011)s.name,s.age,s.id
结果如下:
私有属性的继承
实际上,私有属性也是可以被子类继承的。只不过,子类继承的不是私有属性本来的名字,而是私有属性伪装后的名字。
虽然子类可以继承并访问父类的私有属性,但是不建议这么做。既然是私有的,肯定是不愿意我们去访问的。
class Father:def __m(self):print("私有方法")class Son(Father):def p(self):# 通过伪装之后的名字,进行访问self._Father__m()s = Son()s.p()
结果如下:
两个关于继承的内建函数
① isinstance(参数一,参数二)
- 第一个参数:对象;
- 第二个参数:类型;
- 含义:判断第一个指定的参数指定的"对象",是否是第二个参数的指定类型(包括其父类性);
class Father:passclass Son(Father):passf = Father()s = Son()
来检测一下:
② issubclass()
- 第一个参数:类型;
- 第二个参数:类型;
- 含义:判断第一个指定的参数类型,是否是第二个参数的指定类型(或者是其子类型);
class Father:passclass Son(Father):passf = Father()s = Son()
再来检测一下:
重写
当父类中的成员,对子类不完全适用时,子类就可以重新定义该成员。
class Bird:def fly(self):print("鸟飞")class Ostrich(Bird):# 父类中的fly功能,不适合鸵鸟。因此,子类需要对父类的功能进行修改def fly(self):print("不会飞")# 子类增加自己特有的功能def run(self):print("高速奔跑")o = Ostrich()o.fly()
结果如下:
class Bird:def fly(self):print("鸟飞")class Ostrich(Bird):# 父类中的fly功能,不适合鸵鸟。因此,子类需要对父类的功能进行修改def fly(self):# 通过super()方法,可以实现对父类中同名方法的访问super().fly() # super()既可以调用父类中的私有属性。也可以调用父类中的方法print("不会飞")o = Ostrich()o.fly()
结果如下:
多重继承
python中,一个子类可以继承多个父类。多个父类的成员,都可以被子类所继承。继承多个父类使用 , 分割。
class Rectangle:def area(self):print("矩形求面积")class Diamond:def area(self):print("菱形求面积")class Square(Rectangle,Diamond): #总是按照这里的先后顺序,一一继承def t(self):self.area()s = Square()s.t()
结果如下:
class Rectangle:def area(self):print("矩形求面积")class Diamond:def area(self):print("菱形求面积")class Square(Diamond,Rectangle): #总是按照这里的先后顺序,一一继承def t(self):self.area()s = Square()s.t()
结果如下:
多继承:按照继承原则,每个父类看作一个分支。按照顺序进行查找,深度优先。但是有一个原则:子类一定会在父类之前被搜索。
class Teacher:def __init__(self,name,group):self.name = nameself.group = groupdef introcude(self):print(f"我的名字是{self.name},所在小组是{self.group}")def teach(self):print("输入代码")print("知识点讲解")class PythonTeacher(Teacher):def __init__(self,name,group):super().__init__(name,group)def teach(self):print("打开pycharm")super().teach()class JaVaTeacher(Teacher):def __init__(self,name,group):super().__init__(name,group)def teach(self):print("打开eslipse")super().teach()p = PythonTeacher("梁某人", 10)print(p.introcude(), p.teach())
结果如下:
j = JaVaTeacher("梁三",666)print(j.group,j.teach())
结果如下:
多态
这个在python中基本体现不出来,知道面向对象有多态这个特性就行了。