欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

Python 入门 —— Python 面向对象的三大特点:封装、继承、多态

程序员文章站 2024-03-04 15:06:11
...

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

执行如下:
Python 入门 —— Python 面向对象的三大特点:封装、继承、多态
控制台显示如下:
Python 入门 —— Python 面向对象的三大特点:封装、继承、多态

这就是封装,定义不同对象,只需要对类中的方法进行调用,然后让其完成对应的效果
示例二:
摆放家具
需求:
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

控制台显示如下:
Python 入门 —— Python 面向对象的三大特点:封装、继承、多态
由于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()

执行如下:
Python 入门 —— Python 面向对象的三大特点:封装、继承、多态
控制台显示如下:
Python 入门 —— Python 面向对象的三大特点:封装、继承、多态

继承的传递性:(爷爷,父亲,儿子)

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() 

执行如下:
Python 入门 —— Python 面向对象的三大特点:封装、继承、多态
控制台显示如下:
Python 入门 —— Python 面向对象的三大特点:封装、继承、多态

继承——重写父类

  • 重写父类方法有两种情况:
    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()

执行如下:
Python 入门 —— Python 面向对象的三大特点:封装、继承、多态
控制台显示如下:
Python 入门 —— Python 面向对象的三大特点:封装、继承、多态

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()

执行如下:
Python 入门 —— Python 面向对象的三大特点:封装、继承、多态
控制台显示如下:
Python 入门 —— Python 面向对象的三大特点:封装、继承、多态

多继承

子类拥有一个父类叫做单继承
子类可以拥有多个父类,并且具有所有父类的属性和方法

示例:

 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()

执行如下:
Python 入门 —— Python 面向对象的三大特点:封装、继承、多态
控制台显示如下:
Python 入门 —— Python 面向对象的三大特点:封装、继承、多态

若是父类的方法中有相同名称的,子类会继承在前方的属性

示例:定义父类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()

执行如下:
Python 入门 —— Python 面向对象的三大特点:封装、继承、多态
控制台显示如下:
Python 入门 —— Python 面向对象的三大特点:封装、继承、多态

若是调换顺序:

class A():
    def test(self):
        print 'A'

class B():
    def test(self):
        print 'B'

class C(B,A):
    pass

c = C()
c.test()

控制台显示如下:
Python 入门 —— Python 面向对象的三大特点:封装、继承、多态

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()方法,输入不同的动物名称,会得到相应的结果,这就是多态的应用
执行如下:
Python 入门 —— Python 面向对象的三大特点:封装、继承、多态
控制台显示:
Python 入门 —— Python 面向对象的三大特点:封装、继承、多态
示例二:此例子能更清晰点

 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 面向对象的三大特点:封装、继承、多态
控制台显示:
Python 入门 —— Python 面向对象的三大特点:封装、继承、多态