博客围绕面向对象编程展开，介绍了封装，即将属性和方法封装到类中，还给出相关练习题目；阐述了继承，可实现代码重用，子类能继承父类属性和方法，有传递性，还提及多继承；最后讲解了多态，即同一事物的多种形态，可在不考虑对象类型时调用方法。
一、 封装：
- 面向对象第一步 ： 将属性和方法封装到一个抽象的类中
- 外界使用类创建对象，然后让对象调用方法
- 对象方法的细节都封装在类的内部
练习：
题目要求一：
1.小明体重75.0公斤
2.小明每次跑步会减肥0.5公斤
3.小明每次吃东西会增重1攻击
题目要求二：
1.小明和小美都爱跑步
2.小美体重45.0公斤
3.小明体重75.0公斤
4.每次跑步会减肥0.5公斤
5.每次吃东西会增重1攻击
class Person():
def __init__(self,name,weight):
self.name = name
self.weight = weight
def __str__(self):
return '我的名字叫%s 体重是%.2f' %(self.name,self.weight)
def run(self):
print('%s爱跑步' %self.name)
self.weight -= 0.5
def eat(self):
print('%s吃东西' %self.name)
self.weight += 1
xiaoming = Person('小明',76.0)
print(xiaoming)
xiaoming.run()
print(xiaoming)
xiaoming.eat()
print(xiaoming)
结果：
我的名字叫小明 体重是76.00
小明爱跑步
我的名字叫小明 体重是75.50
小明吃东西
我的名字叫小明 体重是76.50
- 题目二：
题目要求：
1.房子有户型，总面积和家具名称列表
新房子没有任何的家具
2.家具有名字和占地面积，其中
床：占4平米
衣柜：占2平面
餐桌：占1.5平米
3.将以上三件家具添加到房子中
4.打印房子时，要求输出:户型，总面积，剩余面积，家具名称列表
##定义家具类:房子类要使用家具，则被使用的类应先开发
class HouseItem():
def __init__(self,name,area):
self.name = name
self.area = area
def __str__(self):
return '[%s]占地 %.2f' %(self.name,self.area)
#1.创建家具
# bed = HouseItem('bed',4)
# print(bed)
# table = HouseItem('table',2)
# print(table)
##定义房子类
class House():
def __init__(self,house_type,area):
self.house_type = house_type
self.area = area
#剩余面积
self.free_area = area ##剩余面积的初始值为总面积
self.item_list = []
def __str__(self):
return ('户型:%s\n总面积:%.2f[剩余:%.2f]\n家具:%s'
%(self.house_type,self.area,self.free_area,self.item_list))
def add_item(self,item):
#1.判断家具的面积
if item.area > self.free_area:
print('%s的面积太大，无法添加' %item.name)
#2.将家具的名称添加到列表中
self.item_list.append(item.name)
#3.计算剩余面积
self.free_area -= item.area
#1.创建家具对象
bed = HouseItem('bed',4)
# print(bed)
chest = HouseItem('chest',2)
# print(yg)
table = HouseItem('table',1.5)
# print(table)
#2.创建房子对象
my_house = House('两室一厅',100)
#3.添加家具
my_house.add_item(bed)
my_house.add_item(chest)
my_house.add_item(table)
print(my_house)
结果：
户型:两室一厅
总面积:100.00[剩余:92.50]
家具:['bed', 'chest', 'table']
题目三：
1.士兵瑞恩有一把AK47
2.士兵可以开火(士兵开火扣动的是扳机)
3.枪 能够 发射子弹(把子弹发射出去)
4.枪 能够 装填子弹 --增加子弹的数量
##创建枪类
class Gun():
def __init__(self,model):
self.model = model
self.bullet_count = 0 ##子弹的数量一开始为0
def add_bullet(self,count):
self.bullet_count += count
def shoot(self):
if self.bullet_count <=0:
print('%s没有子弹了...' %self.model)
self.bullet_count -= 1
print('%s~~~~~%s' %(self.model,self.bullet_count))
##定义士兵类
class Soldier():
def __init__(self,name):
self.name = name
self.gun = None
def fire(self):
if self.gun == None:
print('%s还没有枪...' %self.name)
self.gun.add_bullet(10)
self.gun.shoot()
##定义枪对象
ak47 = Gun('ak47')
ak47.add_bullet(50)
ak47.shoot()
##定义士兵对象
ryan = Soldier('Ryan')
ryan.gun = ak47
ryan.fire()
结果：
ak47~~~~~49
ak47~~~~~58
二、继承：
- 继承：实现代码的重用，相同的代码不需要重复写
- 子类继承自父类，可以直接享受父类中已经封装好的方法
- 子类重应该根据职责，封装子类特有的属性和方法
class Animal():
def eat(self):
print('吃~~~~~')
def drink(self):
print('喝')
def run(self):
print('跑')
def sleep(self):
print('睡')
class Cat(Animal):
def call(self):
print('喵～')
fentiao = Cat()
fentiao.eat()
fentiao.run()
fentiao.call()
结果：
吃~~~~~
跑
喵～
-
子类可以继承父类的所有属性和方法
-
继承具有传递性，子类拥有父类的父类的属性和方法
class Animal(): def eat(self): print('吃~~~~~') def drink(self): print('喝') def run(self): print('跑') def sleep(self): print('睡') class Cat(Animal): def call(self): print('喵～') class HelloKitty(Cat): def speak(self): print('我能说英语') class Dog(Animal): def bark(self): print('汪～') kt = HelloKitty() kt.eat() kt.speak() 结果: 吃~~~~~ 我能说英语 -
如果子类重写了父类的方法
-
在运行中，只会调用在子类中重写的方法而不会调用父类方法
class Cat():
def call(self):
print('喵～')
class HelloKitty(Cat):
def speak(self):
print('我能说英语')
def call(self):
print('@#@$@$@#@!#')
kt = HelloKitty()
kt.call()
结果：
@#@$@$@#@!#
-
如果子类重写父类的方法后，还想调用父类的方法：
class Cat(): def call(self): print('喵～') class HelloKitty(Cat): def speak(self): print('我能说英语') def call(self): #1.针对子类特有的需求，编写代码 print('@#@$@$@#@!#') #2.调用原本在父类中封装的方法 # Cat.call(self) ##两种方法选一种 super().call() kt = HelloKitty() kt.call() 结果： @#@$@$@#@!# 喵～ -
多继承：子类拥有多个父类叫多继承，拥有所有父类的属性和方法
class A(): def test(self): print('A---->test方法') def demo(self): print('A---->demo方法') class B(): def test(self): print('B---->test方法') def demo(self): print('B---->demo方法') class C(A,B): ##当父类的方法或属性同名时，按括号中的父类先后顺序执行 pass c = C() c.test() c.demo() 结果: A---->test方法 A---->demo方法
三、多态：
1.什么是多态
同一种事物的多种形态(动物:人，猫，狗)
2.为何要用多态
多态性:指的是可以在不用考虑对象具体类型的前提下，直接调用对象的方法
3.如何使用多态
class Animal:
def talk(self):
pass
class People(Animal):
def talk(self):
print('say hello')
class Dog(Animal):
def talk(self):
print('汪汪汪')
class Pig(Animal):
def talk(self):
print('哼哼哼')
peo1=People()
dog1=Dog()
pig1=Pig()
# 不用考虑对象具体类型的前提下，直接调用对象的方法
peo1.talk()
dog1.talk()
pig1.talk()
"""
再来想车是不是有很多牌子，你去学车需要说专门学哪个牌子的车的驾驶方式吗？
"""
# 来你之前也一直在用多态性:不用考虑对象具体类型的前提下，直接调用对象的方法
l=list([1,2,3])
s=str('hello')
t=tuple((4,5,6))
l.__len__()
s.__len__()
t.__len__() # 我不需要考虑这三个具体是什么类型，只要是容器类型就都能调用len这个方法
# 再来看多态性能够实现的条件是什么？父类有的方法名子类也必须叫这个方法才行
class Animal:
def talk(self):
pass
class People(Animal):
def jiao(self):
print('say hello')
class Dog(Animal):
def han(self):
print('汪汪汪')
class Pig(Animal):
def hou(self):
print('哼哼哼')
# 多态性能实现的条件就是父类给子类定义了一个标准，动物都必须会叫，并且叫的方法都必须是talk
# 但是你现在能约束我说子类必须叫这个方法吗？
# 那有没有一种情况能够做到说子类必须按照父类定义的标准
import abc
class Animal(metaclass=abc.ABCMeta): # 父类存在的意义就是用来定义规范
@abc.abstractmethod
def talk(self):
pass
# Animal() # 抽象基类不能被实例化！！！
class People(Animal):
def jiao(self):
print('say hello')
class Dog(Animal):
def han(self):
print('汪汪汪')
class Pig(Animal):
def hou(self):
print('哼哼哼')
# 上面三个类 一实例化都会报错
# 但是python推崇的是自由，简约并不希望限制程序员的开发
# 鸭子类型：只要你长得像鸭子，说话像鸭子，那你就是鸭子！
class People:
def talk(self):
print('say hello')
class Dog:
def talk(self):
print('汪汪汪')
class Pig:
def talk(self):
print('哼哼哼')
# 再来看linux中:一切皆文件！
class Disk:
def read(self):
print('disk read')
def write(self):
print('disk write')
class Process:
def read(self):
print('process read')
def write(self):
print('processes write')
class Memory:
def read(self):
print('memory read')
def write(self):
print('memory write'
扫一扫
1190
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
