• Python面向对象的三大特征 --- 封装、继承、多态


    一、封装

      1)封装:是面向对象的一大特点;将属性和方法封装在一个抽象类中。外界使用类创建对象,然后让对象调用内部方法。对象方法的细节都被封装在类的内部。


    class Person():

      def __init__(self,name,weight):    # 初始化方法

          self.name = name

          self.weight = weight

      def __str__(self):     # 定义返回方法

          return 'my name is %s,my weight is %.2f.' %(self.name,self.weight)

      def run(self):        # 定义跑步方法

          self.weight -= 0.5

          print '每次跑步会减重0.5公斤。'

      def eat(self):       # 定义吃方法

          self.weight += 1.0

          print '每次吃东西会增重1.0公斤'

    # 创建类的实例化对象,并调用方法 

    ming = Person('小明',65)

    ming.run()

    ming.eat()

    print ming

     

    lili = Person('lili',45)

    lili.run()

    print lili 


      2)举例1:

        需求:摆放家具

        1、房间有户型,总面积和家具名称列表。新房间五家具

        2、家具上有名字和占地面积

        3、将家具添加在房子中

      解析如下:

     # 定义一个家具类。有姓名和占地面积的属性; 

     class fortn(): 

       def __init__(self,name,area):

            self.name = name

            self.area = area

       def __str__(self):

            return '%s的占地面积是%.2f' %(self.name,self.area)

    # 定义房子类。有户型、总面积、剩余面积、家具的属性;方法为添加家具

    class home():

       def __init__(self,name,area):

           self.name = name

           self.area = area

           self.leaveArea = area   # 剩余面积初始值为总面积

           self.fortn_list = []

       def __str__(self):

           return '户型:%s ,总面积:%.2f ,剩余面积:%.2f , 家具:%s' %(self.name,self.area,self.leaveArea,self.fortn_list)

       def add_thing(self,argc):

           print "要添加%s"  %argc.name

           if self.leaveArea < argc.area:

               print "%s占地面积太大,不能添加" %argc.name

               return

           self.fortn_list.append(argc.name)

           self.leaveArea -= argc.area

     

    # 创建家具对象

    bed = fortn('bed',4)

    chest = fortn('chest',2)

    table = fortn('table',1.5)

    # 创建房子对象

    my_house = home('两室一厅',200)

    my_house.add_thing(bed)

    my_house.add_thing(chest)

    my_house.add_thing(table)

    print my_house 


      举例2:

        需求:士兵有枪,当枪里有子弹才可以射击

      解析如下:

    # 创建枪类

    class  Gun():

       def __init__(self,model):

           self.model = model

           self.bullet_count = 0

       def shoot(self):

           if self.bullet_count <= 0:

               print "%s没有子弹" %self.model

               return 

           self.bullet_count -= 1

           print '发射一次,子弹还有%s' %self.bullet_count

       def add_bullet(self,count):

           self.bullet_count += count

    # 创建士兵类

    class Sodlier():

       def __init__(self,name):

           self.name = name

           self.gun = None    # 当属性不确定的时候,可以使用None来初始化

       def fire(self):

           if self.gun == None:

               print "%s还没有枪" %self.name

           print "go to fire!%s" %self.name

           self.gun.add_bullet(10)

           self.gun.shoot()

     

    # 定义枪对象

    ak47 = Gun('AK47')

    # ak47.add_bullet(10)

    # ak47.shoot()

     

    # 定义士兵对象

    ryan = Soldier('Ryan')

    ryan.gun = ak47

    ryan.fire()

    print ryan.gun

    二、继承

      1)继承实现的是代码的重用,相同部分代码不需要重写,分为单继承和多继承。多继承:一个子类可以继承多个父类。

      2)单继承:一个子类只能继承一个父类

     # 定义父类

    class Animal():

       def call(self):

           print "我会叫"

       def run(self):

           print "我会跑"

    # 定义子类Cat,并重写父类的call方法

    class Cat(Animal):

       def call(self):  # 由于和父类中的call方法重名,所以实现重写

          print "我会喵喵叫~~~"

    # 定义HelloKitty子类,继承Cat类

    class HelloKitty(Cat):

        def speak(self):

            print "我会说"

    # 创建对象

    tom = HelloKitty()

    tom.run()           # 在子类中没有定义run方法,但在父类和祖父类中有

    tom.call()         

    tom.speak()

      3)多继承:一个子类可以有多个父类

    # 定义父类1

    class  A():

       def test(self):

           print "A ---> test"

       def demo(self):

           print "A ---> demo"

    # 定义父类2

    class B():

       def test(self):

           print "B ---> test"

       def demo(self):

           print "B ---> demo"

    # 定义子类C,继承父类A和B的方法和属性

    class C(A,B):

       # 当父类中的方法同名时,按括号中父类的先后顺序继承

       pass

    # 定义子类的实例化对象

    c = C()

    c.test()    # 此时调用的均为父类A的结果

    c.demo()

      4)继承中的重写问题:在开发过程中,若父类方法和子类方法的实现完全不同,可以重写父类方法,实现方法覆盖。

    # 定义父类

    class Animal():

       def call(self):

           print "我会叫"

       def run(self):

           print "我会跑"

    # 定义子类Cat,并重写父类的call方法

    class Cat(Animal):

       def call(self):  # 由于和父类中的call方法重名,所以实现重写

          print "我会喵喵叫~~~"

           tom.run()     # 此时可以使用创建出来的对象,调用父类的方法

    # 创建对象

    tom = Cat()

    tom.call()           # 此时,调用call显示的为:我会喵喵叫

      5)继承中的扩展问题
    # 定义父类

    class Animal():

       def call(self):

           print "我会叫"

       def run(self):

           print "我会跑"

    # 定义子类Cat,并重写父类的call方法

    class Cat(Animal):

       def call(self):  # 由于和父类中的call方法重名,所以实现重写

           print "我会喵喵叫~~~"

    # 创建对象

    tom = Cat()

    tom.call()           # 此时,调用call显示的为:我会喵喵叫
     

    三、多态

      1)同一操作作用于不同的对象,可以有不同的解释,产生不同的执行结果

    class Dog(object):

       def __init__(self,name):

           self.name = name

       def game(self):

           print "%s是一只普通的狗" %self.name

    class amazing(Dog):

       def game(self):

           print "%s是一只神奇的狗" %self.name

    class Person(object):

       def __init__(self,name):

           self.name = name

       def game_with_dog(self,dog):

           print "%s和%s快乐地玩耍" %(self.name,dog.name)

           dog.game()

    wangcai = amazing("旺财")

    xiaoming = Person("小明")

    xiaoming.game_with_dog(wangcai)

     

       

      

      

      

         

  • 相关阅读:
    [LeetCode] Walls and Gates
    [LeetCode] Expression Add Operators
    [LeetCode] Inorder Successor in BST
    [LeetCode] Peeking Iterator
    [CTCI] 最小调整有序
    [LeetCode] Single Number III
    [LeetCode] Zigzag Iterator
    [LeetCode] Wiggle Sort
    android 设颜色透明值
    android android BitmapFactory报错OOM
  • 原文地址:https://www.cnblogs.com/uthnb/p/9609269.html
Copyright © 2020-2023  润新知