python中调用父类的方式 + 继承中参数与方法的传递特性
python和java的继承
- python中可以单继承也可以多继承，即可以一个类继承多个父类；
- java中只支持单继承，不支持多继承，但是java中接口可以多继承，所以接口可以有多个父类
python中一个类有多个父类的时候，默认使用第一个父类的同名属性和方法；
如果子类先调用父类的attribut和method, 父类属性会覆盖子类属性，所以在调用父类时先调用子类的初始化self.init() 注意括号中为空，具体解释看后面代码示例；
python中子类继承父类：
- 继承父类的方法 ：通过实例化对象调用，但这种情况下，子类的同名方法就会覆盖 父类中的同名方法。见例子1，例子3
- 继承父类的属性：子类需要先调用父类的init函数，因为子类的init函数不会自动继承父类中init函数中的属性。
不继承父类init函数直接通过实例化对象调用父类中的属性会报错。见例子2，例子3
子类对象调用父类attribut、method的三种方式：
方法 1
父类名.init(self, 父类同类参数)
父类名.method(父类同类参数)方法2
super(子类名，self).init(父类同类参数)
super(子类名，self).method(父类同类参数)方法3
super().init(self，父类同类参数)
super().method(父类同类参数)方法2和方法3省略括号里内容的区别**，一般用方法1 和 方法3**
**
总结：
| 父类名.init(self, 参数) | 父类名； ()中一定有self +参数 |
|---|---|
| super(子类名,self).init(参数) | 子类名； （）中参数一定没self |
例子 1
# python中重写父类方法，不用函数名相同，但是参数要相同
# python中有重载的思想但是没有重载行为，python是动态语言不需要重载
class testA(object):
def __init__(self,name):
self.name=name
self.age=100
def sMethod(self, sMethodAttribut):
sMethodAttribut="fu_sMethodAttribut"
print(sMethodAttribut)
class testB(testA):
def __init__(self):
self.age=age
""" 调用子类自己的初始化。
子类调用父类的属性和方法时，父类属性会覆盖子类属性
所以调用父类属性前，先调用自己子类的初始化(这里讲的始终是属性，不涉及方法)"""
def zMethod(self,name):
print("zi method, self : ",self)
self.__init__() #（）里是空的,与子类初始化init函数中参数一致
"""重写父类方法，子父类方法名可以不同，但是参数要一致；
python不会自动调用父类的constructeur，需要手动调用，
所以调用父类方法时，为保证调用到的也是父类的属性
必须在调用父类方法前调用父类的初始化，也就是调用父类的__init__(self，参数)
而，如何调用父类的init函数，调用方式同上文的3种方式。"""
"""子类重写父类方法 1"""
def sup1(self,name):
print("fu method, self : ",self)
testA.__init__(self,name) #这里是调用父类的init函数，init中传递的参数要和父类保持一致, ()里一定有self
testA.sMethod(self,name) # 这里调用的是父类的method,所以()里参数和父类保持一致,一定有self
"""子类重写父类方法 2"""
def sup2(self,name):
print("fu method, self : ",self)
super(testB,self).__init__(name) # 这里是调用父类的init函数，init中传递的参数要和父类保持一致（后面的括号中一定没有self）
super(testB,self).sMethod(name) # ()里参数和父类保持一致
"""子类重写父类方法 3"""
def sup3(self,name):
print("fu method, self : ",self)
super().__init__(name) #这里是调用父类的init函数，init里参数和父类保持一致,没有self
super().sMethod(name) #()里参数和父类保持一致
# 创建实例/对象
b=testB()
# 对象调用子类方法
b.zMethod("immuable") # zi method, self : <__main__.testB object at 0x00000195CC3D9550>
#对象调用父类方法
b.sMethod("we") # fu_sMethodAttribut
# 对象重写父类的3种方法
print("\n-------------------------super 1--------------------")
b.sup1("super 1")
print("\n-------------------------super 2--------------------")
b.sup2("super 2")
print("\n-------------------------super 3----------------------")
b.sup3("super 3")
输出
# 对象调用子类方法
zi method, self : <__main__.testB object at 0x00000195CC99EB70>
#对象调用父类方法
fu method
# 对象重写父类的3种方法
-------------------------super 1--------------------
fu method, self : <__main__.testB object at 0x00000195CC99EB70>
super 1
-------------------------super 2--------------------
fu method, self : <__main__.testB object at 0x00000195CC99EB70>
super 2
-------------------------super 3----------------------
fu method, self : <__main__.testB object at 0x00000195CC99EB70>
super 3
例子2，子类的初始化
python类中初始化__init__（）方法是可选的， 如果子类没有新的构造参数，或 新的初始化逻辑，则初始化__init__（）方法没有必要被创建，因为这里python会找到父类的初始化方法并执行。
"""子类继承父类的属性时：子类需要先调用父类的init函数，因为子类的init函数不会自动继承父类中init函数中的属性。最后通过实例化对象调用父类中的属性报错"""
class A(object):
def __init__(self,name):
self.name=name
class B(A):
def __init__(self,name,age):
self.age=age
b=B("immuable",18)
b.age
# b.name #报错, 因为父类的属性并没有被调用
输出
18
如下是想要调用父类属性name的正确写法
class A(object):
def __init__(self,name):
self.name=name
def fuMethod(self):
print("fu method")
class B(A):
def __init__(self,name,age):
super().__init__(name) # 需要调用父类中的init函数
self.age=age
def fuMethod(self):
print("zi method")
b=B("immuable",18)
print(b.age, b.name)
# 子类继承父类时 ：通过实例化对象调用父类方法，但这种情况下，子类的同名方法就会覆盖 父类同名方法（奖励讲的是方法，不涉及属性）。属性见例子1或例子3
b.fuMethod() #
输出
在这里插入代码片
例子3
class A(object):
def __init__(self,name):
self.name=" fu name"
def fuMethod(self):
print("fu method")
class B(A):
def __init__(self,name,age):
super().__init__(name)
self.age=age
#子类中与父类同名的方法： 子类方法覆盖父类方法
#子类继承父类属性name：这里先调用父类属性，那么父类属性name覆盖子类属性name
# 但一般都是self.name=name这种正常的写法，通过self.name=‘fu name’可以看到参数的传递
def fuMethod(self,name,age):
self.name="zi name"
print("zi method")
b=B("immuable",18)
print(b.age, b.name)
b.fuMethod("--",18)
输出
fu name 18
zi method
例子3的正常写法及其输出
class A(object):
def __init__(self,name):
self.name=name # 改成正常形式
def fuMethod(self):
print("fu method")
class B(A):
def __init__(self,name,age):
self.name="zi name" #这里还是写成赋值形式，便于查看参数传递
self.age=age
super().__init__(name)
def fuMethod(self,name,age):
self.__init__(name,age)
self.name="zzi name" #这里还是写成赋值形式，便于查看参数传递
print("zi method")
b=B("immuable",18)
print(b.name,b.age)
b.fuMethod("--",18)
immuable 18
zi method
java中方法的overlaod与override
参考：http://t.csdn.cn/syJds
