L6-14 继承多态

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

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

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

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

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

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

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

减少类与类之间代码冗余

class ParentClass1: #定义父类
    pass
 
class ParentClass2: #定义父类
    pass
 
class SubClass1(ParentClass1): #单继承，基类是ParentClass1，派生类是SubClass
    pass
 
class SubClass2(ParentClass1,ParentClass2): #python支持多继承，用逗号分隔开多个继承的类
    pass

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

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

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

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

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

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

 例如：动物有多种形态：人，狗，猪

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

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

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

# 父类
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)

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

#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.多态就是指，对于同一个事物，可以有同名的两个或者多个方法，
#  一起调用，得到不同的结果。