初步理解面向对象

"""
面向过程
    变量、函数杂乱无章，不便于管理和维护
面向对象
    变量、函数封装在对象里，以便于程序管理和维护
"""
# 请同学将自己的姓名，性别，年龄上传给老师
# 面向过程，方法各式各样，不好管理
stu1 = "我叫小明，今年23岁，性别男"
stu2 = {'姓名':'小红', '性别':'女', '年龄':'22'}
stu3 = ['张三', '男', '25']
​
# 面向对象 便于管理与维护
# 1.在程序中设计表格，我们称之为：设计类（class）
class Student:
    # 设计表格的内容
    name = None
    gender = None
    age = None
# 2.在程序中打印表格，我们称之为：创建对象
# 基于类创建对象
stu_1 = Student()
stu_2 = Student()
​
# 3.在程序中填写表格，我们称之为：对象属性赋值
stu_1.name = "小明"
stu_1.gender = "男"
stu_1.age = "23"
​
stu_2.name = '小红'
stu_2.gender = '女'
stu_2.age = '20'
​
# 4.获取对象中记录的信息
print(stu_1.name)
print(stu_1.gender)
print(stu_1.age)

类的定义与使用

"""
类的创建方法
class 类名称:
    类的属性
​
    类的行为
​
class是关键字，表示要开始定义类了
类的属性 -> 定义在类中的变量(成员变量)
类的行为 -> 定义在类中的函数(成员方法)
​
创建类的对象的语法：
对象 = 类名称()
​
类中定义成员方法和定义函数基本一致，但有细微区别
def 方法名(self,形参1,....,形参n):
    方法体
​
self关键字：
    成员方法定义时，必须填写的(通常会自己补全)
它用来表示类对象自身的意思
当我们使用类对象调用方法时，self会自动被python传入
*在方法内部，想要访问类的成员变量，必须使用self访问
"""
# 定义一个类
class Student:
    # 设计表格的内容
    name = None
    # 创建类的行为/方法：本意为在类中创建所有对象使用的函数
    def success(self):
        print(f'{self.name}同学已成功在老师这里报名')
    def say_hi(self):  #  self关键字是在方法中必须出现的一个关键字，当然也可以忽略它，但是必须要存在
        print('同学们好，老师好')
    def say_hi2(self, msg):
        print(f'大家好，我是{self.name}，{msg}')
# 基于类创建对象
stu1 = Student()
stu1.name = "小明"
stu1.success()
stu1.say_hi()
​
stu2 = Student()
stu2.name = '周杰轮'
stu2.say_hi2('哎哟不错哦')
​
# 以上属性赋值需要依次进行，略显繁琐，有没有更加高效的方式，能够一行代码就完成呢？

类的构造方法

"""
python类中可以使用: __init__()方法，称之为构造方法
可以实现：
    在创建类对象(构造类)的时候，会自动执行
    在创建类对象(构造类)的时候，将传入的参数自动传递给__init__方法使用
"""
​
"""
类的构造方法
"""
# 使用构造方法对成员变量进行赋值
# 构造方法的名称：__init__
class Student:
    def __init__(self, name, age, tel):  # 使用构造方法无需额外定义变量属性
        self.name = name
        self.age = age
        self.tel = tel
        # 验证构造方法是否会自动运行起来
        print('Student类创建了一个类对象')
stu1 = Student('周杰轮',31,'19266668888')
print(stu1.name)
print(stu1.age)
print(stu1.tel)
​
print('=======================================================')
"""
析构函数
使用__del__ 析构函数，当你使用del关键字删除整个对象时，就会自动调用此方法里的内容
"""
class Student:
    def __init__(self, name, age, tel):  # 使用构造方法无需额外定义变量属性
        self.name = name
        self.age = age
        self.tel = tel
        # 验证构造方法是否会自动运行起来
        print('Student类创建了一个类对象')
    def __del__(self):
        print(f'对象{self.name}同学已经被删除了')
stu1 = Student('周杰轮',31,'19266668888')
del stu1  # 使用del关键字删除此对象

面向对象特性

简述

"""
面向对象编程，是许多编程语言都支持的一种编程思想
简单理解是：基于模板（类）去创建实体（对象）,使用对象完成功能开发。
​
面向对象包含3大特性：
    封装
    继承  
    多态
"""

封装

"""
封装
封装表示的是，将现实世界事物的：
    属性
    行为
封装到类中,描述为：
    成员变量
    成员方法
从而完成程序对现实世界事物中的描述
​
例如大家使用的手机
对用户和开放的属性和行为：
属性：序列号、品牌、型号、长宽高
行为：上网、拍照、通话
​
对用户隐藏的属性和行为
属性：系统具体编码、手机运行电压
行为：内存管理、程序调度
​
既然现实事物有不公开的属性和行为，那么作为现实事物在程序中映射的类，也应该支持
"""
​
"""
私有成员
类中提供了私有成员的形式来支持
    私有成员变量
    私有成员方法
定义方法
    私有成员变量：变量名以__开头(两个下划线)
    私有成员方法：方法名以__开头(两个下划线)
即可完成私有成员的设置
"""
class Phone:
    IMEI = None  # 序列号
    brand = None  # 品牌
​
    __voltage = 0.5  # 手机电压  私有成员变量
​
    def __set_single_core(self):  # 程序调度 私有成员方法
        print('cpu已更改为单核运行')
# 获取的类对象，无法使用私有成员
# phone = Phone()  # 创建对象
# phone.__set_single_core()  # 使用私有方法会报错
# phone.__voltage = 3.3  # 不报错，但是无效
# print(phone.__voltage)
​
​
# 私有成员无法被类对象使用，但是可以被其他的成员使用
    def use_5g(self):
        if self.__voltage >= 1:
            print('5g功能已开启')
        else:
            self.__set_single_core()
            print('电量不足，无法使用5g通话，并已设置为单核运行模式以进行省电')
phone = Phone()
phone.use_5g()
"""
私有成员的意义
仅提供与内部使用，外部类无法进行使用和更改
"""

继承

"""
继承
class 类名(父类名)：
    类内容体
继承分为：单继承和多继承
继承表示：将从父类那里继承（复制）来成员变量和成员方法（不包含私有）
"""
class phone:
    IMEI = None  # 序列号
    brand = 'CQ'  # 品牌
    def use_4g(self):
        print('4g功能')
​
# 基于上面的类创建一个全新的类，且对于已有iphone类进行修改
# class phone2022:
#     IMEI = None  # 序列号
#     brand = None  # 品牌
#     # 添加新的成员变量
#     face_id = True  # 人脸识别
#     def use_4g(self):
#         print('4g功能')
#     # 添加新的成员方法
#     def use_5g(self):
#         print('5g功能')
​
# 继承的方法：单继承
class phone2022(phone):
    # 添加新的成员变量和成员方法
    face_id = True  # 人脸识别
    def use_5g(self):
        print('5g功能')
​
phone = phone2022()
print(phone.brand)
phone.use_4g()
phone.use_5g()
​
# 多继承：可以拥有多个父类
# 创建一个猫的类和狗的类，并且用动物类将他们继承
class cat:
    color = 'white'
    cat_age = '3'
    def cat_shout(self):
        print('mew mew')
​
class dog:
    color = 'brown'
    dog_age = '5'
    def dog_shout(self):
        print('woof woof')
​
# 创建动物类使用多继承将两个类一起继承
class animal(cat, dog):
    pass  # 如果无需添加新的成员变量和成员方法只需要加入pass关键字
animal = animal()
print(animal.color)  # 当类中出现相同成员变量，将会以定义从左到右的位置输出第一个成员变量
print(animal.dog_age)
animal.cat_shout()
animal.dog_shout()
​

继承的复写和使用父类成员

"""
复写
子类继承父类的成员属性和成员方法后，如果对其"不满意"，那么可以进行复写。
即：在子类中重新定义同名的属性或方法即可。
"""
class phone:
    IMEI = None  # 序列号
    brand = 'CQ'  # 品牌
    def use_4g(self):
        print('使用4g网络进行通话')
# 定义子类，复写父类成员
class MyPhone(phone):
    # 对父类的成员变量和成员方法进行重写
    brand = 'CQEdu'
    def use_4g(self):
        print('开启cpu单核模式，确保通话的时候省电')
        # print('使用4g网络进行通话')
        super().use_4g()  # 直接使用父类成员，无需进行重新定义
        print('关闭CPU单核模式，确保性能')
    def find(self):
        print(f'子类的厂商是:{self.brand}')
        print(f'父类的厂商是:{super().brand}')  # 父类的数据还是存在的
phone = MyPhone()
# 父类成员被重写后，即为覆盖原内容
phone.use_4g()
print(phone.brand)
​
"""
调用父类的原内容
方式1：
使用成员变量：父类名.成员变量
使用成员方法：父类名.成员方法(self)
​
方式2：
使用super()调用父类成员
使用成员变量：super().成员变量
使用成员方法：super().成员方法()
"""
phone.find()

多态(有图片示例)->空调要求分布

"""
多态，指的是：多种状态，即完成某个行为时，使用不同的对象会得到不同的状态
    由父类创建无参的成员方法，由很多不同子类继承父类的方法再对于方法进行不同的重写。
"""
class animal:
    def shout(self):
        pass
class dog(animal):
    def shout(self):
        print('汪汪汪')
​
class cat(animal):
    def shout(self):
        print('喵喵喵')
​
def make_noise(animal):
    animal.shout()
​
dog = dog()
cat = cat()
# 根据定义的函数，传入不同的对象，出现不同的结果 -> 多态
make_noise(dog)
make_noise(cat)  # 同样的行为(函数)，传入不同的对象，得到不同的状态
​
​
​
# 多态实例
# 空调
class AC:  #作用: 多用于做顶层设计,便于子类做不同的方法内容（函数内容），也是对子类进行一种约束，要求子类必须复写父类的一些方法
    # 制冷
    def cool(self):
        pass
    # 制热
    def hot(self):
        pass
# 创建厂家类，GREE、Midea
class Midea_AC(AC):
    def cool(self):
        print('美的空调制冷科技')
​
    def hot(self):
        print('美的空调制热方法')
​
class GREE_AC(AC):
    def cool(self):
        print('格力空调制冷科技')
    def hot(self):
        print('格力空调制热方法')
# 对于父类的对象定义一个方法，传入子类对象进行工作，从而获得不同的工作状态
def cool(AC):
    AC.cool()
​
midea_ac = Midea_AC()
gree_ac = GREE_AC()