1. #   ---------------------  类的三大特性的综合运用 案例  -------------------------
  2. #   定义三个类：小狗，小猫，人
  3. #   小狗：姓名，年龄（默认1岁）      吃饭，玩，睡觉，看家（格式：名字是xx，年龄xx岁的小狗在xx）
  4. #   小猫：姓名，年龄（默认1岁）      吃饭，玩，睡觉，捉老鼠（格式：名字是xx，年龄xx岁的小猫在xx）
  5. #   人：姓名，年龄（默认1岁），宠物      吃饭，玩，睡觉，（格式：名字是xx，年龄xx岁的人在xx）
  6. #                              养宠物（让所以的宠物吃饭，玩，睡觉)
  7. #                               工作（让所有的宠物做自己工作职能的工作）
  8.  
  9. class Person():
  10.     def __init__(self, name, pets, age=1):
  11.         self.name = name
  12.         self.pets = pets
  13.         self.age = age
  14.  
  15.     def eat(self):
  16.         print("%s 在吃饭" % self)
  17.  
  18.     def play(self):
  19.         print("%s 在玩" % self)
  20.  
  21.     def sleep(self):
  22.         print("%s 在睡觉" % self)
  23.  
  24.     def yangPets(self):
  25.         print("%s 养宠物" % self)
  26.         for pet in self.pets:
  27.             pet.eat()
  28.             pet.play()
  29.             pet.sleep()
  30.  
  31.     def make_pets_work(self):
  32.         # for pet in self.pets:
  33.         #     if isinstance(pet, Dog):
  34.         #         pet.wacth()
  35.         #     elif isinstance(pet, Cat):
  36.         #         pet.cacth()
  37.  
  38.         #   上面的如果在加入其他的对象可能就需要重新写判断条件，可以把宠物的智能都写成相同的一个函数
  39.         for pet in self.pets:
  40.             pet.work()
  41.  
  42.     def __str__(self):
  43.         return "名字为{}，年龄为{}的人".format(self.name, self.age)
  44.  
  45. class Dog():
  46.     def __init__(self, name, age = 1):
  47.         self.name = name
  48.         self.age = age
  49.  
  50.     def eat(self):
  51.         print("%s 在吃饭" % self)
  52.  
  53.     def play(self):
  54.         print("%s 在玩" % self)
  55.  
  56.     def sleep(self):
  57.         print("%s 在睡觉" % self)
  58.  
  59.     #   改造
  60.     # def wacth(self):
  61.     def work(self):
  62.         print("%s 看家" % self)
  63.  
  64.     def __str__(self):
  65.         return "名字为{}，年龄为{}的小狗".format(self.name, self.age)
  66.  
  67. class Cat():
  68.     def __init__(self, name, age=1):
  69.         self.name = name
  70.         self.age = age
  71.  
  72.     def eat(self):
  73.         print("%s 在吃饭" % self)
  74.  
  75.     def play(self):
  76.         print("%s 在玩" % self)
  77.  
  78.     def sleep(self):
  79.         print("%s 在睡觉" % self)
  80.  
  81.     #   改造
  82.     # def cacth(self):
  83.     def work(self):
  84.         print("%s 捉老鼠" % self)
  85.  
  86.     def __str__(self):
  87.         return "名字为{}，年龄为{}的小猫".format(self.name, self.age)
  88.  
  89. d = Dog("小黑", 18)
  90. c = Cat("小花", 20)
  91. print(d)    #   名字为小黑，年龄为18的小狗
  92. d.eat()     #   名字为小黑，年龄为18的小狗 在吃饭
  93. d.play()    #   名字为小黑，年龄为18的小狗 在玩
  94. print("-" * 30)
  95.  
  96. p = Person("小明", [d, c], 30)
  97. p.yangPets()
  98. print("-" * 30)
  99. p.make_pets_work()
  100.  
  101. print("=" * 30)
  102.  
  103. #   --------------------    改造上面的案例 ---------------------
  104. class Animal():
  105.     def __init__(self, name, age = 1):
  106.         self.name = name
  107.         self.age = age
  108.  
  109.     def eat(self):
  110.         print("%s 在吃饭" % self)
  111.  
  112.     def play(self):
  113.         print("%s 在玩" % self)
  114.  
  115.     def sleep(self):
  116.         print("%s 在睡觉" % self)
  117.  
  118. class Person(Animal):
  119.     def __init__(self, name, pets, age=1):
  120.         super(Person, self).__init__(name, age)
  121.         self.pets = pets
  122.  
  123.     #   修改命名方式
  124.     def yang_pets(self):
  125.         print("%s 养宠物" % self)
  126.         for pet in self.pets:
  127.             pet.eat()
  128.             pet.play()
  129.             pet.sleep()
  130.  
  131.     def make_pets_work(self):
  132.         # for pet in self.pets:
  133.         #     if isinstance(pet, Dog):
  134.         #         pet.wacth()
  135.         #     elif isinstance(pet, Cat):
  136.         #         pet.cacth()
  137.  
  138.         #   上面的如果在加入其他的对象可能就需要重新写判断条件，可以把宠物的智能都写成相同的一个函数
  139.         for pet in self.pets:
  140.             pet.work()
  141.     #
  142.     def __str__(self):
  143.         return "名字为{}，年龄为{}的人".format(self.name, self.age)
  144.  
  145. class Dog(Animal):
  146.     def work(self):
  147.         print("%s 看家" % self)
  148.  
  149.     def __str__(self):
  150.         return "名字为{}，年龄为{}的小狗".format(self.name, self.age)
  151.  
  152. class Cat(Animal):
  153.     def work(self):
  154.         print("%s 捉老鼠" % self)
  155.  
  156.     def __str__(self):
  157.         return "名字为{}，年龄为{}的小猫".format(self.name, self.age)
  158.  
  159. d = Dog("小黑", 10)
  160. c = Cat("小花", 11)
  161. p = Person("小明", [d, c], 20)
  162. p.yang_pets()
  163. p.make_pets_work()
  1. #   ---------------------  类的三大特性的综合运用 案例  -------------------------
    #   定义三个类：小狗，小猫，人
    #   小狗：姓名，年龄（默认1岁）      吃饭，玩，睡觉，看家（格式：名字是xx，年龄xx岁的小狗在xx）
    #   小猫：姓名，年龄（默认1岁）      吃饭，玩，睡觉，捉老鼠（格式：名字是xx，年龄xx岁的小猫在xx）
    #   人：姓名，年龄（默认1岁），宠物      吃饭，玩，睡觉，（格式：名字是xx，年龄xx岁的人在xx）
    #                              养宠物（让所以的宠物吃饭，玩，睡觉)
    #                               工作（让所有的宠物做自己工作职能的工作）
  2.  
  3. class Person():
        def __init__(self, name, pets, age=):
            self.name = name
            self.pets = pets
            self.age = age
  4.  
  5.     def eat(self):
            print("%s 在吃饭" % self)
  6.  
  7.     def play(self):
            print("%s 在玩" % self)
  8.  
  9.     def sleep(self):
            print("%s 在睡觉" % self)
  10.  
  11.     def yangPets(self):
            print("%s 养宠物" % self)
            for pet in self.pets:
                pet.eat()
                pet.play()
                pet.sleep()
  12.  
  13.     def make_pets_work(self):
            # for pet in self.pets:
            #     if isinstance(pet, Dog):
            #         pet.wacth()
            #     elif isinstance(pet, Cat):
            #         pet.cacth()
  14.  
  15.         #   上面的如果在加入其他的对象可能就需要重新写判断条件，可以把宠物的智能都写成相同的一个函数
    for pet in self.pets:
                pet.work()
  16.  
  17.     def __str__(self):
            return "名字为{}，年龄为{}的人".format(self.name, self.age)
  18.  
  19. class Dog():
        def __init__(self, name, age = ):
            self.name = name
            self.age = age
  20.  
  21.     def eat(self):
            print("%s 在吃饭" % self)
  22.  
  23.     def play(self):
            print("%s 在玩" % self)
  24.  
  25.     def sleep(self):
            print("%s 在睡觉" % self)
  26.  
  27.     #   改造
        # def wacth(self):
    def work(self):
            print("%s 看家" % self)
  28.  
  29.     def __str__(self):
            return "名字为{}，年龄为{}的小狗".format(self.name, self.age)
  30.  
  31. class Cat():
        def __init__(self, name, age=):
            self.name = name
            self.age = age
  32.  
  33.     def eat(self):
            print("%s 在吃饭" % self)
  34.  
  35.     def play(self):
            print("%s 在玩" % self)
  36.  
  37.     def sleep(self):
            print("%s 在睡觉" % self)
  38.  
  39.     #   改造
        # def cacth(self):
    def work(self):
            print("%s 捉老鼠" % self)
  40.  
  41.     def __str__(self):
            return "名字为{}，年龄为{}的小猫".format(self.name, self.age)
  42.  
  43. d = Dog("小黑", )
    c = Cat("小花", )
    print(d)    #   名字为小黑，年龄为18的小狗
    d.eat()     #   名字为小黑，年龄为18的小狗 在吃饭
    d.play()    #   名字为小黑，年龄为18的小狗 在玩
    print("-" * )
  44.  
  45. p = Person("小明", [d, c], )
    p.yangPets()
    print("-" * )
    p.make_pets_work()
  46.  
  47. print("=" * )
  48.  
  49. #   --------------------    改造上面的案例 ---------------------
    class Animal():
        def __init__(self, name, age = ):
            self.name = name
            self.age = age
  50.  
  51.     def eat(self):
            print("%s 在吃饭" % self)
  52.  
  53.     def play(self):
            print("%s 在玩" % self)
  54.  
  55.     def sleep(self):
            print("%s 在睡觉" % self)
  56.  
  57. class Person(Animal):
        def __init__(self, name, pets, age=):
            super(Person, self).__init__(name, age)
            self.pets = pets
  58.  
  59.     #   修改命名方式
    def yang_pets(self):
            print("%s 养宠物" % self)
            for pet in self.pets:
                pet.eat()
                pet.play()
                pet.sleep()
  60.  
  61.     def make_pets_work(self):
            # for pet in self.pets:
            #     if isinstance(pet, Dog):
            #         pet.wacth()
            #     elif isinstance(pet, Cat):
            #         pet.cacth()
  62.  
  63.         #   上面的如果在加入其他的对象可能就需要重新写判断条件，可以把宠物的智能都写成相同的一个函数
    for pet in self.pets:
                pet.work()
        #
    def __str__(self):
            return "名字为{}，年龄为{}的人".format(self.name, self.age)
  64.  
  65. class Dog(Animal):
        def work(self):
            print("%s 看家" % self)
  66.  
  67.     def __str__(self):
            return "名字为{}，年龄为{}的小狗".format(self.name, self.age)
  68.  
  69. class Cat(Animal):
        def work(self):
            print("%s 捉老鼠" % self)
  70.  
  71.     def __str__(self):
            return "名字为{}，年龄为{}的小猫".format(self.name, self.age)
  72.  
  73. d = Dog("小黑", )
    c = Cat("小花", )
    p = Person("小明", [d, c], )
    p.yang_pets()
    p.make_pets_work()

Python 类的三大特性的综合运用 案例的更多相关文章

  1. 第9章 Java类的三大特性之一：继承

    1.什么是继承 子类继承父类就是对父类的扩展,继承时会自动拥有父类所拥有的处private之外的所有成员作用:增加代码复用语法格式: class 子类名 extends 父类名{…………}第9章 Ja ...

  2. （转载）OC学习篇之---类的三大特性：封装，继承，多态

    之前的一片文章介绍了OC中类的初始化方法和点语法的使用,今天来继续学习OC中的类的三大特性,我们在学习Java的时候都知道,类有三大特性:继承,封装,多态,这个也是介绍类的时候,必须提到的话题,那么今 ...

  3. OC基础 类的三大特性

    OC基础  类的三大特性 OC的类和JAVA一样,都有三大特性:继承,封装,多态,那么我们就来看一下OC中类的三大特性. 1.继承 继承的特点: (1)子类从父类继承了属性和方法. (2)子类独有的属 ...

  4. 转 OC温故:类的三大特性(封装，继承，多态)

    原文标题:OC学习篇之---类的三大特性(封装,继承,多态) 我们都知道,面向对象程序设计中的类有三大特性:继承,封装,多态,这个也是介绍类的时候,必须提到的话题,那么今天就来看一下OC中类的三大特性 ...

  5. OC学习篇之---类的三大特性(封装，继承，多态)

    之前的一片文章介绍了OC中类的初始化方法和点语法的使用:http://blog.csdn.net/jiangwei0910410003/article/details/41683873,今天来继续学习 ...

  6. Python：Day24 类、类的三大特性

    Python有两种编程方式:函数式+面向对象 函数式编程可以做所有的事情,但是否合适? 面向对象: 一.定义 函数: def + 函数名(参数) 面象对象: class  bar--->  名字 ...

  7. Python 面向对象的三大特性：封装，继承，多态

    # 面向对象的三大特性:封装,继承,多态 # 继承的影响:资源的继承,资源的使用,资源的覆盖,资源的累加 # 资源的继承,在Python中的继承是指能使用父类的资源,而不是说在子类也复制一份父类代码到 ...

  8. Python - 面向对象编程 - 三大特性之继承

    继承 继承也是面向对象编程三大特性之一 继承是类与类的一种关系 定义一个新的 class 时,可以从某个现有的 class 继承 新的 class 类就叫子类(Subclass) 被继承的类一般称为父 ...

  9. Python 面向对象的三大特性

    面向对象的三大特性:继承,封装,多态 什么时候用封装: 同一种功能的时候, 譬如:把一部分数据或方法,封装到同一个类的中 PS:在构造方法中,原始数据中....

随机推荐

  1. Charlse 抓包

    下载Charlse:https://www.charlesproxy.com/ 安装使用: https://www.cnblogs.com/ceshijiagoushi/p/6812493.html ...

  2. java读取项目资源文件的方法

    1.把资源文件放在项目的Resource文件夹下,并使其设置成为资源文件夹(通过idea或者eclise)2. Thread.currentThread().getContextClassLoader ...

  3. 【Python基础】装饰器的解释和用法

    装饰器的用法比较简单,但是理解装饰器的原理还是比较复杂的,考虑到接下来的爬虫框架中很多用到装饰器的地方,我们先来讲解一下. 函数 我们定义了一个函数,没有什么具体操作,只是返回一个固定值 请注意一下缩 ...

  4. 巨蟒python全栈开发数据库攻略4：多表操作&Navicat&pymysql

    1.多表查询 2.连表补充 3.boss工具=>Navicat 4.索引加速寻找工具=>everything 5.pymysql 6.pymysql初识 7.pymysql的各个方法

  5. 【Python之路】第二十篇--MySQL（二）

    视图 视图是一个虚拟表(非真实存在),其本质是[根据SQL语句获取动态的数据集,并为其命名], 用户使用时只需使用[名称]即可获取结果集,并可以将其当作表来使用. 1.创建视图 --格式:CREATE ...

  6. mysql delete 多表

    DELETE u.*,acu.*,alu.* FROM user u, accountuser acu ,algouser alu WHERE u.userId=11 and acu.userID=1 ...

  7. php 汉字验证码

    代码: captcha.php <?php //实现简单的验证码 //session_start session_start(); //画布 $image = imagecreatetrueco ...

  8. 2015-03-18——mongodb的简单配置

    参考网址:http://www.cnblogs.com/mecity/archive/2011/06/11/2078527.html#3060056 mongod 数据库启动程序 mongo 数据库操 ...

  9. HTML里引号的输出与显示

    关于输入框中显示双引号和单引号 前台显示解决办法: 方法一: 单引号<input type="text" value="'"> 双引号<inp ...

  10. python线程间数据共享(示例演示)

    ``` import threading data_list = [] def task(arg): data_list.append(arg) print(data_list) def run(): ...