Python语言第六章之面向对象

面向对象介绍

• 面向对象编程: Object Oriented Programming 简写 OOP

• 在面向对象的世界里：万事万物皆对象

• 面向对象简单来说, 就是将操作看成一个整体, 对面向过程进行封装

  对象是通过类实例化而来

• 面向过程

  • 买菜、洗菜、切菜、做菜，按步骤完成这个过程

• 面向对象

  • 弄了一个自动炒菜机对象，把买菜、洗菜、切菜、做菜封装在机器里

  • 面向对象对面向过程做了进一步的封装

• 类和对象是面向对象非常重要的概念

  • 类是描述了一种类型(相当于图纸)

  • 对象是这个类型的具体实现(相当于图纸具体实现)

类和对象

class 类名:
    pass

创建对象

对象名 = 类名

代码演示

# 定义类
class Person:
    pass

# 创建对象
p = Person()

类的组成

类可以描述世间万物，类都需要有类名，也应该具备一些属性和行为

• 类的关键字：class
• 类的名称：类名
• 类的属性：一组数据
• 类的方法：允许进行操作的方法(行为)

类的组成为成员方法和成员属性

成员属性__init__

成员属性的定义需要在初始化方法__init__方法下定义

def __init__(self):
    self.属性 = 属性值
初始化,添加属性
self.属性变量名 = 内容

class Person:
    def __init__(self, name, age):
        # 成员属性
        self.name = name
        self.age = age
        
# 创建对象
p = Person('张三', 30)
# 访问成员属性
print(p.name)
print(p.age)

在创建对象时，属性值可以由外部传进来，也可以在初始化方法里设置为任意值

成员属性__str__

方便打印对象属性, 一般情况下, 返回是字符串, 否则直接通过__init__返回的是地址

class Person():
    def __init__(self, username, user_age):
        self.name = username
        self.age = user_age
        # 设置默认参数
        self.issingle = False
        print("自动调用了")

    # __str__打印一些对象的属性信息,进行返回,否则打印p的时,是地址
    def __str__(self):
        return f"{self.name}在吃饭,{self.issingle}"

    def eat(self):
        self.issingle = True
        print(f"{self.name}在吃饭,{self.issingle}")

    def run(self):
        print(f"{self.age}运动")

    def exe(self):
        # 在函数内部调用了方法
        self.eat()


# 只会在实例化的时候自动执行
# p = Person()
# p1 = Person()
# 而后调用方法时就不再执行了
# p.eat()

p = Person("mike", 29)
print(p)
p.eat()

成员方法def 函数名(self)

成员方法的定义格式为 def 函数名(self)

class Person:
    
    # 定义成员方法 say_hello
    def say_hello(self):
        print('hello')
        
	# 定义成员方法run
    def run(self):
        print('跑')

# 创建对象
p = Person()
# 调用成员方法
p.say_hello()

总结

# 形式 class + 名称 (大驼峰命名)
class Person():
    def eat(self):
        print(f"{self.name}在吃饭")

    def run(self):
        print("在运动")


# # p就是People类的实例化对象
p = Person()
# # 通过对象调用方法
# p.eat()
# p.run()
#
# p2 = Person()
# p2.eat()
# p2.run()

"""
对象.属性 可以添加属性
调用之前, 必须添加了name属性, 所以放在这个属性使用之前
"""
p.name = "zs"
# print(p.name)
p.eat()


# def stu():
#     print("哈哈哈")
#
#
# p.stu = stu
# p.stu()

self参数使用

self: 谁调用方法, self就是谁 比如p = Person() 中, self 就指向 p

只要使用self.属性或者self.方法, 都是类内部使用的

通过实例化对象的 对象.属性或者对象.方法 这个都是在类内部使用的

class Person():
    def eat(self):
        print("在吃饭")

    def run(self):
        print("在运动")

    def exe(self):
        # 在函数内部调用了方法
        self.eat()


# self指向p
p = Person()
p.eat()
# exe方法在类内部调用了eat方法
p.exe()

​
class Person():
    def eat(self):
        print("在吃饭")

    def run(self):
        print("在运动")

    def exe(self):
        # 在函数内部调用了方法
        self.eat()


# self指向p
p = Person()
p.eat()
# exe方法在类内部调用了eat方法
p.exe()


​

访问权限

访问权限分为公共和私有,私有属性在类外面不能访问

"""
实例属性:
姓名 name
年龄 __age
实例方法:
__init__()添加实例属性
__secret()打印年龄
pub()公共方法
"""

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

    def eat(self):
        print(f"{self.name}在吃饭,今年{self.__age}岁")

    # 私有方法
    def __secret(self):
        print("这是一个秘密")

    def pub(self):
        self.__secret()


p = Person("zs", 18)
print(p.name)
p.eat()
# 私有属性 在类外部不能访问
# p.__secret()
# 只能在非私有方法中使用
p.pub()

面向对象三大特性

封装: 隐藏内部实现细节, 只保留功能接口

继承: 类与类之间的关系(父与子), 主要用来复用, 父中的子都可以用

多态: 一类事物有多种形态(一个类中有多个类)

封装

定义一个洗衣机类，其中包含了打开/关闭洗衣机门、设置洗衣模式、设置马达转速、开始洗衣服等方法。

在初始化时，需要传入品牌brand和容量capacity两个参数。洗衣机门的状态is_closed、洗衣模式__mode和马达转速motor_speed都有默认值。

调用wash()方法时，会根据门的状态和模式来执行相应的操作，最终完成洗衣任务。

步骤

1. 定义WashMachine类，初始化时传入品牌和容量两个参数，并设置默认值。
2. 定义打开/关闭洗衣机门的方法，通过修改is_closed属性来实现。
3. 定义设置洗衣模式的方法，通过修改__mode属性来实现。
4. 定义设置马达转速的私有方法，通过修改motor_speed属性来实现。
5. 定义开始洗衣服的方法，根据门的状态和模式来执行相应的操作，最终完成洗衣任务。
6. 实例化WashMachine类，传入品牌和容量两个参数，得到一个洗衣机对象。
7. 调用打开/关闭洗衣机门的方法，模拟打开/关闭洗衣机门的操作。
8. 调用设置洗衣模式的方法，传入一个参数，设置洗衣模式。
9. 调用开始洗衣服的方法，根据门的状态和模式来执行相应的操作，最终完成洗衣任务。

class WashMachine:
    def __init__(self, brand, capacity):
        """
        初始化
        :param brand: 品牌
        :param capacity: 容器
        """
        self.brand = brand
        self.capacity = capacity
        self.__is__closed = True  # 门是否打开
        self.__mode = 0  # 洗衣模式
        self.__motor_speed = 0  # 马达转速

    # 关闭洗衣机门
    def close_door(self):
        self.__is__closed = False

    # 打开洗衣机门
    def open_door(self):
        self.__is__closed = True

    # 设置洗衣模式
    def set_mode(self, mode):
        self.__mode = mode

    # 设置马达转速(私有)
    def __set__motor_speed(self, speed):
        self.__motor_speed = speed

    # 洗衣服
    def wash(self):
        # 根据门的状态和模式进行相应的洗衣服
        if self.__is__closed:
            print("门未关闭!")
            return
        elif self.__mode == 0:
            print("洗衣模式未设定")
            return
            # 判断洗衣模式
        if self.__mode == 1:
            # 设置转速
            self.__set__motor_speed(1000)
            print(f"开始洗衣服, 转速{self.__motor_speed}")
        elif self.__mode == 2:
            self.__set__motor_speed(2000)
            print(f"开始洗衣服,狂暴模式, 转速{self.__motor_speed}")
        print("洗衣完成!")


wc = WashMachine("海尔", "30L")
# 开门
wc.close_door()
# 设置模式
wc.set_mode(1)
# 洗衣服
wc.wash()

继承

Student 继承父类 Person 的方法和属性

继承指的是一个对象直接使用另一个对象的属性或方法

继承的格式：
class 子类名(父类名):

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

    def say_hello(self):
        print(f"{self.name} say hello, 今年 {self.age}岁")


# 继承Person,子类继承父类,拥有父类方法和属性
class Student(Person):
    pass


stu = Student("zs", 18)
stu.say_hello()

重写super()

Student类继承了Person父类的方法和属性, 并且重写了父类中的init方法, 使用super()调用符类(超类)的初始化方法

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

    def say_hello(self):
        print(f"{self.name} say hello, 今年 {self.age}岁")


# 继承Person,子类继承父类,拥有父类方法和属性
class Student(Person):
    # 重写父类的init方法
    def __init__(self, age, name, sex):
        super().__init__(name, age)
        self.sex = sex

    def stu_all(self):
        print(f"{self.name} say hello,性别{self.sex}, 今年 {self.age}岁")


stu = Student("zs", 18, "男")
stu.say_hello()
stu.stu_all()

多态

对于父类Human来说, 被多个子类继承

class Human():
    def eat(self):
        print("吃饭!")


class ZhHuman(Human):
    def eat(self):
        print("zh 吃饭!")


class UsHuman(Human):
    def eat(self):
        print("us 吃饭!")


class AfHuman(Human):
    def eat(self):
        print("af 吃饭!")


def do_something(st):
    st.eat()


zh = ZhHuman()
us = UsHuman()
af = AfHuman()
do_something(zh)
do_something(us)
do_something(af)