一、面向对象两个核心概念：
1.类：是一群具有相同特征或形为的事物的一个统称，类是抽象的，不能直接使用
2.对象：由类创造出来的具体存在
在开发中，应该先有类，再有对象
二、类和对象的关系
类是模板，对象是根据这个模板创建出来的
类只需要有一个，对象可以有多个（一张图纸可以造多个飞机）
类：属性（信息）和方法（你能完成的事）
#1.类名
#2.属性
#3.方法
#1.类名 ：这类事物的名字，满足大驼峰命名法
#2.属性：这个类创建出的对象有什么特征
#3.方法：这个类创建出的对象有什么行为
需求：
1、人的类
小明今年18岁，身高1.75，每天早上要跑步，然后去吃东西
小美今年17岁，身高1.65，小美不跑步，但是喜欢吃东西
Person ##类名
name ##属性
age ##属性
height ##属性
run() ##方法
eat() ##方法
2.一只黄颜色的狗叫大黄
看见生人汪汪叫
看见家人摇尾巴
Dog ##类名
name ##属性
color ##属性
shout() ##方法
shake() ##方法
三、类的定义和使用
#小猫爱吃鱼，小猫要喝水
代码：
class Cat(): ##类的定义
def eat(self): ##定义吃的方法
print('%s爱吃鱼' %self.name) ##self:哪一个对象调用的方法，self就是哪一个对象的引用
def drink(self): ##定义喝的方法
print('小猫要喝水')
tom = Cat() ##定义一个对象tom属于猫类
tom.name = 'Tom' ##可以使用 .属性名 利用赋值语句就可以在类的外部
print(tom) ##给对象增加属性（不推荐）,将对象的属性封装在类中
tom.eat() ##tom，吃的方法调用
tom.drink() ##tom，喝的方法调用
hello_kitty = Cat()
hello_kitty.name = 'hello_kitty'
hello_kitty.eat()
hello_kitty.drink()
实验结果：
Tom爱吃鱼
小猫要喝水
hello_kitty爱吃鱼
小猫要喝水
四、初始化方法
如果有初始化方法，那么在定义类的时候传入参数
class Cat():
def __init__(self,name): ##初始化方法，如果不传入参数，会报错，类似构造函数
print('这是一个初始化方法') ##传入参数后，直接调用初始化方法
self.name = name
def eat(self):
print('%s爱吃鱼' %self.name)
cat = Cat('tom')
print(cat.name)
hello_kitty = Cat('HK')
print(hello_kitty.name)
hello_kitty.eat()
实验结果：
这是一个初始化方法
tom
这是一个初始化方法
HK
HK爱吃鱼
五、__str__方法
只要定义了__str__(self)方法，那么就会打印从这个方法中return的数据
class Cat():
def __init__(self,name):
self.name = name
def __str__(self):
return '我是%s' %self.name
tom = Cat('粉条')
print(tom)
实验结果：
我是粉条
练习：使用面向对象的方法，实现堆栈的功能
代码：
class Stack():
def __init__(self):
self.stack = []
def push(self,value):
self.stack.append(value)
return True
def pop(self):
#先判断栈是否为空
if self.stack:
item = self.stack.pop()
return item
else:
return False
def top(self):
if self.stack:
return self.stack[-1]
else:
return False
def length(self):
return len(self.stack)
def view(self):
return ','.join(self.stack)
s = Stack()
s.push('1')
s.push('2')
item = s.pop()
print(item)
print(s.view())
实验结果：
2
1
六、封装
封装
#面向对象第一步 ： 将属性和方法封装到一个抽象的类中
#外界使用类创建对象，然后让对象调用方法
#对象方法的细节都封装在类的内部
"""
需求
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)
yg = HouseItem('yg',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(yg)
my_house.add_item(table)
print(my_house)
实验结果：
户型:两室一厅
总面积:100.00[剩余:92.50]
家具:['bed', 'yg', 'table']
练习：
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(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
七、继承
1）继承的概念和使用
面向对象的三大特征：
1.封装：根据职责将属性和方法封装到一个抽象的类中
2.继承：实现代码的重用，相同的代码不需要重复写
"""
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()
实验结果：
吃~~~~~
跑
喵～
#子类继承自父类，可以直接享受父类中已经封装好的方法
#子类重应该根据职责，封装子类特有的属性和方法
2）多重继承
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()
实验结果：
吃~~~~~
我能说英语
#子类可以继承父类的所有属性和方法
#继承具有传递性，子类拥有父类的父类的属性和方法
3）子类重写父类方法将会覆盖原来的方法
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('我能说英语')
def call(self):
print('@#@$@$@#@!#')
kt = HelloKitty()
kt.call()
实验结果：
@#@$@$@#@!#
#如果子类重，重写了父类的方法
#在运行重，只会调用在子类中重写的方法而不会调用父类方法
4）调用原本在父类中封装的方法
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('我能说英语')
def call(self):
#1.针对子类特有的需求，编写代码
print('@#@$@$@#@!#')
#2.调用原本在父类中封装的方法
# Cat.call(self)
super().call()
kt = HelloKitty()
kt.call()
实验结果：
@#@$@$@#@!#
喵～
5）继承多个父类，前面的父类会覆盖后面的父类。
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方法