python语法基础之面向对象3：继承

继承

例子： 

"""继承"""
class Animal():
    def eat(self):
        print('--吃--')
    def drink(self):
        print('--喝--')
    def sleep(self):
        print('--睡--')
    def run(self):
        print('--跑')

class Dog(Animal):
    """添加了Dog类，继承了Aniaml类"""
    def bark(self):
        print('--汪汪--')

class Cat(Animal):
    """添加了Cat类，继承了Aniaml类"""
    def catch(self):
        print('--抓老鼠--')

a=Animal()
a.drink()

wangcai=Dog()
wangcai.sleep()

tom=Cat()
tom.eat()

D:\Anaconda\python.exe E:/pythonwork/黑马/面向对象.py
--喝--
--睡--
--吃--

Process finished with exit code 0

 

子类继承父类、父类的父类

"""继承"""
class Animal():
    def eat(self):
        print('--吃--')
    def drink(self):
        print('--喝--')
    def sleep(self):
        print('--睡--')
    def run(self):
        print('--跑')

class Dog(Animal):
    def bark(self):
        print('--汪汪--')
class xiaotian(Dog):
    """添加一个类，继承了Dog类，也继承了Animal类"""
    def fly(self):
        print('--飞---')


# class Cat(Animal):
#     def catch(self):
#         print('--抓老鼠--')

# a=Animal()
# a.drink()

wangcai=Dog()
wangcai.sleep()

# tom=Cat()
# tom.eat()

xiaotianquan=xiaotian()
xiaotianquan.fly()#调用自己的方法
xiaotianquan.bark()#调用父类Dog的方法
xiaotianquan.eat()#调用父类的父类Animal的方法

D:\Anaconda\python.exe E:/pythonwork/黑马/面向对象.py
--睡--
--飞---
--汪汪--
--吃--

Process finished with exit code 0

在子类中重写父类的方法

"""继承"""
class Animal():
    def eat(self):
        print('--吃--')
    def drink(self):
        print('--喝--')
    def sleep(self):
        print('--睡--')
    def run(self):
        print('--跑')

class Dog(Animal):
    def bark(self):
        print('--汪汪--')
class xiaotian(Dog):
    """添加一个类，继承了Dog类，也继承了Animal类"""
    def fly(self):
        print('--飞---')
    def bark(self):#自身定义了一个父类的方法，在子类中对父类的方法进行重写
        print('--狂叫--')


# class Cat(Animal):
#     def catch(self):
#         print('--抓老鼠--')

# a=Animal()
# a.drink()

wangcai=Dog()
wangcai.sleep()

# tom=Cat()
# tom.eat()

xiaotianquan=xiaotian()
xiaotianquan.fly()#调用自己的方法
xiaotianquan.bark()#如果自身有这个方法，就调用自身的方法。如果自身没有就调用父类Dog的方法
xiaotianquan.eat()#调用父类的父类Animal的方法

在子类中调用被重写的父类的方法（两种方法）

第一种方法：   类名.方法名（self）             【类名：可父类可子类，再找相对应的方法调用】

如果自身有这个方法，先调自身的，打印出来，再执行    类名.方法名（self）   调（父类）的方法打印出来。

注意：在子类中调用被重写的父类的方法时，需要传递代表自身的self，否则会报错的

"""继承"""
class Animal():
    def eat(self):
        print('--吃--')
    def drink(self):
        print('--喝--')
    def sleep(self):
        print('--睡--')
    def run(self):
        print('--跑')

class Dog(Animal):
    def bark(self):
        print('--汪汪--')
class xiaotian(Dog):
    """添加一个类，继承了Dog类，也继承了Animal类"""
    def fly(self):
        print('--飞---')
    def bark(self):#自身定义了一个父类的方法，在子类中对父类的方法进行重写
        print('--狂叫--')

        """第一种在子类中调用父类的方法"""
        Dog.bark(self)

wangcai=Dog()

xiaotianquan=xiaotian()
xiaotianquan.fly()#调用自己的方法
xiaotianquan.bark()#如果自身有这个方法，就调用自身的方法,再执行Dog.bark(self)调用父类的Dog方法

D:\Anaconda\python.exe E:/pythonwork/黑马/面向对象.py
--飞---
--狂叫--
--汪汪--
--吃--

Process finished with exit code 0

第二种方法：super().bark()

"""继承"""
class Animal():
    def eat(self):
        print('--吃--')
    def drink(self):
        print('--喝--')
    def sleep(self):
        print('--睡--')
    def run(self):
        print('--跑')

class Dog(Animal):
    def bark(self):
        print('--汪汪--')
class xiaotian(Dog):
    """添加一个类，继承了Dog类，也继承了Animal类"""
    def fly(self):
        print('--飞---')
    def bark(self):#自身定义了一个父类的方法，在子类中对父类的方法进行重写
        print('--狂叫--')

        # """第一种在子类中调用父类的方法"""
        # Dog.bark(self)
        """第二种在子类中调用父类的方法"""
        super().bark()

wangcai=Dog()

xiaotianquan=xiaotian()
xiaotianquan.fly()#调用自己的方法
xiaotianquan.bark()#如果自身有这个方法，就调用自身的方法,再执行Dog.bark(self)调用父类的Dog方法

D:\Anaconda\python.exe E:/pythonwork/黑马/面向对象.py
--飞---
--狂叫--
--汪汪--

Process finished with exit code 0

私有方法、私有属性在继承中的表现

1、私有的属性和方法并不会被继承，只要是私有的东西就不会被继承的，也就是不能在子类中使用父类中的私有方法和私有属性。

2、私有的属性和方法只能在定义它们的类中公开一个方法里面调用，不能在子类中使用父类中的私有方法和私有属性。

多继承

所谓多继承，即子类有多个父类，并且具有它们的特征。python是可以多继承的，父类中的方法、属性，子类会继承。object类是所有类的基类，下面的object写与不写是一样的。

"""多继承"""
class Base():
    def test(self):
        print('--base')

class A(Base):
    def test(self):
        print('--A')

class B(Base):
    def test(self):
        print('--B')

class C(B,A):
    def test(self):
        print('--C')

c=C()
#c.test() #如果方法名一样，优先调用自身的方法
c.test()  #如果子类没有方法，而继承的多个父类中有相同的方法名时，继承时 谁在前，就调用谁的方法
print(C.__mro__) #C3算法，查看搜索顺序

结果：

D:\Anaconda\python.exe E:/pythonwork/黑马/面向对象.py
--C
(<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class '__main__.Base'>, <class 'object'>)

Process finished with exit code 0

多态 

多态的概念是应用于Java和C#这一类强类型语言中，而Python崇尚“鸭子类型”。

所谓多态：定义时的类型和运行时的类型不一样，此时就成为多态。

• Python伪代码实现Java或C#的多态

class F1(object):
    def show(self):
        print 'F1.show'

class S1(F1):
    def show(self):
        print 'S1.show'

class S2(F1):
    def show(self):
        print 'S2.show'

# 由于在Java或C#中定义函数参数时，必须指定参数的类型
# 为了让Func函数既可以执行S1对象的show方法，又可以执行S2对象的show方法，所以，定义了一个S1和S2类的父类
# 而实际传入的参数是：S1对象和S2对象

def Func(F1 obj):
    """Func函数需要接收一个F1类型或者F1子类的类型"""

    print obj.show()

s1_obj = S1()
Func(s1_obj) # 在Func函数中传入S1类的对象 s1_obj，执行 S1 的show方法，结果：S1.show

s2_obj = S2()
Func(s2_obj) # 在Func函数中传入Ss类的对象 ss_obj，执行 Ss 的show方法，结果：S2.show

• Python “鸭子类型”

class F1(object):
    def show(self):
        print 'F1.show'

class S1(F1):

    def show(self):
        print 'S1.show'

class S2(F1):

    def show(self):
        print 'S2.show'

def Func(obj):
    print obj.show()

s1_obj = S1()
Func(s1_obj) 

s2_obj = S2()
Func(s2_obj)

类属性、实例属性

在了解了类基本的东西之后，下面看一下python中这几个概念的区别

先来谈一下类属性和实例属性

在前面的例子中我们接触到的就是实例属性（对象属性），顾名思义，类属性就是类对象所拥有的属性，它被所有类对象的实例对象所共有，在内存中只存在一个副本，这个和C++中类的静态成员变量有点类似。对于公有的类属性，在类外可以通过类对象和实例对象访问

类属性

class People(object):
    name = 'Tom'  #公有的类属性
    __age = 12     #私有的类属性

p = People()

print(p.name)           #正确
print(People.name)      #正确
print(p.__age)            #错误，不能在类外通过实例对象访问私有的类属性
print(People.__age)        #错误，不能在类外通过类对象访问私有的类属性

实例属性(对象属性)

class People(object):
    address = '山东' #类属性
    def __init__(self):
        self.name = 'xiaowang' #实例属性
        self.age = 20 #实例属性

p = People()
p.age =12 #实例属性
print(p.address) #正确
print(p.name)    #正确
print(p.age)     #正确

print(People.address) #正确
print(People.name)    #错误
print(People.age)     #错误

通过实例(对象)去修改类属性

class People(object):
    country = 'china' #类属性


print(People.country)
p = People()
print(p.country)
p.country = 'japan' 
print(p.country)      #实例属性会屏蔽掉同名的类属性
print(People.country)
del p.country    #删除实例属性
print(p.country)

总结

• 如果需要在类外修改类属性，必须通过类对象去引用然后进行修改。如果通过实例对象去引用，会产生一个同名的实例属性，这种方式修改的是实例属性，不会影响到类属性，并且之后如果通过实例对象去引用该名称的属性，实例属性会强制屏蔽掉类属性，即引用的是实例属性，除非删除了该实例属性。

• class Tool(object):
  
      #类属性
      num = 0
  
      #方法
      def __init__(self, new_name):
          #实例属性
          self.name = new_name
          #对类属性+=1
          Tool.num += 1
  
  
  tool1 = Tool("铁锹")
  tool2 = Tool("工兵铲")
  tool3 = Tool("水桶")
  
  print(Tool.num)
  

  D:\Anaconda\python.exe "D:/黑马/python就业班上（剩余部分加微信VR365666）/01基础/第2节 python语法基础/08.面对对象-2/源码/14-类属性-实例属性.py"
  3
  
  Process finished with exit code 0
  

静态方法和类方法

1. 类方法

是类对象所拥有的方法，需要用修饰器@classmethod来标识其为类方法，对于类方法，第一个参数必须是类对象，一般以cls作为第一个参数（当然可以用其他名称的变量作为其第一个参数，但是大部分人都习惯以'cls'作为第一个参数的名字，就最好用'cls'了），能够通过实例对象和类对象去访问。

class People(object):
    country = 'china'

    #类方法，用classmethod来进行修饰
    @classmethod
    def getCountry(cls):
        return cls.country

p = People()
print p.getCountry()    #可以用过实例对象引用
print People.getCountry()    #可以通过类对象引用

类方法还有一个用途就是可以对类属性进行修改：

class People(object):
    country = 'china'

    #类方法，用classmethod来进行修饰
    @classmethod
    def getCountry(cls):
        return cls.country

    @classmethod
    def setCountry(cls,country):
        cls.country = country


p = People()
print p.getCountry()    #可以用过实例对象引用
print People.getCountry()    #可以通过类对象引用

p.setCountry('japan')   

print p.getCountry()   
print People.getCountry()

结果显示在用类方法对类属性修改之后，通过类对象和实例对象访问都发生了改变

2. 静态方法

需要通过修饰器@staticmethod来进行修饰，静态方法不需要多定义参数

class People(object):
    country = 'china'

    @staticmethod
    #静态方法
    def getCountry():
        return People.country


print(People.getCountry())

总结

从类方法和实例方法以及静态方法的定义形式就可以看出来，类方法的第一个参数是类对象cls，那么通过cls引用的必定是类对象的属性和方法；而实例方法的第一个参数是实例对象self，那么通过self引用的可能是类属性、也有可能是实例属性（这个需要具体分析），不过在存在相同名称的类属性和实例属性的情况下，实例属性优先级更高。静态方法中不需要额外定义参数，因此在静态方法中引用类属性的话，必须通过类对象来引用

class Game(object):

    #类属性
    num = 0

    #实例方法
    def __init__(self):
        #实例属性
        self.name = "laowang"

    #类方法
    @classmethod
    def add_num(cls):
        cls.num = 100

    #静态方法
    @staticmethod
    def print_menu():
        print("----------------------")
        print("    穿越火线V11.1")
        print(" 1. 开始游戏")
        print(" 2. 结束游戏")
        print("----------------------")

game = Game()
#Game.add_num()#可以通过类的名字调用类方法
game.add_num()#还可以通过这个类创建出来的对象 去调用这个类方法
print(Game.num)

#Game.print_menu()#通过类 去调用静态方法
game.print_menu()#通过实例对象 去调用静态方法

D:\Anaconda\python.exe "D:/黑马/python就业班上（剩余部分加微信VR365666）/01基础/第2节 python语法基础/08.面对对象-2/源码/15-实例方法-类方法-静态方法.py"
100
----------------------
    穿越火线V11.1
 1. 开始游戏
 2. 结束游戏
----------------------

Process finished with exit code 0