一.面向对象的概念
#面向对象两个核心概念:
#1.类:是一群具有相同特征或形为的事物的一个统称,类是抽象的,不能直接使用
#2.对象:由类创造出来的具体存在
#在开发中,应该先有类,再有对象
#类和对象的关系
#类是模板,对象是根据这个模板创建出来的
#类只需要有一个,对象可以有多个(一张图纸可以造多个飞机)
#类:属性(信息)和方法(你能完成的事)
#1.类名
#2.属性
#3.方法
#1.类名 :这类事物的名字,满足大驼峰命名法
#2.属性:这个类创建出的对象有什么特征
#3.方法:这个类创建出的对象有什么行为
"""
需求:
小明今年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)
def drink(self):
print('小猫要喝水')
tom = Cat()
tom.name = 'Tom'
print(tom)
tom.eat()
tom.drink()
hello_kitty = Cat()
hello_kitty.name = 'hello_kitty'
hello_kitty.eat()
hello_kitty.drink()
#self:哪一个对象调用的方法,self就是哪一个对象的引用
#可以使用 .属性名 利用赋值语句就可以在类的外部
#给对象增加属性(不推荐),将对象的属性封装在类中
二.初始化方法
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()
三.__str__方法
"""
__str__方法
"""
class Cat():
def __init__(self,name):
self.name = name
def __str__(self):
return '我是%s' %self.name
tom = Cat('粉条')
print(tom)
#练习1
#用面向对象方式实现栈的工作方式
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())
四.封装
#封装
#面向对象第一步 : 将属性和方法封装到一个抽象的类中
#外界使用类创建对象,然后让对象调用方法
#对象方法的细节都封装在类的内部
"""
需求
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)
五.继承
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 eat(self):
# print('吃~~~~~')
# def drink(self):
# print('喝')
# def run(self):
# print('跑')
# def sleep(self):
# print('睡')
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()