第八课 类与对象

面向对象是软件工程的常用方法，它利于项目维护、分工协作等等。
面向对象通过类、对象等高级抽象来描述现实中的问题。

Python是面向对象的语言，同样支持类、对象等。

一个简单的类

class people:                   # 定义类
    name = "noah"               # 定义类的属性
    def speak(self):            # 定义类的方法
        return "hello"

x = people()                    # 实例化类
print(x.name)                   # 访问类的属性
print(x.speak())                # 访问类的方法

类的封装性

封装性 即 属性通过方法进行组织封装访问 或 私有属性只能通过方法访问

class people:                               # 定义类
    name = ""                               # 公开属性 名称
    age = 0                                 # 公开属性 年龄
    __weight = 0                            # 私有属性 体重 两个_
    def __init__(self, name, age, weight):  # 构造函数 初始化属性
        self.name = name
        self.age = age
        self.__weight = weight
    def getInfo(self):                      # 获取用户信息
        print("%s：年龄 %d 体重 %d" %(self.name, self.age, self.__weight))

p = people("张三", 8, 25)                    # 实例化类 带初始化参数
print(p.name)                                # 可以获得名称 输出：张三
print(p.age)                                 # 可以获得年龄 输出：8
#print(p.__weight)                           # 报错 不能获得体重
p.getInfo()                                  # 获得用户的信息 输出：张三：年龄 8 体重 25

类的继承性

当某个通用父类不能满足需求，可以通过子类的继承来扩展其功能，从而满足我们的需求而不影响父类的功能和通用性。

# 父类 人类
class people:                                       # 定义类
    name = ""                                       # 公开属性 名称
    age = 0                                         # 公开属性 年龄
    __weight = 0                                    # 私有属性 体重 两个_
    def __init__(self, name, age, weight):          # 构造函数 初始化属性
        self.name = name
        self.age = age
        self.__weight = weight
    def getInfo(self):                              # 获取用户信息
        print("人类信息 %s：年龄 %d 体重 %d" %(self.name, self.age, self.__weight))

# 子类 学生
class student(people):                              # 继承 传入父类的名称
    grade = 0                                       # 增加新属性
    def __init__(self, name, age, weight, grade):
        people.__init__(self, name, age, weight)    # 调用父类的构函
        self.grade = grade
    def playGame(self):                              # 实现子类方法 注：子类不能调用父类的私有属性
        print("学生游戏 %s：年龄 %d 年级 %d" %(self.name, self.age, self.grade))

s = student("张三", 8, 25, 1)                        # 实例化子类
s.playGame()                                         # 调用子类新方法 输出：学生游戏 张三：年龄 8 年级 1
s.getInfo()                                          # 可以调用父类方法 输出：人类信息 张三：年龄 8 体重 25

p = people("李四", 10, 30)                            # 实例化父类 父类不受影响  输出：人类信息 李四：年龄 10 体重 30
p.getInfo()

类的多态性

多态性 即同一方法多种形态。初始化不同的子类，虽调用父类同一个方法，但都以子类的方法为准，实现不同的功能。

# 父类 人类
class people:                                       # 定义类
    name = ""                                       # 公开属性 名称
    age = 0                                         # 公开属性 年龄
    def __init__(self, name, age):                  # 构造函数 初始化属性
        self.name = name
        self.age = age
    def speak(self):                                # 获取用户信息
        print("我是人类 %s：年龄 %d" %(self.name, self.age))

# 子类 老师
class teacher(people):                              # 继承 传入父类的名称
    def __init__(self, name, age):
        people.__init__(self, name, age)            # 调用父类的构函
    def speak(self):                                # 覆写父类方法
        print("我是老师 我讲两句  %s：年龄 %d" %(self.name, self.age))

# 子类 学生
class student(people):                              # 继承 传入父类的名称
    def __init__(self, name, age):
        people.__init__(self, name, age)    # 调用父类的构函
    def speak(self):                                # 覆写父类方法
        print("我是学生 自我介绍 %s：年龄 %d" %(self.name, self.age))


p = people("张三", 8)                                # 实例化父类
p.speak()                                            # 输出：我是人类 张三：年龄 8
t = teacher("李四", 9)                               # 实例化父类
t.speak()                                           # 输出：我是老师 我讲两句  李四：年龄 9
s = student("王二", 10)                              # 实例化父类
s.speak()                                           # 输出：我是学生 自我介绍 王二：年龄 10