面向对象介绍
面向对象编程: 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()方法时，会根据门的状态和模式来执行相应的操作，最终完成洗衣任务。
步骤
- 定义
WashMachine类，初始化时传入品牌和容量两个参数，并设置默认值。 - 定义打开/关闭洗衣机门的方法，通过修改
is_closed属性来实现。 - 定义设置洗衣模式的方法，通过修改
__mode属性来实现。 - 定义设置马达转速的私有方法，通过修改
motor_speed属性来实现。 - 定义开始洗衣服的方法，根据门的状态和模式来执行相应的操作，最终完成洗衣任务。
- 实例化
WashMachine类，传入品牌和容量两个参数，得到一个洗衣机对象。 - 调用打开/关闭洗衣机门的方法，模拟打开/关闭洗衣机门的操作。
- 调用设置洗衣模式的方法，传入一个参数，设置洗衣模式。
- 调用开始洗衣服的方法，根据门的状态和模式来执行相应的操作，最终完成洗衣任务。
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)
