python和其他面向對象語言類似，每個類可以擁有一個或者多個父類，它們從父類那里繼承了屬性和方法。如果一個方法在子類的實例中被調用，或者一個屬性在子類的實例中被訪問，但是該方法或屬性在子類中並不存在，那么就會自動的去其父類中進行查找。
繼承父類后，就能調用父類方法和訪問父類屬性，而要完成整個集成過程，子類是需要調用的構造函數的。
子類不顯式調用父類的構造方法，而父類構造函數初始化了一些屬性，就會出現問題
如果子類和父類都有構造函數，子類其實是重寫了父類的構造函數，如果不顯式調用父類構造函數，父類的構造函數就不會被執行，導致子類實例訪問父類初始化方法中初始的變量就會出現問題。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
class
A:
def __init__(self):
self.namea=
"aaa"
def funca(self):
print(
"function a : %s"
%self.namea)
class
B(A):
def __init__(self):
self.nameb=
"bbb"
def funcb(self):
print(
"function b : %s"
%self.nameb)
b=B()
print(b.nameb)
b.funcb()
b.funca()
|
結果：
|
1
2
3
4
5
6
7
8
|
bbb
function b : bbb
Traceback (most recent call last):
File
"/home/lai/workspace/sru/2.py"
, line 24,
in
<module>
b.funca()
File
"/home/lai/workspace/sru/2.py"
, line 11,
in
funca
print(
"function a : %s"
%self.namea)
AttributeError:
'B'
object
has no attribute
'namea'
|
在子類中，構造函數被重寫，但新的構造方法沒有任何關於初始化父類的namea屬性的代碼，為了達到預期的效果，子類的構造方法必須調用其父類的構造方法來進行基本的初始化。有兩種方法能達到這個目的：調用超類構造方法的未綁定版本，或者使用super函數。
方法一：調用未綁定的超類構造方法
修改代碼，多增一行：
def __init__(self):
self.namea="aaa"
def funca(self):
print("function a : %s"%self.namea)
class B(A):
def __init__(self):
self.nameb="bbb"
#這一行解決了問題
A.__init__(self)
def funcb(self):
print("function b : %s"%self.nameb)
b=B()
print(b.nameb)
b.funcb()
b.funca()
結果
|
1
2
3
|
bbb
function b : bbb
function a : aaa
|
如上有注釋的一行解決了該問題，直接使用父類名稱調用其構造函數即可。
這種方法叫做調用父類的未綁定的構造方法。在調用一個實例的方法時，該方法的self參數會被自動綁定到實例上（稱為綁定方法）。但如果直接調用類的方法（比如A.__init），那么就沒有實例會被綁定。這樣就可以自由的提供需要的self參數，這種方法稱為未綁定unbound方法。
通過將當前的實例作為self參數提供給未綁定方法，B類就能使用其父類構造方法的所有實現，從而namea變量被設置。
方法二：使用super函數
修改代碼，這次需要增加在原來代碼上增加2行：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
#父類需要繼承object對象
class
A(
object
):
def __init__(self):
self.namea=
"aaa"
def funca(self):
print(
"function a : %s"
%self.namea)
class
B(A):
def __init__(self):
#這一行解決問題
super(B,self).__init__()
self.nameb=
"bbb"
def funcb(self):
print(
"function b : %s"
%self.nameb)
b=B()
print(b.nameb)
b.funcb()
b.funca()
|
結果與方法一相同
|
1
2
3
|
bbb
function b : bbb
function a : aaa
|
如上有注釋的為新增的代碼，其中第一句讓類A繼承自object類，這樣才能使用super函數，因為這是python的“新式類”支持的特性。當前的雷和對象可以作為super函數的參數使用，調用函數返回的對象的任何方法都是調用超類的方法，而不是當前類的方法。
super函數會返回一個super對象，這個對象負責進行方法解析，解析過程其會自動查找所有的父類以及父類的父類。
方法一更直觀，方法二可以一次初始化所有超類
super函數比在超累中直接調用未綁定方法更直觀，但是其最大的有點是如果子類繼承了多個父類，它只需要使用一次super函數就可以。然而如果沒有這個需求，直接使用A.__init__(self)更直觀一些。
父類能調用子類的方法嗎？
● 把子類傳遞到父類的有參構造中，然后調用。
● 使用反射的方式調用，你使用了反射還有誰不能調用的？！
● 父類調用子類的靜態方法。
案例展示：
package com.ywq;
public class Test2{
public static void main(String[] args)
{
Son son = new Son();
Father father=new Father(son);
father.fun1();
father.fun4();
}
}
class Father{
public Son son;
public Father(Son son){
this.son=son;
}
public Father() {
}
public void fun4(){
//方法3：使用反射的方式調用子類方法
try {
Class cls=Class.forName("com.ywq.Son");
Son son=(Son) cls.newInstance();
son.fun2();
} catch (Exception e) {
e.printStackTrace();
}
}
public void fun1(){
//方法1：把子類傳遞到父類的有參構造函數中，然后調用。
System.out.println("我是父類的方法");
son.fun2();
//方法2：父類調用子類的靜態方法。
Son.fun3();
}
}
class Son extends Father{
public static void fun3(){
System.out.println("我是子類的靜態方法");
}
public void fun2(){
System.out.println("我是子類的方法");
}
}
這三種都是父類直接調用子類的方法，
參考：https://blog.csdn.net/oschina_41675984/article/details/80373587