L6-14 继承多态

一、课程导入

上节课我们初步学习了面向对象编程的特点,我们可以将一些代码封装在一起,反复使用,这样提高了编写程序的效率。

封装、继承和多态是面向对象编程的三大特征。

学习了封装的强大功能, 你是不是很想了解继承 和多态的作用呢?

二、继承

1.什么是继承

  1.1 在现实的世界中

人们可以从他们的父母那里继承一些东西,例如黑头发、黄皮肤或者继承一些财产之类的东西。

  1.2 在面向对象编程中

一个类从其他的类那里继承属性和方法,这样就有了类的整个家族;
在这个家族中,每个类共享相同的属性和方法。

总结:

1.继承是一种创建新类的方式

2.新建的类可以创建一个或多个父类,父类有称为基类或者超类

3.新建的类称为派生类或者子类

在python中类的继承分为:单继承或多继承

2. python中继承的特点:

1. 子类可以遗传/重用父类的属性
2. python中一个子类可以同时继承多个父类

3.为何要用继承

减少类与类之间代码冗余

4.如何用继承

4.1

class ParentClass1: #定义父类
    pass

class ParentClass2: #定义父类
    pass

class SubClass1(ParentClass1): #单继承,基类是ParentClass1,派生类是SubClass
    pass

class SubClass2(ParentClass1,ParentClass2): #python支持多继承,用逗号分隔开多个继承的类
    pass

4.2

class Dog(): #定义一个父类Dog,类名后加上括号
    pass
class Too(Dog):#将类名Dog放入子类Ted括号中
    pass
class Loo(Dog):#将类名Dog放入子类Ted括号中
    pass

# Dog是被继承的类,它是父类,Too和Loo是子类,可以从父类哪里继承一些属性和方法。
# pass在此位置相当于占位的,如果不写东西会报错

4.3 试一试

class Dog:#定义一个父类
    def eat(self):
        print("吃点东西")
class Too(Dog):#将父类的类名放入子类Too括号中
    def ok(self):
        print("好呀!")
class Loo(Dog):#将父类的类名放入子类Loo括号中
    def yeah(self):
        print("嗯嗯!")
lala=Too ()
HaHa = Loo()
lala.eat()
lala.ok()
HaHa.eat()
HaHa.yeah()

4.4 为父类添加基本上属性

class Dog:#定义一个父类
    # 创建构造方法,增加name值
    def __init__(self,name):
        self.name=name
    def eat(self):
        print("吃点东西")
class Too(Dog):#将父类的类名放入子类Too括号中
    def ok(self):
        print("好呀!")
class Loo(Dog):#将父类的类名放入子类Loo括号中
    def yeah(self):
        print("嗯嗯!")
lala=Too ("大黄") # 创建对象时需提供相对应的实参
HaHa = Loo("旺财")
lala.eat()
lala.ok()
HaHa.eat()
HaHa.yeah()

总结:在上述例子中,子类继承父类的属性和方法,在子类中定义了方法,那是否可以为子类增加属性呢?

5.绑定类的初始化方法

class Dog():
    def __init__(self,name):
        self.name = name
    def eat(self):
        print("吃点东西")
class Too(Dog):
    def __init__(self,name,hair):
        Dog.__init__(self,name)
        self.hair = hair  # 给子类Too定义属性hair,Too类创建的对象都会有属性hair
    def ok(self):
        print("好呀!")
lala=Too("大黄","黄色") # 传入两个参数
lala.eat()
lala.ok()
# 如果要给予子类增加属性,应当显示调用父类的初始化方法,将父类与子类关联在一起。

细讲:

def __init__(self,name,hair):
        Dog.__init__(self,name)
        self.hair = hair

第一行代码,在子类__init__()方法中先写来自父类的属性name,后面添加上子类新的属性hair,

第二行代码用来将父类和子类关联在一起,这样不用重写父类的属性变量self.name,

子类Too实例化对象会包含父类的所有属性,

第三行写上新的属性变量self.hair。

6.实例

class Animal:      #父类  基类  超类
    def __init__(self,name,life_value,aggr):
        self.name= name
        self.life_value = life_value
        self.aggr = aggr  #攻击力
    def eat(self):
        self.life_value += 10  #谁调谁的血量就增加

class Person(Animal):  #子类  派生类
    def __init__(self, money, name, life_value, aggr):
        super().__init__(name, life_value, aggr)
        self.money = money  #派生出来的一个属性
    def attack(self,enemy):    #人的派生方法
        #enemy.life_value = enemy.life_value - self.aggr
        enemy.life_value -= self.aggr

class Dog(Animal): #子类  派生类
    def __init__(self,name,breed, life_value,aggr):
        # Animal.__init__(self,name,breed, life_value,aggr)#让子类执行父类的方法 就是父类名.方法名(参数),连self都得传
        super().__init__(name,life_value,aggr) #super关键字  ,都不用传self了,在新式类里的
        # super(Dog,self).__init__(name,life_value,aggr)  #上面super是简写
        self.breed = breed
    def bite(self,person):   #狗的派生方法
        person.life_value -= self.aggr
    def eat(self):  #父类方法的重写
        super().eat()
        print(‘dog is eating‘)

# ha2 = Dog(‘旺财‘,‘哈士奇‘,20000,100)
# egg = Person(‘egon‘,500,1000,50)
# print(egg.aggr)
# print(ha2.aggr)
# egg.eat()
# print(egg.life_value)
#
# egg.eat()
# print(egg.life_value)
#
# ha2.eat()
# print(ha2.life_value)
#
# print(egg.life_value)
# ha2.bite(egg)
# print(egg.life_value)
#

ha2 = Dog(‘牛头梗‘,‘旺财‘,20000,100)
print(ha2.life_value)
ha2.eat()  #如果父类有的方法子类里面也有,那么就叫做方法的重写,就不执行父类的了,去执行子类了
print(ha2.life_value)

super(Dog,ha2).eat() #生掉父类的方法,但是不推荐这样用
print(ha2.life_value)

#在继承中,如果子类有的方法就执行子类的
# 如果子类没有的方法就执行父类的

实现调用父类的方法

三、多态

1.什么是多态

多态指的是一类事物有多种形态(比如:老师.下课铃响了(),
学生.下课铃响了(),老师执行的是下班操作,学生执行的是放学操作,
虽然二者消息一样,但是执行的效果不同)
 例如:动物有多种形态:人,狗,猪

在面向对象编程时,对于同一个事物,可以有同名的两个或者多个方法,用一种调用方式,能够得到不同的结果,这就是多态。

总结:多态指的是同一种/类事物的不同形态

2.为何要用多态

多态性:在多态的背景下,可以在不用考虑对象具体类型的前提下而直接使用对象
多态性的精髓:统一

3.如何用多态

3.1

# 父类
class Animal:
    def speak(self):
        pass
# 子类
class People(Animal):
    def speak(self):
        print(‘say hello‘)
# 子类
class Dog(Animal):
    def speak(self):
        print(‘汪汪汪‘)
# 子类
class Pig(Animal):
    def speak(self):
        print(‘哼哼哼‘)

# 产生三个对象
p1=People()
p2=Dog()
p3=Pig()

# 定义统一技能的接口
def speak(animal):
    animal.speak()

# 由于继承了父类,都具有speak方法
speak(p1)
speak(p2)
speak(p3)

3.2 假设要设计程序,计算不同形状的面积,比如三角 形,长方形,可以创建两个类,用一种方法调用。

class Triangle:
    def __init__(self,width,height):
        self.width = width
        self.height = height
    def getArea(self):
        area = self.width*self.height / 2.0
        print(area)
class Square:
    def __init__(self,size):
        self.size = size
    def getArea(self):
        area = self.size*self.size
        print(area)
myTriangle = Triangle(4,5)
mySquare = Square(10)
myTriangle.getArea()
mySquare.getArea()

在计算两个形状的面积时,都 采用了getArea ()这个方法。

四、动手实践

大鱼吃小鱼是非常经 典的一款小游戏,现 在来模拟下,实现小 鱼和鲨鱼的几个动作。

分析:

代码:

#1.利用学习过的随机模块,获得父类Fish的位置
import random
class Fish:
    def __init__(self):
        self.x = random.randint(0,50)
        self.y = random.randint(0,50)
    def move(self):
        print("我的位置是:",self.x,self.y)
#2.暂时先不考虑金鱼的移动方向等问题
class Goldfish(Fish):
    pass
#获得父类的方法,定义一个eat方法
class Shark(Fish):
    def __init__(self):
        Fish.__init__(self)
        self.hungry = True
    def eat(self):
        if self.hungry:
            print("吃货的梦想就是天天有吃的,哈哈")
            self.hungry = False
        else:
            print("太撑了,吃不下")
#3.实例化小鱼goldfish和鲨鱼shark,并调用方法
goldfish = Goldfish()
goldfish.move()
shark = Shark()
shark.eat()
shark.eat()
shark.move()

五、总结

# 1.在面向对象编程中,一个类从其他的类那里继承属性和方法,
#   这样就有了类的整个家族;在这个家族中,每个类共享相同的属性和方法。
# 2.如果父类构造函数初始化了一些属性,子类不显式调用父类的构造方法,就会报错。
# 3.多态就是指,对于同一个事物,可以有同名的两个或者多个方法,
#  一起调用,得到不同的结果。

原文地址:https://www.cnblogs.com/xiaoxiao-ya/p/11954475.html

时间: 2024-10-13 21:56:32

L6-14 继承多态的相关文章

No2_4.接口继承多态_Java学习笔记_经典案例

1 import java.util.ArrayList; 2 import java.util.Collections; 3 import java.util.List; 4 5 /** 6 * @title 接口继承多态的经典范例 7 * @author 作者:sunshine yaqingl 8 * @date 创建时间:2016年7月6日 下午5:27:39 9 */ 10 11 //使用Comparable接口自定义排序 12 class Employee implements Com

php面向对象 封装继承多态 接口、重载、抽象类、最终类总结

1.面向对象 封装继承多态  接口.重载.抽象类.最终类 面向对象 封装继承多态  首先,在解释面向对象之前先解释下什么是面向对象? [面向对象]1.什么是类? 具有相同属性(特征)和方法(行为)的一系列个体的集合,类是一个抽象的概念2.什么是对象?从类中拿到的具有具体属性值得个体,称为对象,对象是一个具体的个体 所以,面向对象即我们专注对象来处理问题,通过从一个个具有属性和功能的类中拿到对象来处理问题. 下面我们再来细说下面向对象的三大特征:继承/封装/多态 一.继承 在PHP中我们主要通关E

OOP三大核心封装继承多态

OOP支柱 3 个核心:封装 继承 多态 封装就是将实现细节隐藏起来,也起到了数据保护的作用. 继承就是基于已有类来创建新类可以继承基类的核心功能. 在继承中 另外一种代码重用是:包含/委托,这种重用不是父子类的继承关系,而是一个类定义为另一个类的成员变量. 一个简单的例子,汽车和收音机,汽车里面有一个收音机,不能说继承,不符合逻辑,只能说是一种对象包含了另一个对象.汽车对象中调用了收音机对象中的方法. 多态就是同一请求,不同的响应操作. 多态 同一种方式处理相关对象的能力. 相同的请求操作不同

封装继承多态到底讲的是什么

封装继承多态到底讲的是什么 封装.继承.多态并不是针对C#语言提出来的,他是一个在面向对象思想下产生的一个概念.所以想要弄明白封装.继承.多态,首先就要先了解面向对象概念. 封装:当我们提及面向对象的时候,这个对象怎么来?就是通过我们人为的封装得来.封装就是把一些特征或功能组合到一个抽象的对象上.就比如说电脑:它的特征是有一个显示屏,有一个主机,有鼠标和键盘等等.功能有计算等.那我们把这些特征和功能组合到“电脑”这个抽象的名词上时,“电脑”于是就有了这些特征和功能.但这个“电脑”不是实物,它代表

(1) 深入理解Java面向对象三大特性 封装 继承 多态

转眼已经工作快6年了,最开始做了2年J2EE:然后整了2年的数据仓库,主要是Cognos的报表开发:现在从事4G LTE核心网的开发,用的语言任然是Java,但写代码的机会不多,基本都是看代码找BUG,偶尔做点new feature也是在比较成熟的框架上复制.粘贴.修改,大部分时间还是在理解业务,钱多.事少.离家近,当时来这家公司图的是后面2点,2年过去了,英文水平有所提升,对敏捷开放也有一定的了解,但技术方面明显退步了或者说没有进步吧,本来以前也不怎么好,因为工作上用不到,自己也没怎么学习,所

java基础之【继承--->多态】内存图

执行流程 1:Animal a = new Cat(); 1.1:在栈中创建区域,类型为Animal,变量名:a; 1.2:在堆中new Cat();占用一块区域.地址值:[0x3a4] 1.3:spuer()实例化父类Animal. 1.3.1:new Animal();占用一块区域,地址值:0x3ab; 1.3.2:引用着在方法区中初始化[Animal中的所有方法,该引用为:[0x754]]. 1.3.3:将Animal()引用赋给spuer();spuer引用着Animal(); 1.4:

三大特性:封装,继承,多态

透切理解面向对象三大基本特性是理解面向对象五大基本原则的基础. 三大特性是:封装,继承,多态 所谓封装: 也就是把客观事物封装成抽象的类,并且类可以把自己的数据和方法只让可信的类或者对象操作,对不可信的进行信息隐藏.封装是面向对象的特征之一,是对象和类概念的主要特性. 简单的说,一个类就是一个封装了数据以及操作这些数据的代码的逻辑实体.在一个对象内部,某些代码或某些数据可以是私有的,不能被外界访问.通过这种方式,对象对内部数据提供了不同级别的保护,以防止程序中无关的部分意外的改变或错误的使用了对

初识JAVA(【面向对象】:pub/fri/pro/pri、封装/继承/多态、接口/抽象类、静态方法和抽象方法;泛型、垃圾回收机制、反射和RTTI)

JAVA特点: 语法简单,学习容易 功能强大,适合各种应用开发:J2SE/J2ME/J2EE 面向对象,易扩展,易维护 容错机制好,在内存不够时仍能不崩溃.不死机 强大的网络应用功能 跨平台:JVM,字节码 两个命令: javac helloworld.java:将Java文件编译为字节码的.class文件 java helloworld:运行Java程序...??暂时这么认为 数据类型: 普通数据类型:int a=3; 对象数据类型:使用关键字new,String s=new String("

面向对象的三大特性---封装继承多态

面向对象的三大特性---封装继承多态 首先我们来创建一个控制台程序 新建一个父类Person 创建一个子类继承父类Person 子类: main函数: 输出结果: 根据结果显示创建子对象,首先调用父类的构造函数在调用子类的构造函数. 继承的传递性 例如: A:B,B:C,则A:C ⅰ.继承过来之后被隐藏,有意隐藏加一个关键字"new",如果加了关键字"new",就告诉子类,父类里面的sayHi只能被隐藏,不能被覆写  ⅱ.继承过来之后被覆写/重写,覆写需要在父类里面

类与对象 面向对象和面向过程对比 面向对象三大特征:封装 继承 多态

 初识面向对象 面向过程: 一切以事务的发展流程为中心. 面向对象: 一切以对象为中心. 一切皆为对象. 具体的某一个事务就是对象 打比方: 大象进冰箱 步骤: 第一步, 开门, 第二步, 装大象, 第三步, 关门 面向对象:大象, 你进冰箱. 此时主语是大象. 我操纵的是大象. 此时的大象就是对象 1. 面向过程: 一切以事物的流程为核心. 核心是"过程"二字, 过程是指解决问题的步骤, 即, 先?干什么, 后干什么. 基于该思想编写程序就好比在编写一套流水线. 是一种机械 式的编程