python关于继承、多态的知识学习

一、继承

面向对象三大特征：

1、封装： 根据职责将属性和方法封装到一个抽象的类中

2、继承： 实现代码的重用，相同的代码不需要重复的写

3、多态： 不同的对象调用相同的方法，产生不同的结果，增加代码的灵活度

(1)私有属性和私有方法

私有属性就是对象不希望公开的属性

私有方法就是对象不希望公开的方法

定义方法： 在定义属性或方法时，在属性名或者方法名前增加__(两个下划线)

1、

class Women():

def __init__(self,name):

self.name = name

self.age = 18

def secret(self):

print '%s 的年龄是 %d' %(self.name,self.age)

lily =Women('lily')

print lily.age

lily.secret()

2、

class Women():

def __init__(self,name):

self.name = name

self.__age = 18 #私有属性,在外界不允许被访问

def __secret(self): #私有方法，在外界不允许被访问

print '%s 的年龄是 %d' %(self.name,self.__age)

lily =Women('lily')

print lily.age

lily.__secret()

3、

父类的私有属性和私有方法

1、子类对象不能在自己的方法内部，直接访问父类的私有属性和私有方法

2、子类对象可以通过父类的公有方法间接访问到私有属性或私有方法

私有属性，私有方法是对象的隐私，不对外公开，外界以及子类都不能直接访问

私有属性，私有方法常用作一些内部的事情

"""

class A(object):

def __init__(self):

# 在初始化方法中定义了两个属性，一个公有属性，一个私有属性

self.num1 = 100

self.__num2 = 200

# 定义私有方法

def __test(self):

print '私有方法%d %d'%(self.num1,self.__num2)

class B(A):

pass

# 创建一个子类对象

b=B()

# 虽然B继承了A在外界不能直接访问对象的私有属性/调用私有方法

print b.__num2

b.__test

4、

class A(object):

def __init__(self):

# 在初始化方法中定义了两个属性，一个公有属性，一个私有属性

self.num1 = 100

self.__num2 = 200

# 定义私有方法

def __test(self):

print '私有方法%d %d'%(self.num1,self.__num2)

class B(A):

def demon(self):

# 在子类的方法中，不能访问父类的私有属性

print '访问父类的私有属性%d' % self.__num2

self.__test()

pass

# 创建一个子类对象

b=B()

b.test()

5、

class A(object):

def __init__(self):

# 在初始化方法中定义了两个属性，一个公有属性，一个私有属性

self.num1 = 100

self.__num2 = 200

# 定义私有方法

def __test(self):

print '私有方法%d %d'%(self.num1,self.__num2)

def test(self):

print '%d' %self.__num2

self.__test()

class B(A):

def demon(self):

# 在子类的方法中，不能访问父类的私有属性

print '访问父类的私有属性%d' % self.__num2

self.test() # 可以访问公有方法

pass

# 创建一个子类对象

b=B()

print b

b.test()

(2)单继承

1、继承的概念：子类拥有父类的所有方法和属性(子类只需封装自己特有的方法和属性)

c类从b类继承，b类又从a类继承，那么c类就具有b类和a类的所有属性和方法

继承的语法

class 类名(父类)

def 子类特有的方法

1、

class Animal():

def eat(self):

print '吃'

def drink(self):

print '喝'

class Cat(Animal):

def call(self):

print 'hehe'

pangzi = Cat()

pangzi.call()

pangzi.eat()

pangzi.drink()

2、

class Animal():

def eat(self):

print '吃'

def drink(self):

print '喝'

class Cat(Animal):

def call(self):

print '点点滴滴'

class Dingdangmao(Cat):

def speak(self):

print '我可以以实现你所有梦想'

pangzi = Dingdangmao()

pangzi.call()

pangzi.eat()

pangzi.drink()

pangzi.speak()

3、

重写父类方法有两种情况：

1、覆盖父类的方法

2、对弗雷方法进行扩展

1、覆盖父类的方法

如果在开发中，父类的方法的实现和子类方法法的实现，完全不同，就可以

使用覆盖的方式在子类中重新编写父类的方法

具体实现方式，就相当于在子类中定义了一个和父类同名的方法并且实现

重写后，在运行时，只会调用子类的重写方法，而不会在调用父类封装的方法

"""

class Animal():

def eat(self):

print '吃'

def drink(self):

print '喝'

class Cat(Animal):

def call(self):

print 'hehe'

def drink(self):

print 'xixi'

pangzi = Cat()

# 如果子类中，重写了父类的方法

# 在运行中，只会调用子类中重写的方法，不会调用父类的方法

pangzi.call()

pangzi.eat()

pangzi.drink()

4、

class Animal():

def eat(self):

print '吃'

def drink(self):

print '喝'

class Cat(Animal):

def call(self):

print 'hehe'

def drink(self):

print 'xixi'

Animal.drink(self)

pangzi = Cat()

pangzi.call()

pangzi.eat()

pangzi.drink()

5、对父类的方法进行扩展

如果在开发中，子类的方法实现包含父类的方法实现(父类原本封装的方法实现是子类方法的一部分)就可以使用

扩展方法

【1】在子类中重写父类的方法

【2】在需要的位置使用 (父类名.方法(self))来调用父类方法进行

【3】代码其他位置针对子类的需求，编写子类特有的代码实现

class Dog():

def __init__(self):

self.hunger = True

def eat(self):

if self.hunger:

print 'aaaaaaa'

self.hunger = False

else:

print 'no'

class Cutedog(Dog):

def __init__(self): #由于此处有继承，则会覆盖掉父类

self.sound = 'lalala'

Dog.__init__(self) #此处出现调用父类，则为父类的扩展则不会被覆盖

def sing(self):

print self.sound

dog = Dog()

dog.eat()

heimao = Cutedog()

heimao.eat()

heimao.sing()

6、旧式类(经典类)在python3之前的版本此类表示没有继承

新式类 继承了object基类

class A():# 旧式类(经典类)在python3之前的版本此类表示没有继承

def test(self):

print 'testA'

class B(object): # 新式类 继承了object基类

def demon(self):

print 'demonB'

#########################################################

在ipython中

In [1]: class A(object):

...: pass

...:

In [2]: a = A()

In [3]: dir(a)

Out[3]:

['__class__',

'__delattr__',

'__dict__',

'__doc__',

'__format__',

'__getattribute__',

'__hash__',

'__init__',

'__module__',

'__new__',

'__reduce__',

'__reduce_ex__',

'__repr__',

'__setattr__',

'__sizeof__',

'__str__',

'__subclasshook__',

'__weakref__']

In [5]: class B():

...: pass

...:

In [6]: b =B()

In [7]: dir(b)

Out[7]: ['__doc__', '__module__']

#######################################################

(3)多继承

1、

多继承

子类拥有一个父类叫做

"""

class A():

def test(self):

print 'testA'

class B():

def demon(self):

print 'demonB'

class C():

def haha(self):

print 'hahaC'

class D(A,B,C):

pass

d=D()

d.test()

d.demon()

d.haha()

2、

class A():

def test(self):

print 'testA'

def demon(self):

print 'demonA'

class B():

def demon(self):

print 'demonB'

class C():

def haha(self):

print 'hahaC'

class D(A,B,C): #当继承多个类中出现了相同的属性时按照继承顺序来排在前面的写

pass

d=D()

d.test()

d.demon()

d.haha()

二、多态

1、封装：根据职责将属性和方法封装到一个抽象的类中

定义类的准则

2、继承：实现代码的重用，相同的代码不需要重复的编写

设计类的技巧

子类针对自己特有的需求，编写特定的代码

3、多态

不同的子类(这是之前提到的继承的知识)

对象调用相同的方法，产生不同的执行结果

"""

class Cat(object):

def __init__(self,name):

self.name = name

def game(self):

print '%s会喵喵叫' %self.name

class Hellokitty(Cat):

def game(self):

print'%s会说你好' %self.name

class Person(object):

def __init__(self,name):

self.name = name

def game_with_dog(self,cat):

print '%s和%s快乐的玩耍' %(self.name,cat.name)

cat.game()

#1、创建一个狗对象

A= Hellokitty('团团')

#2、创建一个人对象

xiaohong = Person('小红')

#3、让猫和小红玩耍

xiaohong.game_with_dog(A)