1. 封装

类有三种权限，分别是public,protected和private.这三者区别如下：

public：类外可以访问，类内可以访问，子类可以继承父类的所有属性特征。

protected：类外不可以访问，类内可以访问，子类可以继承父类的所有特征特性。

private：类外不可以访问，类内可以访问，子类不可以继承父类所有特性。

这里的权限时逐渐封闭，在private达到最高级别。同时访问权限的确定和修改不会影响程序的性能。

封装就是将现实世界中的属性行为转化为程序中的类的成员变量和成员方法的过程称之为封装。封装不代表所有的属性和行为都会开放给用户，即私有的成员变量和行为。封装可以很大限度的保护程序的安全，减少程序的安全隐患。

  • 私有成员变量和方法：私有方法无法直接被类调用，私有成员无法赋值和取值

私有成员和私有变量的构建方法：

1
2
3
4
class 名称：
	__成员变量名
    
    def __方法名

注意：

  1. 私有成员变量进行调用赋值时不会报错，但是操作无效
  2. 私有方法的调用会报错
  3. 私有成员可以由内部去使用

例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class STU:
    __age=20
    name=None
    
    def __init__(self,name):
        self.name=name
        
    def __printms(self):
        print("学生信息")
        
stu=STU("张三")
#1
stu.__age=18
#2
stu.__printms()

运行结果如下：

image-20231222152054055

私有成员的使用：

私有成员在类中时可以由其他公开成员方法去调用从而使用

例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class STU:
    __age=20
    name=None
    
    def __init__(self,name):
        self.name=name
        
    def printms(self):
        if self.__age >=18:
        	print("学生成年")
        else:
            print("学生未成年")
        
stu=STU("张三")
stu.printms()

输出结果为：

image-20231222152652001

所以私有成员仅供内部成员方法使用。

2. 继承

继承就是将将已有的功能调用继续使用，而被调用的部分为父类，调用的类成为子类。

基础语法：

1
2
3
4
5
6
7
8
9
class 类1：
	成员变量
    
    成员方法
    
class 类2(类1)：
	成员变量
    
    成员方法

在上述格式中，类1称为父类，类2称为子类，继承分类单继承和多继承即继承一个类或者继承多个类，如果子类对杜雷的某一变量需要更改则可以直接进行赋值，称之为复写

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class engine:
    n=4
    id=1105
    type=1
    
class engine2(engine):
    type=2
    
class carbox:
    length="长车型"
    
class Car(carbox,engine):
    def printms(self):
		print(f"汽车发动机缸数为{self.n},型号为{self.id},车身长短为{self.length}")

car=Car()
car.printms()

以上engine2为单继承，继承了engine的内容,在engine2中type复写了2剩下的属性则可以继续使用。而Car则是使用了多继承将engine和carbox的内容整合输出。

输出结果为：

image-20231222154402455

而在继承中如果出现多继承时有相同成员变量存在则会满足就近原则。即调用最靠左的父类名称中的变量

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
class massage1:
    ms=123456
    
class massage2:
    ms=654321
    
class ms(massage1,massage2):
    def printf(self):
        print(self.ms)
        
MS=ms()
MS.printf()

输出结果如下：

image-20231222154822273

所以输出了massage1中的内容，那么我们也可以直接选择性调用自己所需要的父类成员。

父类成员我们也可以选择直接调用

基础格式：

1
2
3
4
5
super().成员变量
super().成员方法()

父类名.成员变量
父类名.成员方法(self)

注意：

  1. 在这里用super（）在调用方法时不需要加self，但是重名时仍然会遵循就近原则
  2. 直接使用父类名在方法使用上需要加self
  3. 直接调用时会直接忽略子类的复写

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class massage1:
    ms=123456
    
class massage2:
    ms=654321
    
class ms1(massage1,massage2):
    def printf(self):
        print(massage2.ms)
        
class ms2(massage1):
    ms=123
    def printf(self):
        print(super().ms)
        
MS1=ms1()
MS1.printf()
MS2=ms2()
MS2.printf()

输出结果为：

image-20231222155707784

3. 多态

多态即为多种状态，在使用不同对象时会得到不同状态。父类作为定义声明，子类作为实际对象工作。

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class system:
    def printf(self):
        pass
    
class windows(system):
    def printf(self):
        print("windows系统")
        
class mac(system):
    def printf(self):
        print("苹果系统")
        
def printfs(system:system):
    system.printf()
    
        
win=windows()
m=mac()

printfs(win)
printfs(m)

在上述程序中子类继承父类格式，创建不同的类执行不同的代码，实现多态。

这里的父类是使用空方法，叫做抽象类（也叫接口）通常配合多态使用。

  • 抽象类：含有抽象方法的类

  • 抽象方法：方法体为空实现（pass）

含义：

  1. 父类来确定方法有哪些（预定设计模板）
  2. 具体实现方法由子类自行决定。

优点：可以提前制定一个指标用来为子类确定设计标准

资料参考

b站的黑马程序员