Python 入门 —— Python 面向对象的三大特点:封装、继承、多态
Python 面向对象的三大特点:封装、继承、多态
- 面向对象的三大特点:
- 封装:将有一定功能的代码封装起来,使用时调用即可
- 继承:将公共的属性和方法放在父类中,自己自考虑特有的属性和方法。
- 多态:程序运行过程中,根据执行条件的不同,动态执行不同的操作代码的过程称为运行时多态。
1 封装
- 封装
1.封装是面向对象编程的一大特点
2.面向对象编程的第一步将属性和方法封装到一抽象的类中
3.外界使用类创建对象,然后让对象调用方法
4.对象方法的细节都被封装在类的内部
示例一:
要求:
XX爱跑步
1. XX体重75.0公斤
2. XX每次跑步会减肥0.5公斤
3. XX每次吃东西体重会增加1公斤
class Person(): # 定义类
def __init__(self,name,weight):
self.name = name
self.weight = weight
print "%s like to run,and %s's weight is %.2f kg" \
% (self.name,self.name,self.weight)
def run(self,lose_weight): # 定义方法
self.weight -= lose_weight
print "When %s run,weight will be lost %.2f kg ,and the finall weight is %.2f" \
% (self.name,lose_weight,self.weight)
def eat(self,get_weight): # 定义方法
self.weight += get_weight
print "When %s eat,weight will be put on %.2f kg ,and the finall weight is %.2f" \
% (self.name,get_weight, self.weight)
Tom = Person('Tom',75) # 定义对象
Tom.run(0.5) # 调用方法,加上参数,意味,Tom 每跑一次步,就减重0.5
Jarry = Person('Jarry',60)# 可以定义第二个对象,再调用方法
Jarry.eat(1) # 调用方法,加上参数,意味,Tom 每吃一次,就增重1
执行如下:
控制台显示如下:
这就是封装,定义不同对象,只需要对类中的方法进行调用,然后让其完成对应的效果
示例二:
摆放家具
需求:
1.房子有户型,总面积和家具名称列表
新房子没有任何的家具
2.家具有名字和战地面积,其中
床:占4平米
衣柜:占2平面
餐桌:占1.5平米
3.将以上三件家具添加到房子中
4.打印房子时,要求输出:户型,总面积,剩余面积,家具名称列表
class Furniture(object): # 建立类 Furniture
def __init__(self,name,area):
self.name = name
self.area = area
class House(object): # 建立类 House
def __init__(self,model,areas):
self.model = model
self.areas = areas
self.free_area = areas
self.furniture_list = []
def __str__(self):
return '房子户型:%s\n房子大小:%.2f\n剩余空间:%.2f\n家具列表:%s' \
% (self.model,self.areas,self.free_area,self.furniture_list)
def add(self,furniture): # 创建方法 add 进行家具的添加
if furniture.area > self.areas:
print '%s 面积太大,无法添加' % furniture.name
return
self.furniture_list.append(furniture.name)
print '%s 添加成功' % furniture.name
self.free_area -= furniture.area
bed = Furniture('bed',400) # 建立家具类的对象 bed,给bed面积为100
wardrobe = Furniture('wardrobe',2) # 建立家具类的对象 wardrobe
table = Furniture('table',1.5) # 建立家具类的对象 table
my_house = House('三室一厅',100) # 创建对象my_house,给他的面积为100
my_house.add(bed) # 调用方法添加及家具
my_house.add(wardrobe)
my_house.add(table)
print my_house
控制台显示如下:
由于bed面积大于房子的面积100,所以无法被添加
2 继承:
- Python 类的继承
在OOP(Object Oriented Programming)程序设计中,当我们定义一个c lass的时候,可以从某个现有的class 继承,新的class称为子类(Subclass),而被继承的class称为基类、父类或超类(Base class、Super class)。- 子类拥有父类的所有属性和方法
子类继承父类,可以直接享受父类已经封装好的方法
子类中应该根据自己的职责,封装子类特有的属性和方法
示例:
class Animal(): # 定义父类 Animal 类
def eat(self): # 定义父类中的方法
print 'eat'
def drink(self):
print 'drink'
def run(self):
print 'run'
def sleep(self):
print 'sleep'
class Cat(Animal):
# 子类拥有父类的所有属性和方法
# 子类根据自己的职责,封装子类特有的属性和方法
def scream(self):
print 'miao~~'
tom = Cat()
tom.eat() # 子类的示例直接可以调用父类中的方法
tom.drink()
tom.run()
tom.sleep()
tom.scream()
执行如下:
控制台显示如下:
继承的传递性:(爷爷,父亲,儿子)
1.C类从B类继承,B类又从A类继承
2.那么C类就具有B类和A类的所有属性和方法
子类拥有父类以及父类的父类中封装的所有属性和方法
示例:
class Animal():
def eat(self):
print 'eat'
def drink(self):
print 'drink'
def run(self):
print 'run'
def sleep(self):
print 'sleep'
class Cat(Animal):
# 子类拥有父类的所有属性和方法
# 子类根据自己的职责,封装子类特有的属性和方法
def scream(self):
print 'miao~~'
class BlueCat(Cat): # 定义子类的子类
def speak(self):
print 'I can spea Chinese'
bluecat = BlueCat()
bluecat.eat()
bluecat.drink()
bluecat.run()
bluecat.sleep()
bluecat.scream()
bluecat.speak()
执行如下:
控制台显示如下:
继承——重写父类
- 重写父类方法有两种情况:
1.覆盖父类的方法
2.对父类方法进行扩展
1.覆盖父类的方法
如果在开发中,父类的方法的实现和子类方法的实现,
完全不同,就可以使用覆盖的方式,
在子类中重新编写父类的方法
具体实现方法,相当于在子类中定义了一个父类同名的方法并且实现
重写之后,在运行时,只会调用子类的重写方法
而不会调用父类的封装的方法
示例:
class Animal():
def eat(self):
print 'eat'
def drink(self):
print 'drink'
def run(self):
print 'run'
def sleep(self):
print 'sleep'
class Cat(Animal):
# 子类拥有父类的所有属性和方法
def scream(self):
print 'miao~~'
# 子类继承父类,可以直接享受父类已经封装好的方法
# 子类中应该根据自己的职责,封装子类特有的属性和方法
class BlueCat(Cat):
def speak(self):
print 'I can speak Chinese'
def scream(self): # 子类中定义与父类相同的方法,进行覆盖
print 'Come here beat me!'
bluecat = BlueCat() # 定义对象
bluecat.eat() # 调用父类的方法
bluecat.drink()
bluecat.run()
bluecat.sleep()
bluecat.scream() # 调用重新定义过的与父类中方法相同的方法
bluecat.speak()
执行如下:
控制台显示如下:
2.对父类的方法进行扩展
如果在开发中,子类的方法实现包含有父类的方法实现
(父类原本封装的方法实现是子类方法的一部分就可以使用扩展方法)
1.在子类中重写父类的方法
2.在需要的位置使用父类名.方法(self)来调用父类方法的执行(使用父类名称调用父类方法)
3.代码其他位置针对子类的需求,编写子类特有的代码实现
示例:
class Animal():
def eat(self):
print 'eat'
def drink(self):
print 'drink'
def run(self):
print 'run'
def sleep(self):
print 'sleep'
class Cat(Animal):
# 子类拥有父类的所有属性和方法
def scream(self):
print 'miao~~'
# 子类继承父类,可以直接享受父类已经封装好的方法
# 子类中应该根据自己的职责,封装子类特有的属性和方法
class BlueCat(Cat):
def speak(self):
print 'I can speak Chinese'
def scream(self):
print 'Come here beat me!'
Cat.scream(self) # 调用父类的同名方法
bluecat = BlueCat()
bluecat.eat()
bluecat.drink()
bluecat.run()
bluecat.sleep()
bluecat.scream()
bluecat.speak()
执行如下:
控制台显示如下:
多继承
子类拥有一个父类叫做单继承
子类可以拥有多个父类,并且具有所有父类的属性和方法
示例:
class A(): # 定义父类 A
def test(self):
print 'A'
class B(): # 定义父类 B
def demo(self):
print 'B'
class C(B,A): # 定义子类C,继承父类 A,B 的特性
pass
c = C()
c.test()
c.demo()
执行如下:
控制台显示如下:
若是父类的方法中有相同名称的,子类会继承在前方的属性
示例:定义父类A,B,A,B中有相同的方法,子类会继在前方的父类的方法
class A(): # 定义父类 A
def test(self):
print 'A'
class B(): # 定义父类 B
def test(self):
print 'B'
class C(A,B): # 定义子类C,继承父类 A,B 的特性
pass
c = C()
c.test()
执行如下:
控制台显示如下:
若是调换顺序:
class A():
def test(self):
print 'A'
class B():
def test(self):
print 'B'
class C(B,A):
pass
c = C()
c.test()
控制台显示如下:
3 多态
面向对象程序设计最有趣的特性是多态,它是是让大多数人犯晕的特性。
多态:(Polymorphism) 按字面的意思就是“多种状态”
在面向对象语言中,接口的多种不同的实现方式即为多态。
多态意味着就算不知道变量所引用的对象类是什么,还是能对它进行操作,而它也会根据对象(或类)类型的不同而表现出不同的行为。
示例一:
class Animal(object):
def __init__(self,name):
self.name = name
def scream(self):
print '没有动物叫'
class Cat(Animal):
def scream(self):
print '喵喵喵喵喵'
class Dog(Animal):
def scream(self):
print '汪汪汪汪汪'
a = Animal('')
a.scream()
c = Cat('Tom')
c.scream()
d = Dog('Senven')
d.scream()
代码中有Cat和Dog 两个子类,都继承了类Animal,它们都有scream()方法,输入不同的动物名称,会得到相应的结果,这就是多态的应用
执行如下:
控制台显示:
示例二:此例子能更清晰点
class Dog(object):
def __init__(self,name):
self.name = name
def scream(self):
print '%s wang,wang,wang' % self.name
def game(self):
print '%s 玩耍,玩飞盘' % self.name
class GodDog(Dog):
def game(self):
print '%s fly and scream' % self.name
class Person(object):
def __init__(self,name):
self.name = name
def game(self,dog):
print '%s play with %s' % (self.name,dog.name)
dog.game()
wangcai = Dog('wangcai')
goddog = GodDog('xiaotian')
yangjian = Person('yangjain')
yangjian.game(wangcai)
执行如下:
控制台显示:
推荐阅读
-
Python 入门 —— Python 面向对象的三大特点:封装、继承、多态
-
Python3.5面向对象程序设计之类的继承和多态详解
-
Python面向对象程序设计类的封装与继承用法示例
-
Python 入门 之 面向对象的三大特性(封装 / 继承 / 多态)
-
python3全栈开发-面向对象的三大特性(继承,多态,封装)之继承
-
Python3.5面向对象程序设计之类的继承和多态详解
-
python面向对象(封装、继承、多态)+ 面向对象小栗子
-
python小结----面向对象的三大特征(封装,继承,多态)
-
python面向对象三大特性:封装、继承、多态
-
python与面向对象(issubclass、封装、多态、多继承)4