1、封装
-
封装：根据职责将属性和方法封装到一个抽象的类中
-
面向对象第一步：将属性和方法封装到一个抽象的类中
-
外界使用类创建对象，对象调用方法
-
对象方法的细节都被封装在类的内部
-
例1
"""
# _*_coding:utf-8 _*_
Name:封装_01.py
Date:4/11/19
Author:LiMin
Connect:[email protected]
Desc:
"""
"""
需求： 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,体重为%.1f千克' %(self.name,self.weight)
def run(self):
self.weight -= 0.5
return '%s跑完步后体重变为%.1f千克' %(self.name,self.weight)
def eat(self):
self.weight += 1
return '%s吃完东西后体重变为%.1f千克' %(self.name,self.weight)
person = Person('李雷',75.0)
print(person)
print(person.run())
hanmeimei = Person('韩梅梅',45.0)
print(hanmeimei)
print(hanmeimei.eat())
运行结果：
我的名字是李雷,体重为75.0千克
李雷跑完步后体重变为74.5千克
我的名字是韩梅梅,体重为45.0千克
韩梅梅吃完东西后体重变为46.0千克
- 例2
"""
# _*_coding:utf-8 _*_
Name:封装_02.py
Date:4/11/19
Author:LiMin
Connect:[email protected]
Desc:
"""
"""
需求： 1.房子有户型，总面积和家具名称列表,新房子没有任何的家具
2.家具有名字和占地面积，其中
床：占4平米
衣柜：占2平面
餐桌：占1.5平米
3.将以上三件家具添加到房子中
4.打印房子时，要求输出:户型，总面积，剩余面积，家具名称列表
"""
class Furniture():
def __init__(self,name,area):
self.name = name
self.area = area
def __str__(self):
return '[%s]占地面积为%.2f平米' %(self.name,self.area)
class House():
def __init__(self,house_type,area):
self.house_type = house_type
self.area = area
self.free_area = area ##剩余面积，没有放置家具前，剩余面积为所有面积。
self.list_item = []
def __str__(self):
return '房子户型为%s,\n面积为%.2f平米,\n家具%s,\n剩余面积%.2f平米'%(self.house_type,self.area,self.list_item,self.free_area)
def add_item(self,item):
if item.area >= self.free_area: #判断家具的面积
print('%s的占地面积太大，房间搁置不下' %item.name)
else:
self.list_item.append(item.name) #将家具的名称添加到列表中
self.free_area -= item.area ##计算剩余面积
#先创建家具对象
bed = Furniture('bed',4)
yg = Furniture('yg',2)
table = Furniture('table',1.5)
#创建房子对象
house = House('三室一厅',120)
#添加家具
house.add_item(bed)
house.add_item(table)
print(house)
运行结果：
房子户型为三室一厅,
面积为120.00平米,
家具['bed', 'table'],
剩余面积114.50平米
- 例3
"""
# _*_coding:utf-8 _*_
Name:封装_03.py
Date:4/11/19
Author:LiMin
Connect:[email protected]
Desc:
"""
"""
1.士兵瑞恩有一把AK47
2.士兵可以开火(士兵开火扣动的是扳机)
3.枪 能够 发射子弹(把子弹发射出去)
4.枪 能够 装填子弹 --增加子弹的数量
Soldier Gun
------------- -----------------
name model
gun bullet_count #子弹数量足够多才能完
成射击的动作
------------- -----------------
__init__(self): __init__(self):
fire(self): add_bullet(self,count):#装填子弹的
方法
shoot(self):
"""
class Gun(): ##枪的类
def __init__(self,model):
self.model = model
self.bullet_count = 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(5) ##如果添加上5颗子弹
self.gun.shoot() ##完成设计动作
ak47 = Gun('ak47') ##枪的实例化
ak47.add_bullet(20) ##给枪添加20发子弹
ak47.shoot()
ryan = Soldier('Ryan') ##大兵的实例化
ryan.gun = ak47
ryan.fire()
运行结果：
ak47 ... 19 ##添加了20 发子弹，完成一次射击动作，还剩下19发
ak47 ... 23 ##19发子弹，又添加了5发，完成一次射击动作，还剩下23发
2、继承
- 继承：实现代码的重用，相同的代码不需要重复的写
- 子类继承自父类，可以直接享受父类中已经封装好的方法
- 子类中应该根据职责，封装子类特有的属性和方法
"""
# _*_coding:utf-8 _*_
Name:继承_01.py
Date:4/11/19
Author:LiMin
Connect:[email protected]
Desc:
"""
class Animal():
def eat(self):
print('吃')
def drink(self):
print('喝')
def play(self):
print('玩')
def enjoy(self):
print('乐')
class people(Animal):
def sleep(self):
print('睡')
lily = people()
lily.eat()
lily.enjoy()
lily.sleep()
运行结果：
吃
乐
睡
- 子类可以继承父类的所有属性和方法
- 继承具有传递性，子类拥有父类的属性和方法
"""
# _*_coding:utf-8 _*_
Name:继承_02.py
Date:4/11/19
Author:LiMin
Connect:[email protected]
Desc:
"""
class Animal():
def eat(self):
print('吃')
def drink(self):
print('喝')
def play(self):
print('玩')
def enjoy(self):
print('乐')
class Cat(Animal):
def shout(self):
print('喵')
class Hellokitty(Cat):
def speak(self):
print('我会说日语')
kt = Hellokitty()
kt.speak()
kt.shout()
kt.eat()
kt.enjoy()
运行结果：
我会说日语
喵
吃
乐
- 当父类方法不能满足子类的需求时，可以对方法进行重写
1.覆盖父类的方法
2.对父类的方法进行扩展 - 如果子类中，重写了父类的方法，在运形时，只会调用在子类中重写的方法
"""
# _*_coding:utf-8 _*_
Name:继承_03.py
Date:4/11/19
Author:LiMin
Connect:[email protected]
Desc:
"""
class Animal():
def eat(self):
print('吃')
def drink(self):
print('喝')
def run(self):
print('跑')
def sleep(self):
print('睡')
class Cat(Animal):
def shout(self):
print('喵')
class Hellokitty(Cat):
def speak(self):
print('我可以说日语')
def shout(self):
print('@#$%%@$#@#@$')
kt = Hellokitty()
kt.shout()
运行结果：
@#$%%@$#@#@$
- 当有两个父类有同样的方法时，调用第一个
"""
# _*_coding:utf-8 _*_
Name:封装_04.py
Date:4/11/19
Author:LiMin
Connect:[email protected]
Desc:
"""
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方法
3、多态
- 多态： 子类和父类存在相同方法时，子类会覆盖父类方法，运形时总会调用子类方法
"""
# _*_coding:utf-8 _*_
Name:多态.py
Date:4/11/19
Author:LiMin
Connect:[email protected]
Desc:
"""
class Animal(object):
def run(self):
print('running...')
def cry(self):
print('crying...')
class Dog(Animal):
def run(self):
print('dog running...')
def eat(self):
print('dog eating...')
class Cat(Animal):
def run(self):
print('cat running...')
cat = Cat()
cat.run()
cat.cry()
dog = Dog()
dog.run()
运行结果：
cat running...
crying...
dog running...
4、新式类和旧式类
- 新式类和旧式(经典)类：object是Python为所有对象提供的基类，提供有一些内置的属性和方法，可以使用dir函数查看。
- 新式类：以object为基类的类，推荐使用
- 经典类：不以object为基类的类，不推荐使用
- 在python3.X中定义的类时，如果没有指定父类，会默认使用object作为基类–python3.x中定义的类都是新式类
- 在python2.x中定义类时，如果没有指定父类，则不会以object作为基类
为保证编写的代码能够同时在python2.x和python3.x运行，今后在定义类时，如果没有父类，建议统一继承自object
class A(object):
pass