rt_01_类与对象.py
面向对象编程思想的基本单位：类与对象 类：具有相同特征和行为的一类事物的统称，理解成一张图纸，一个抽象的事物 对象：是根据类创建出来的具体存在的事物 结论：先有类，后有对象，对象是根据类创建出来的
需求：
洗衣机类：Washer
属性：宽度、高度、颜色、品牌
行为：wash，dry_water
# self关键字在定义类中的函数时，self会自动添加，在调用函数时self是不需要传参的
# self表示的就是当前根据类创建出的对象，就是其本身
# 新式类的定义
class Washer(object):
def wash(self):
"""洗衣服"""
print("washer-->",self)
print("洗衣机洗衣服。。。")
def dry_water(self):
"""洗衣机脱水"""
print("dry_water-->",self)
print("洗衣机脱水。。。")
if __name__ == '__main__':
# 根据类创建对象
haier = Washer()
# 输出当前对象在内存中的地址
print(haier)
haier.wash()
haier.dry_water()
# 再创建一台
# 可以根据类创建出多个不同的对象
xiaotianer = Washer()
print(xiaotianer)
xiaotianer.wash()
xiaotianer.dry_water()输出：
rt_02_student类的设计.py
需求：
设计一个student类
属性：name，age，classes，address
方法：study，play_game
# 给对象添加属性的方式有两种：
# 1.在类的外部添加
# 2.在类的内部添加
class Student(object):
def study(self):
#print("好好学习，天天向上！")
print(f"{self.name}在{self.classes}班级好好学习，天天向上!")
def play_game(self):
print(f"{self.name}热爱生命，热爱游戏！")
if __name__ == '__main__':
xiaoming = Student()
# 在类的外部添加属性
xiaoming.name = "小明"
xiaoming.age = 18
xiaoming.classes = "Python"
print(xiaoming)
xiaoming.study()
xiaoming.play_game()
# 在类的外部给对象添加属性，属性仅仅属于当前对象
# 如果创建新的对象，也需要重新添加（不灵活，不推荐使用）
xiaoqiang = Student()
xiaoqiang.name = "小强"
xiaoqiang.age = 19
xiaoqiang.classes = "Java"
print(xiaoqiang)
xiaoqiang.study()
xiaoqiang.play_game()
输出：
rt_03_在类的内部添加属性.py
# 在类的内部添加属性
# 需要借助（重写）魔法函数init（构造方法）
class Student(object):
def __init__(self,name1,age1,classes1):
"""魔法函数init，每个类默认都是存在的
1、运行机制:创建对象时执行此方法
2、作用：一般用来做一些初始化操作（属性初始化）
"""
# 属性初始化时不能写成固定的值
# self.name = "如花"
# self.age =18
# self.classer = "Python"
#print("这是魔法函数init。。。")
self.name = name1
self.age = age1
self.classes = classes1
def study(self):
# print("好好学习，天天向上！")
print(f"{self.name}在{self.classes}班级好好学习，天天向上!")
def play_game(self):
print(f"{self.name}热爱生命，热爱游戏！")
if __name__ == '__main__':
ruhua = Student("如花",18,"Python")
ruhua.study()
ruhua.play_game()
输出：
rt_04_雇员类的设计.py
需求： 雇员类：Employee 属性：name,age,department,salary 行为：work
# 雇员类：Employee
# 属性：name,age,department,salary
# 行为：work
class Employee(object):
def __init__(self,name,age,department,salary):
self.name = name
self.age = age
self.department = department
self.salary = salary
def work(self):
print(f"{self.name}正在工作，是{self.department}部门的，工作很努力！")
def get_info(self):
print(f"name:{self.name},age:{self.age},department:{self.department},salary:{self.salary}")
# 重写魔法函数str，注意：有返回值，返回值字符串（是对当前对象的描述）
def __str__(self):
return f"name:{self.name},age:{self.age},department:{self.department},salary:{self.salary}"
# 魔法函数del，当对象被销毁时调用此方法，可以根据他的执行时机来做相应的业务处理
def __del__(self):
print("del被调用，当前对象被销毁")
if __name__ == '__main__':
# ruhua = Employee("如花",19,"财务",10000)
# ruhua.work()
xiaoli = Employee("小李",23,"开发部",15000)
# 如果没有重写魔法函数str，输出对象时
#
print(xiaoli)
# xiaoli.work()
# xiaoli.get_info()
laoli = Employee("老李", 38, "开发部", 38000)
print(laoli)
# laoli.work()
# laoli.get_info()
print("---end---")输出：
rt_05_封装.py
面向对象三大特征：
封装：就是把属性和方法封装到类中的过程
特点：属性私有化，方法公有化
# 面向对象三大特征：
# 封装：就是把属性和方法封装到类中的过程
# 特点：属性私有化，方法公有化
# 继承：
# 多态：
class Student(object):
def __init__(self,name,age,address):
# self.name = name
# self.age = age
# self.address = address
self.__name = name
self.__age = age
self.__address = address
def get_info(self):
# print(f"name:{self.name}，age:{self.age}，addres:{self.address}")
print(f"name:{self.__name}，age:{self.__age}，addres:{self.__address}")
# get，获取私有属性的值
def get_age(self):
return self.__age
# set，给私有属性重新赋值
def set_age(self,age1):
if age1 < 15 and age1 > 0:
self.__age = age1
else:
print("您输入的年龄有误！")
if __name__ == '__main__':
ruhua = Student("如花",18,"山东泰安")
# 属性私有化，私有化后的属性只能在类的内部访问，不能被类访问
# 私有化属性：在属性的前面添加双下划线
# print(ruhua.age)
print(ruhua.get_age())
# ruhua.age = -18
# 就想在类的外部访问私有属性的值，可以在类的内部添加公共方法来访问私有属性的值
ruhua.get_info()输出：
rt_06_继承.py
继承：指的是类与类之间存在的关系 一个类如果继承了另一个类，就拥有了这个类的所有资源，私有除外 Python中的继承主要有以下三种类型： 1.单继承 2.多继承 3.多层继承
# A类：父类型
# B类：子类型
# B类继承A类
class A(object):
def __init__(self):
self.num = 100000
self.__money = 5000
def test1(self):
print("这是A类中的test。。。")
class B(A):
pass
if __name__ == '__main__':
a = A()
print(a.num)
a.test1()
b = B()
print(b.num)
b.test1()输出：
rt_07_单继承.py
单继承：一个子类只能继承一个父类
父类：Master（师傅类）
子类：Prentice（徒弟类）
class Master(object):
def __init__(self):
self.kongfu = "【古法煎饼果子配方】"
def make_cake(self):
print(f"运用{self.kongfu}制作煎饼果子！")
class Prentice(Master):
pass
if __name__ == '__main__':
ruhua = Prentice()
print(ruhua.kongfu)
ruhua.make_cake()
输出：
rt_08_多继承.py
# 多继承：一个子类可以继承多个父类
class Master(object):
def __init__(self):
self.kongfu = "【古法煎饼果子配方】"
def make_cake(self):
print(f"运用{self.kongfu}制作煎饼果子！")
# 父类型：School（煎饼果子培训学校）
class School(object):
def __init__(self):
self.kongfu = "【瑞通各种各样煎饼果子配方】"
def make_cake(self):
print(f"运用{self.kongfu}制作煎饼果子！")
class Prentice(School,Master):
# 当继承父类的方法不能满足子类需要时，子类可以重写父类的同名方法
def make_cake(self):
# 重写父类的同名方法后还想保留父类的代码，可以使用super来调用
super(Prentice, self).make_cake()
print("运用独创的煎饼果子配方制作煎饼果子")
pass
if __name__ == '__main__':
ruhua = Prentice()
print(ruhua.kongfu)
ruhua.make_cake()
# 当子类继承多个父类时，子类调用父类的同名属性和方法是怎样调用的？调用顺序？
# 借助魔法属性mro，查看当前子类的继承顺序
print(Prentice.__mro__)输出：
rt_09_多态.py
多态：指的是一种事物的多种形态
注意：多态只存在继承体系中
需求：
警察携带警犬抓罪犯
父类：Dog（警犬类）
子类：DrugDog（缉拿毒贩的警犬）
子类：ArmyDog（追击敌人的警犬）警员类：Police
class Dog(object):
def work(self):
print("指哪打哪。。。")
class DrugDog(Dog):
def work(self):
"""重写父类的方法"""
print("协助警员缉拿毒贩。。。")
class ArmyDog(Dog):
def work(self):
print("协助警员追击敌人。。。")
class Police(object):
# def work_with_drug_dog(self,drug_dog):
# drug_dog.work()
#
# def work_with_army_dog(self,army_dog):
# army_dog.work()
# 需要定义一个公共方法，不管来了多少种类型的警犬都可以接收
def work_with_dog(self,dog):#dog:指的是警犬类的父类型
# 真正在调用时可以传入不同的子类
dog.work()
if __name__ == '__main__':
lijingguan = Police()
drug_dog = DrugDog()
#lijingguan.work_with_drug_dog(drug_dog)
lijingguan.work_with_dog(drug_dog)
army_dog=ArmyDog()
#lijingguan.work_with_army_dog(army_dog)
lijingguan.work_with_dog(army_dog)
输出：
1130
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
