面向对象编程：上
初识面向对象
函数式编程对比面向对象
函数编程两个特点
- 减少代码的重用性
- 增强代码的可读性
面向对象编程
- 是一类相似功能的函数几个，是你代码更清晰化，更合理化
class Human: # 第一部分：静态属性 属性 静态变量 静态字段 mind = '人类' dic = {} l1 = [] # 第二部分：方法 函数 动态属性 def index(self): print('被杀就会死')
class 是关键字与def用法相同，定义一个类。
Human是此类的类名，类名使用驼峰(CamelCase)命名风格，首字母大写，私有类可用一个下划线开头
类的结构从大方向来说就分为两部分
- 静态变量
- 动态方法
从类自身角度研究类
类名操作静态属性
- 查看类中所有的内容：类名.__dict__
class Human: mind = '人类' dic = {} l1 = [] def index(self): print("人被杀就会死") print(Human.__dict__) print(Human.__dict_['mind']) Human.__dict__['mind'] = '憨批' # 报错 print(Human.__dict__) # 这种方式只能查询，不能增删改 # 第一种方式只会查询全部内容(一般不单独属性查询)
- 点操作
# 通过点，可以增删改查类中的单个属性 class Human: mind = '人类' dic = {} l1 = [] def index(self): print("人被杀就会死") print(Human.mind) # 查 Human.mind = '憨批' # 改 print(Human.mind) del Human.mind # 删 Human.fick = '脑瘫' # 增
类名操作动态方法
除了两个特殊方法：静态方法，类方法。一般不会通过类名操作一个类中的方法
class Human: mind = '人类' dic = {} l1 = [] def index(self): print("人被杀就会死") def home(self): print("人被杀不会死") Human.index(123) Human.home(123) # 下面可以用，但是一般不用 Human.__dict__['index'](123)
从对象角度研究类
什么是对象
-
对象就是类的实例化，类名加上()，这就是一个实例化过程，这个就会实例化一个对象
class Human: mind = '人类' def __init__(self): dic = {} l1 = [] def index(self): print("人被杀就会死") def home(self): print("人被杀不会死") obj = Human() # 只要实例化对象，他会自动执行__init__方法 print(obj) # <__main__.Human object at 0x00000191508AA828> # 并且obj的地址和self的地址相同
一个实例化对象发生了三件事
在内存中创建了一个对象空间
制动执行类中的__init__方法，并将对象空间(内存地址)传给了__init__方法的第一个位置参数self
在__init__方法中通过self给对象空间添加属性
class Human: def __init__(self, name, sex, age, hobby): # self 和 obj 指向的是同一个内存地址 # 下面就是通过self给这个对象空间封装四个属性 self.name = name self.sex = sex self.age = age self.hobby = hobby obj = Human('那月', '女', 17, 'cat')
对象操作对象空间属性
- 对象查看对象中所有属性。对象.__dict__
class Human: def __init__(self, name, sex, age, hobby): self.name = name self.sex = sex self.age = age self.hobby = hobby obj = Human('那月', '女', 17, 'cat') print(obj.__dict__) # {'name': '那月', 'sex': '女', 'age': 17, 'hobby': 'cat'}
- 对象查看对象中的单个属性，点操作
class Human: def __init__(self, name, sex, age, hobby): self.name = name self.sex = sex self.age = age self.hobby = hobby obj = Human('那月', '女', 17, 'cat') obj.work = "yuan交" # 增加 del obj.sex # 删除 obj.age = 16 # 改 print(obj.name) # 查
- 对象查看类中的属性
class Human: mind = "活的人" language = 'Chinese' def __init__(self, name, sex, age, hobby): self.name = name self.sex = sex self.age = age self.hobby = hobby obj = Human('那月', '女', 17, 'cat') print(obj.mind) print(obj.language) obj.a = '???' print(obj.a)
- 对象操作类中的方法
class Human: mind = "活的人" language = 'Chinese' def __init__(self, name, sex, age, hobby): self.name = name self.sex = sex self.age = age self.hobby = hobby def work(self): print("人被杀就会死") def home(self): print("人被杀不会死") obj = Human('那月', '女', 17, 'cat') obj.work() obj.home()
类中的方法一般都是通过对象执行的（出去类方法，静态方法外），并且对象执行这些方法都会自动将对象空间传给方法中的第一个参数self
self是什么？
self其实就是类中方法（函数）的第一个位置参数，只不过解释器会自动将调用这个函数的对象传给self。所以咱们把类中的方法的第一个参数约定俗成设置成self, 代表这个就是对象
self 就是调用者本身
类空间以及类之间的关系
对象属性的添加
对象的属性不仅可以在__init__里面添加，还可以在类的其他方法或者类的外面添加
class A: def __init__(self, name): self.name = name def func(self, sex): self.sex = sex # 类外面可以 obj = A('nayue') obj.age = 17 print(obj.__dict__) # {"name": "那月", "age": 17} # 类内部也可以 obj.func('女')
静态属性的添加
类的属性不仅可以在类内部添加，还可以在类的外部添加。
class A: def __init__(self, name): self.name = name def func(self): A.age = 17 # 类的外部可以添加 A.hobby = 'eat' # 类的内部也可以添加 A.func(123) # 必须传个参数
对象如何找到类的属性
对象查找属性的顺序：对象空间 --> 类空间 --> 父类空间
类名查找属性的顺序：本类空间 --> 父类空间
顺序单向不可逆，类名不能找到对象的属性
类与类之间的关系
类与类存在以下关系
- 依赖关系
- 关联关系
- 组合关系
- 聚合关系
- 实现关系
- 继承关系
依赖关系
# 依赖关系：将一个类的对象或者类名传到另一个类的方法使用 class Dog: def __init__(self, name): self.name = name def eat(self, obj1): print(f"狗子{self.name}准备吃饭了") obj1.play_food() # 调用方法 class Human: def play_food(self): print("投食+1") dog = Dog("帅总") human = Human() dog.eat(human) # 传入对象/类名
关联，聚合，组合关系
这三个在代码上写法是相同的，但是含义不一样
关联关系：两种事务必须是相互关联的，但是在某些特殊情况下可以是可更改和可更换的
聚合关系：属于关联关系中的一种特列，侧重点是a和b聚合成c，各自有各自的生命周期(a挂了，b还是好的)
组合关系：属于关联关系中的一种特列，写法上差不多，组合关系比聚合还要紧密(a挂了，b跟着也挂了)
关联关系
class Kitten: def __init__(self, name, Pets=None): self.name = name self.Pets = Pets def cat_nast(self): if self.Pets: print(f"{self.name}养了一只{self.Pets}") else: print(f"{self.name}家里没有宠物") class Master_Pets: def __init__(self, Pets): self.Pets = Pets cat = Kitten('那月') cat.cat_nast() # 此时没有养猫 # 养了一只猫 cat.Pets = "猫咪" cat.cat_nast() # 优子家里一直有养猫 yat = Master_Pets('狗子') yat = Kitten("优子", yat) yat.cat_nast() # 优子把狗子扔了 yat.Pets = None yat.cat_nast()
此时两个类之间就是关联关系. 两个类的对象紧密练习着. 其中⼀个没有了. 另⼀个就孤单的不得了. 关联关系, 其实就是 我需要你. 你也属于我. 这就是关联关系. 像这样的关系有很多很多.
# 老师属于学校，必须有学校才可以工作 class School: def __init__(self,name,address): self.name = name self.address = address class Teacher: def __init__(self,name,school): self.name = name self.school = school s1 = School('北京校区','美丽的沙河') s2 = School('上海校区','上海迪士尼旁边') s3 = School('深圳校区','南山区') t1 = Teacher('武大',s1) t2 = Teacher('海峰',s2) t3 = Teacher('日天',s3) print(t1.school.name) print(t2.school.name) print(t3.school.name)
组合关系：将一个类的对象封装到另一个类的对象属性中，就叫组合
class Gamerole: def __init__(self, name, ad, hp): self.name = name self.ad = ad self.hp = hp def attack(self, p1): p1.hp -= self.ad print('%s攻击%s,%s掉了%s血,还剩%s血' % (self.name, p1.name, p1.name, self.ad, p1.hp)) def equip_weapon(self, wea): self.wea = wea # 组合：给一个对象封装一个属性改属性是另一个类的对象 class Weapon: def __init__(self, name, ad): self.name = name self.ad = ad def weapon_attack(self, p1, p2): p2.hp = p2.hp - self.ad - p1.ad print('%s 利用 %s 攻击了%s,%s还剩%s血' % (p1.name, self.name, p2.name, p2.name, p2.hp)) # 实例化三个人物对象： barry = Gamerole('那月', 10, 200) panky = Gamerole('优子', 20, 50) pillow = Weapon('奶子', 2) # 给人物装备武器对象。 barry.equip_weapon(pillow) # 开始攻击 barry.wea.weapon_attack(barry, panky)
浙公网安备 33010602011771号