Python 类和对象

一、类和成员

类由两部分组成：

类的属性，称为成员变量

类的行为，称为成员方法

注：函数在类外，方法在类内部。

"""
演示类和成员
"""

# 类和成员方法的定义语法
# class 类名称：
#     成员变量
# 
#     def 成员方法(self,参数列表):
#         成员方法体
# 
# 对象 = 类名称

---

二、构造方法

构造方法的名称是：_ _ init_ _ ，注意init前后的2个下划线符号

构造方法的作用：

1.构建类的对象的时候会自动运行

2.构建类对象的传参会传递给构造方法，借此特性可以给成员变量赋值

注意：1.构造方法不要忘记self关键字

           2.在方法内使用成员变量时需要使用self

"""
演示构造方法
"""

# __init__()方法，是构造方法

class Student:

    def __init__(self,name,age,tel):
        self.name = name
        self.age = age
        self.tel = tel
    
stu = Student("周杰论",17,18899996666)
print(stu.name)
print(stu.age)
print(stu.tel)

---

三、魔术方法

_ _init_ _ ：构造方法，用于创建对象的时候设置初始化行为

_ _str_ _：用于实现类对象转字符串的行为

_ _lt_ _：用于2个类对象进行小于或大于比较

_ _le_ _：用于2个类对象进行小于等于或大于等于比较

_ _eq_ _ ：用于2个类对象进行相等比较

"""
演示Python内置的魔术方法
"""

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

    # __str__魔术方法
    def __str__(self):
        return f"Student类对象，name:{self.name},age:{self.age}"
    # __lt__魔术方法
    def __lt__(self,other):
        return self.age < other.age
    # __le__魔术方法
    def __le__(self, other):
        return self.age <= other.age
    #__eq__魔术方法
    def __eq__(self,other):
        return self.age == other.age

# 演示__str__魔术方法
stu = Student("周杰论",13)
print(stu)
print(str(stu))
# 演示__lt__魔术方法
stu1 = Student("林靖杰",18)
print(stu < stu1) #输出True
# 演示__le__魔术方法
print(stu <= stu1)
# 演示__eq__魔术方法
print(stu == stu1)

---

四、私有成员

私有成员：

类中提供了私有成员的形式，私有成员变量和私有成员方法。

定义方式：

1.私有成员变量：变量名以_ _开头（2个下划线）

2.私有成员方法：方法名以_ _开头（2个下划线）

私有成员的访问限制：

1.类对象无法访问私有成员

2.类中的其他成员可以访问私有成员

"""
演示私有成员变量和私有成员方法
"""

# 定义一个手机类
class Phone:
    # 定义一个私有成员变量
    __is_5g_enable = True
    # 定义一个私有成员方法
    def __check_5g(self):
        if self.__is_5g_enable:
            print("5g开启")
        else:
            print("5g关闭，使用4g网络")

    # 定义公开成员方法
    def call_by_5g(self):
        self.__check_5g()
        print("正在通话中")
# 创建对象
phone = Phone()
# 调用公开成员方法
phone.call_by_5g()

---

五、继承

继承就是一个类，继承另外一个类的成员变量和成员方法

# 语法：
# class 类(父类1,父类2,...):
#     类内容体

多继承中，如果父类由同名方法或属性，先继承的优先级高于后继承

pass关键字的作用是无内容时，写一个过渡

"""
演示面向对象：继承的基础语法
"""

# 演示单继承
# 创建父类
class Phone:
    name = "小米"
    price = 1999

    def call_by_4G(self):
        print("4g通话")

# 创建子类
class new_Phone(Phone):
    name = "大米"
    ID = "000001"

    def call_by_5G(self):
        print("5G通话")

# 创建子类对象
phone1 = new_Phone()


# 调用子类的方法和属性
phone1.call_by_5G()
print(phone1.ID)

# 调用父类的方法和属性
phone1.call_by_4G()
print(phone1.name)
print(phone1.price)

# 演示多继承

class Animal:
    name = "小白"
    def say(self):
        print("汪汪汪")
class new_Animal:
    name = "大白"
    def say(self):
        print("喵喵喵")
class new_new_Animal(Animal,new_Animal):
    pass

animal = new_new_Animal()
print(animal.name)
animal.say()

---

六、复写

复写父类成员和语法

复写表示：对父类的成员属性或成员方法进行重新定义

复写的语法：在子类中重新实现同名成员方法或成员属性即可

在子类中，如何调用父类成员？

# 调用父类成员
# 方式1
# 调用父类成员
# 使用成员变量：父类名.成员变量
# 使用成员方法：父类名.成员方法(self)
# 
# 方式2
# 使用super()调用父类成员
# 使用成员变量：super().成员变量
# 使用成员方法：super().成员方法

# 编写父类
class Student:
    hobby = "Java"

    def print_socre(self):
        print("Java考了100分")

# 编写子类
class Good_Student(Student):
    hobby = "Python"

    def print_socre(self):
        print("Python考了100分")

# 创建子类对象
stu = Good_Student()
# 打印子类属性和调用子类方法
print(stu.hobby)
stu.print_socre()

---

七、类型注解

1.变量的类型注解

作用：做代码提示

类型注解支持：1.变量的类型注解

                          2.函数（方法）的形参和返回值的类型注解

变量的类型注解语法：1.变量：类型

                                    2.在注释中，#type:类型

注意：类型注解只是提示性的，因此类型注解错误不会导致代码错误

2.函数和方法类型注解

在何处可以添加注解：1.形参的类型注解

                                    2.返回值的类型注解

函数（方法）的类型注解：def 函数方法名（形参：类型，......，形参：类型） -> 返回值类型：

                                                     pass

3.Union联合类型注解

使用方式：导包：from typing import typing

                  使用：Union[类型，......，类型]

---

八、多态

多态：是同一个行为 使不同的对象有不同的状态

抽象类：是指包含抽象方法的类。而抽象方法是指没有具体实现的方法。

抽象类的作用：多用于做顶层设计（设计标准），以便子类做具体实现。

"""
演示多态
"""

# 演示抽象类
class AC:
    def eat_breakfast(self):
        pass
    def eat_lunch(self):
        pass
    def eat_dinner(self):
        pass

#
class Tom_AC:
    def eat_breakfast(self):
        print("Tom吃了五个大肉包子")
    def eat_lunch(self):
        print("Tom光速炫完了八碗饭")
    def eat_dinner(self):
        print("Tom晚上吃了好多个老八秘制小汉堡")

class Jack_AC:
    def eat_breakfast(self):
        print("Jack早上喝了小鸟伏特加")
    def eat_lunch(self):
        print("Jack吃了一碗面")
    def eat_dinner(self):
        print("Jack去肯德基享受了疯狂星期四")

def eat_AC(ac:AC):
    ac.eat_dinner()

tom = Tom_AC()
jack = Jack_AC()
eat_AC(tom)
eat_AC(jack)