练习35(继承与继承的重用性、继承与派生、抽象类、多继承、新式类和经典类)

最新推荐文章于 2020-12-22 20:24:21 发布
最新推荐文章于 2020-12-22 20:24:21 发布
阅读量182 收藏
点赞数
分类专栏： Python 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bdsdyj_com/article/details/111344379
版权

练习35


# 面向对象的三大特性
    # 继承
        # 继承喝抽象 俩个概念
        # 单继承
            # 语法 : 父类 子类
            # 继承与重用
                # 子类可以使用父类中的名字(变量和方法)
            # 继承与派生
                # 子类在父类的基础上又新创建了自己需要的方法和属性

                # 父类有的子类没有 - 子类对象直接调用 就会直接执行父类的方法
                # 父类有的子类也有 - 子类对象调用 直接执行子类中的方法
                #                  想在子类中使用父类的名字：父类名、super()去调用

            # 规范的变成模式
                # 抽象类
        # 多继承
            # 语法
            # 接口类
            # 新式类和经典类
                # 新式类中
                # 在新式类中 所有的多继承关系寻找方法的顺序 - 都遵循广度优先
                # 继承object
                # mro 方法
                # super: super不是单纯的找父类,而是遵循mro顺序的
                # 经典类
                # python2.x
                # 不主动继承object
                # 静待鸟类在找父类中方法的过程中 遵循 - 深度优先
    # 多态
        #
    # 封装

# c
# c++ c# java python

# 继承的例子
# 游戏
    # 梅西 奥巴马 史努比 史派克 小猪佩奇 猪八戒 # 实例
    # 人 狗 猪 # 分类
    # 动物 # 汇总

# 先抽象 后继承



# 猫类
    # 属性：名字，品种，食物
    # 方法：叫声，抓老鼠，吃，喝
# 够类
    # 属性：名字，品种，食物
    # 方法：叫，看家，吃，喝
# class Animal:
#     def __init__(self,name,kind,food,language):
#         self.name = name
#         self.kind = kind
#         self.food = food
#         self.language = language
#     def yell(self):
#         print('%s叫' % (self.language))
#     def eat(self):
#         print('吃%s' % (self.food))
#     def drink(self):
#         print('喝水')
#
# class Cat(Animal):
#     def catch_mouse(self):
#         print('抓老鼠')
#
# class Dog(Animal):
#     def look_after_house(self):
#         print('看家')

# 继承
# 父类、超类、基类 ：Animal
# 子类 派生类     ：Cat、Dog

# 继承与重用 - 父类中所有的属性和方法都可以被子类使用了
# 阿猫 = Cat('阿猫', '橘猫', '牛杂', '喵喵')
# print(阿猫.name)
# 阿猫.drink()
# 阿猫.eat()
# 阿猫.yell()
#
# 阿狗 = Dog('阿狗', '土狗', '阿猫', '汪汪')
# print(阿狗.name)
# 阿狗.drink()
# 阿狗.eat()
# 阿狗.yell()


# 派生
# class Animal:
#     def __init__(self,name,kind,food,language):
#         print('in Animal')
#         self.name = name
#         self.kind = kind
#         self.food = food
#         self.language = language
#     def yell(self):
#         print('%s叫' % (self.language))
#     def eat(self):
#         print('吃%s' % (self.food))
#     def drink(self):
#         print('喝水')
#
# class Cat(Animal): # Amimal的派生类
#     def __init__(self,name,kind,food,language,eye_color):
#         print('in Cat')
#         self.eye_color = eye_color # 派生属性
#         # Animal.__init__(self,name,kind,food,language)
#         super().__init__(name,kind,food,language)
#
#     def catch_mouse(self): # 派生方法
#         print('抓老鼠')
#
#     def eat(self):   # 不仅执行了父类中的基础功能，还完成了特殊的功能
#         # Animal.eat(self)
#         super().eat()
#         self.weight = 10
#
# class Dog(Animal):
#     def look_after_house(self): # 派生方法
#         print('看家')
#     def eat(self):
#         # Animal.eat(self)
#         super().eat()
#         self.drink()
#
# 阿猫 = Cat('阿猫', '橘猫', '牛杂', '喵喵','绿色')
# print(阿猫.eye_color)
# print(阿猫.food)
# 阿猫.catch_mouse()
# 阿猫.eat()
# print(阿猫.weight)
# 当子类当中有要被调用的方法的时候，子类的对象会直接选择子类中的方法、变量 父类中的方法不会被自动执行
# 如果我们既想要执行子类的方法，也想要执行父类的方法，那么需要在子类的方法中要调用父类的方法
# 父类名.方法名(self...)
# super().方法名(...)
# 帮助我们在子类中调用父类中的同名方法

# 面试题
# class Foo:
#     def __init__(self):
#         self.func()
#     def func(self):
#         print('in Foo')
#
# class Son(Foo):
#     def func(self):
#         print('in Son')
#
# s1 = Son()

# class Foo:
#     Country = 'China'
#     def func(self):
#         print(self.Country)
#
# class Son(Foo):
#     Country = 'English'
#     def func(self):     # 走的这个方法
#         print(self.Country)
#
# s = Son()
# s.func()


# class Foo:
#     Country = 'China'
#     def func(self): # 走的这个方法
#         print(self.Country)
#
# class Son(Foo):
#     Country = 'English'
#
# s = Son()
# s.func()   # English


# class Foo:
#     Country = 'China'
#     def func(self):
#         print(self.Country)
#
# class Son(Foo):
#     pass
#
# s = Son()
# s.func()   # China


# 工作中 公司有使用抽象类开发的规则
# 源码 别人使用抽象类

# 支付功能
# from abc import ABCMeta,abstractmethod
# class Payment(metaclass=ABCMeta):   # 模板的功能
#     @abstractmethod   # abstractmethod 是一个装饰器,装饰器怎么用? 放在函数或者类的上一行
#     def pay(self):
#         pass
#     # @abstractmethod
#     # def shouqian(self):
#     #     pass
# 
# class Alipay(Payment):
#     def pay(self,money):
#         print('使用支付宝支付了%s元' % money)
# 
# class Wechatpay(Payment):
#     def pay(self,money):
#         print('使用微信支付了%s元' % money)
# 
# class Applepay(Payment):
#     def pay(self,money):
#         print('使用苹果支付了%s元' % money)
# 
# def pay(obj,money):
#     obj.pay(money)
# 
# a = Alipay()
# # a.pay(100)
# pay(a,100)
# 
# we = Wechatpay()
# # we.pay(200)
# pay(we,200)
# 
# ap = Applepay()


# 规范
# 多人开发 复杂的需求 后期的扩展

# 抽象类
    # 抽象类是一个规范,它基本不会实现什么具体的功能,抽象类是不能实例化的
    # 要想写一个抽象类,
        # from abc import ABCMeta,abstractmethod
        # 在这个类创建的时候指定 metaclass=ABCMeta
        # 在你希望子类实现的方法上上加上一个 @abstractmethod 装饰器
    # 使用抽象类
        # 继承这个类
        # 必须实现这个类被 @abstractmethod 装饰器装饰的方法


# 多继承
# class Parent1:pass
# class Parent2:pass
# class Son(Parent1,Parent2):pass
# print(Son.__bases__)

# 不是所有的语言都支持多继承 比如 java
# c++ 支持多继承

# 天鹅 飞 游泳 走路
# 老虎 走路 游泳
# 鹦鹉 飞 说话 走路
# class Animal:
#     def __init__(self,name):
#         self.name = name
#     def talk(self):
#         print('%s说话了' % self.name)
#
#     def swim(self):
#         print('%s在游泳' % self.name)
#
#     def fly(self):
#         print('%s在飞' % self.name)
#
#     def walk(self):
#         print('%s在走路' % self.name)



# class Animal:
#     def __init__(self,name):
#         self.name = name
#
# class FlayAnimal(Animal):
#     def fly(self):
#         print('%s在飞' % self.name)
# class WalkAnimal(Animal):
#     def walk(self):
#         print('%s在走路' % self.name)
# class SwimAnimal(Animal):
#     def swim(self):
#         print('%s在游泳' % self.name)
#
# class Tiger(SwimAnimal,WalkAnimal):
#     pass
# class Swan(FlayAnimal,WalkAnimal,SwimAnimal):
#     pass
# class Parrot(FlayAnimal,WalkAnimal,):
#     def talk(self):
#         print('%s说话了' % self.name)
#
# swan = Swan('天鹅')
# # swan.talk()
# swan.fly()
# swan.walk()


# 接口类

# java c#
# 不允许多继承
# 接口 Interface 接口可以被多继承

# Interface FlyAnimal: # 规范继承我的类必须实现这个方法
    # def fly(): pass

# Interface WalkAnimal:
    # def walk(): pass

# Interface SwimAnimal:
    # def swim(): pass

# class Tiger(WalkAnimal,SwimAnimal): 继承了一个规范
#   def walk(): 代码
#   def swim(): 代码

# 抽象类
# 接口

# 新式类
# 在python3.x版本中 所有的类都是新式类
# 所有的新式类都有一个默认的父类: object
# class Person1(object):pass
# class Person2:pass
# class Person3():pass
# p = Person() # __init__ 初始化方法
# print(Person1.__bases__)
# print(Person2.__bases__)
# print(Person3.__bases__)

# python2.7
# 经典类 和 新式类
# class Student:pass # 经典类
# class Student(object):pass # 经典类

# 继承了object的类就是新式类
# 在python3中所有的类都是新式类
# 在python3中既有新世类又有经典类

# 多继承的顺序 在新式类和经典类之间的区别
# class A:
#     def func(self):
#         print('A')
# class B(A):
#     pass
#     # def func(self):
#     #     print('B')
# class C(A):
#     pass
#     # def func(self):
#     #     print('C')
# class D(B,C):
#     pass
#     # def func(self):
#     #     print('D')
# print(D.mro())
# d = D()
# d.func()
# 新式类中
    # 在新式类中 所有的多继承关系寻找方法的顺序 - 都遵循广度优先
    # 继承object
    # mro 方法
    # super: super不是单纯的找父类,而是遵循mro顺序的


# class A:
#     def func(self):
#         print('A')
# class B(A):
#     def func(self):
#         super().func()
#         print('B')
# class C(A):
#     def func(self):
#         super().func()
#         print('C')
# class D(B,C):
#     def func(self):
#         super().func()
#         print('D')
#
# D().func()
# print(D.mro())
# B().func()

# 经典类
# python2.x
# 不主动继承object
# 静待鸟类在找父类中方法的过程中 遵循 - 深度优先
# class A(object):
#     pass
#     def func(self):
#         print('A')
# class B(A):
#     pass
#     def func(self):
#         A.func(self)
#         print('B')
# class C(A):
#     pass
#     def func(self):
#         print('C')
# class D(B,C):
#     pass
#     # def func(self):
#     #     print('D')
# D().func()
谢大脚的好朋友
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
笔记02-继承练习
qq_45181415的博客
12-17 1049
问答题【继承】 1.1 请问子类继承父类用什么关键字？ extends 1.2 请问子类继承父类的好处是什么？ 1:可以提升代码的复用性; 2:子类对象可以直接使用父类非私有的属性和方法; 1.3 请问父类的哪些成员不能被子类继承，或者不能被直接访问？ 私有的 1.4 请问子类是否可以同时继承多个父类？ 不可以 问答题【抽象类】 4.1 请问定义抽象类、抽象方法使用的关键字是什么？ abstract 4.2 请问定义抽象类有什么作用？ 1:可以作为设计模式使用;(例如:模板模式) 2:可以通过抽.
java--继承性练习2
qq_42785453的博客
07-31 322
在TestCylinder类中创建Cylinder类的对象，设置圆柱的底面半径和高，并输出圆柱的体积 Circlele -radius：double Circle（）：构造方法，将radius属性初始化为1 +setRadius（double radius）：void +getRadius（）：double +findArea（）：double 计算圆的面积 Cylinder -length：do...
两种代码重用机制——组合与继承
Syes_lei的博客
08-10 1982
java两种代码重用机制——组合与继承
复用与继承
qq_18255935的博客
04-16 590
复用与继承 复合也就是 has-a； 继承就是is-a； 比如：人有一个名字，人也有家庭住址（has-a），但是你不能说人是一个名字，人是一个家庭住址； 再比如：学生类继承自人类（is-a），学生也是人；如果A类pubilc继承于B类，那么A类对象一定是个B类对象，反之不一定成立； 假如有CPerson类，CStudent类，CTeam类； CStudent类继承自CPerson类，CTeam类中...
类的继承部分练习题
Theshy08的博客
11-14 7518
1.定义一个人的类（属性有名字，年龄。写一个能输出各个属性值的方法showInfo（）），定义一个学生类（属性有性别），学生继承人类。 要求：（1）父类的属性赋值用构造方法来实现（分别用有参数构造方法和无参数构造方法实现） （2）子类的属性也用构造方法来赋值。 （3）在子类中重写父类的showInfo（）方法 （4）声明学生类的对象，调用学生的显示信息的方法。 package work1; public class Person { private String name;
c 自定义实现string类 clear_CC++语言15｜类的继承和派生实现代码重用、扩充
weixin_39667626的博客
11-24 115
在C++中，继承是一个对象自动获取其父对象的所有属性和行为的过程。通过继承，您可以重用，扩展或修改在其他类中定义的属性和行为。通过继承，可以实现函数重写以及多态。在C++中，继承另一个类的成员的类称为派生类，其成员被继承的类称为基类。 派生类是基类的子类。继承代表了 is a 关系。例如，哺乳动物是动物，狗是哺乳动物，因此，狗是动物，等等。C++最强大的功能之一就是派生类的使用。通过其类提供类和对...
C++程序_类的继承与派生_
10-01
在C++编程语言中，类的继承与派生是面向对象编程的重要概念，它们使得代码重用和构建复杂的软件结构变得更加高效。在这个“C++程序_类的继承与派生”主题中，我们将深入探讨这两个核心特性。 首先，类是C++中的基本...
C++ 类的继承与派生实例详解
08-30
3.类的继承方式包括：public（公用继承），private（私有继承），protected（受保护的），而不同的继承方式将影响派生类成员的访问属性。 私有继承是另一种继承方式。如果采用私有继承，基类中的访问属性在派生类中...
Java基础教程之接口的继承与抽象类
09-04
Java编程语言中，接口（interface）和抽象类（abstract class）是两种重要的抽象机制，它们在软件设计中扮演着至关重要的角色，提高了代码的可扩展性和重用性。本教程将深入探讨接口的继承与抽象类的相关知识。 ...
类的继承练习_inheritance_类的继承练习_C++_pineoce_
10-02
在C++编程语言中，类的继承是面向对象编程（OOP）的一个核心概念，它允许我们创建一个新类（子类或派生类），该类不仅拥有已存在的类（父类或基类）的特性，还能添加新的特性和功能。这种机制有助于代码重用，降低...
练习3(格式化输出)
Elian ’s Blog
11-30 490
练习3 name = input('请输入姓名：') age = int(input('请输入年龄：')) sex = input('请输入性别：') % 占位符 s 数据类型为字符串 d 数字 第一种方式： msg = '你的名字是%s，你的年龄%d,你的性别%s' % (name,age,sex) print(msg) 第二种方式 msg = '你的名字是%(name1)s，你的年龄%(age1)d,你的性别%(sex1)s' % {'name1':name,'age1':age,'sex1':se
练习9(列表)
Elian ’s Blog
12-09 469
练习9 # 列表：python基础数据类型之一：其他语言中也有列表的概念，js 数组，可索引，可切片，可加步长 li = ['alex', 100, True, [1, 2, 3], {'name':'太白'},(22, 33)] s1 = '[1,2,3]' # 列表可以存储大量的数据32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。 li = ['alex', 100, True, [1, 2, 3], {'name':'
练习11(range)
Elian ’s Blog
12-09 355
练习11 # range 自定制的 数字范围的 可迭代对象 类比成列表 range(1,101) print(range) # range() 一般和for循环结合使用. for i in range(1,11): print(i) for i in range(1,20,2): print(i) for i in range(1,101,2): print(i) for i in range(10,0,-1): print(i) l1 = ['alex','ale
练习10(元组)
Elian ’s Blog
12-09 346
练习10 # 元组：只读列表，只允许查询，不允许增删改 tu1 = ('alex', 100, True, [1, 2, 3], {'name':'太白'},(22, 33)) # 索引，切片，切片+步长 print(tu1[0]) print(tu1[:3]) # # for 循环 for i in tu1: print(i) # index,len,count # 应用场景： 一些非常重要的数据，不允许所有人修改的，放在元组中。 tu1[3].append(666) tu1.ap
练习41(随机数模块)
Elian ’s Blog
12-22 292
练习41 # 随机数模块 import random # 取随机小数 # print(random.random()) # 从0到1 # print(random.uniform(2,3)) # (n,m) # 取随机整数 # print(random.randint(1,2)) # [1,2] # print(random.randrange(1,100)) # [1,2) # print(random.randrange(1,100,2)) # [1,2),步长2 # 从一个列表中随机抽取 #
练习24(函数的嵌套)
Elian ’s Blog
12-14 254
练习24 # def func1(): # print(111) # def func2(): # print(222) # func1() # print(333) # print(666) # func2() # print(555) # 666 222 111 333 555 # def func1(): # print(222) # def func2(): # print(333) # print(111) # f
Python Number(数字)
Elian ’s Blog
11-25 243
PythonPython Number(数字)Python Number 类型转换Python math 模块、cmath 模块Python数学函数Python随机数函数Python三角函数Python数学常量 Python Number(数字) Python Number 数据类型用于存储数值。 数据类型是不允许改变的,这就意味着如果改变 Number 数据类型的值，将重新分配内存空间。 以下实例在变量赋值时 Number 对象将被创建： var1 = 1 var2 = 10 您也可以使用del语句删除
练习2(while作业)
Elian ’s Blog
12-02 210
练习2 #使用while循环输出 1 2 3 4 5 6 8 9 10 num = 1 while num < 11: if num == 7: num += 1 print(num) num += 1 # 求1-100的所有数的和（三种方法） # 第一种 num = 1 sum = 0 while num < 101: sum = sum + num num += 1 print(sum) # 第二种 wh
Python for 循环语句
Elian ’s Blog
11-24 192
PythonPython for 循环语句通过序列索引迭代循环使用 else 语句 Python for 循环语句 Python for循环可以遍历任何序列的项目，如一个列表或者一个字符串。 语法： for循环的语法格式如下： for iterating_var in sequence: statements(s) #!/usr/bin/python # -*- coding: UTF-8 -*- for letter in 'Python': # 第一个实例 print '当前
C++继承与派生：理解基类和Employee类的创建
基类（Base Class）和派生类（Derived Class）是类与类之间的关系，通过继承机制，派生类能够复用和扩展基类的属性和行为。 首先，基类是创建新类时的基础模板，提供了一组通用的功能和数据成员。在这个例子中，`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值