Java學習個人備忘錄之繼承
繼承的好處
1. 提高了代碼的復用性。
2. 讓類與類之間產生了關系，給第三個特征多態提供了前提。
java中支持單繼承，不直接支持多繼承，但對C++中的多繼承機制進行改良。
java支持多層繼承。
C繼承B，B繼承A，就會出現繼承體系。
當要使用一個繼承體系時：
1. 查看該體系中的頂層類，了解該體系的基本功能。
2. 創建體系中的最子類對象，完成共能的使用。
什麽時候定義繼承呢?
當類與類之間存在著所屬關系的時候，就定義繼承，xxx是yyy中的一種， xxx extends yyy。
class Person
{
String name;
int age;
}
class Student extends Person //繼承
{
// String name;
// int age;
void study()
{
System.out.println(name+"...student study...."+age);
}
}
class Worker extends Person
{
// String name;
// int age;
void work()
{
System.out.println("worker work");
}
}
class ExtendsDemo
{
public static void main(String[] args)
{
Student s = new Student();
s.name = "zhangsan";
s.age = 20;
s.study();
}
}
在子父類中，成員的特點體現
1.成員變量
2.成員函數
3.構造函數
1. 成員變量
當本類的成員和局部變量同名時，用this區分；
當子父類中的成員變量同名時，用super區分父類。
this和super的用法很相似。
this：代表一個本類對象的引用。
super：代表一個父類的空間，並不代表父類對象。
class Fu
{
int num = 4;
}
class Zi extends Fu
{
int num = 5;
void show()
{
System.out.println(super.num+"..."+num);
}
}
class ExtendsDemo2
{
public static void main(String[] args)
{
Zi z = new Zi();
z.show();
}
}
2. 成員函數
當子父類中出現成員函數一模一樣的情況，會運行子類的函數。
這種現象，稱為覆蓋操作，這時函數在子父類中的特性。
函數兩個特性：
1.重載. 同一個類中，overload
2.覆蓋. 子類中，覆蓋也稱為重寫，override
覆蓋註意事項：
1.子類方法覆蓋父類方法時，子類權限必須要大於等於父類的權限。
2.靜態只能覆蓋靜態，或被靜態覆蓋。
class Fu
{
void show()
{
System.out.println("fu show run");
}
}
class Zi extends Fu
{
void show()
{
System.out.println("zi show run");
}
}
class ExtendsDemo2
{
public static void main(String[] args)
{
Zi z = new Zi();
z.show();
}
}
什麽時候使用覆蓋?
當對一個類進行子類的擴展時，子類需要保留父類的功能聲明。
但是要定義子類中該功能的特有內容時，就是用覆蓋操作完成。
class Phone
{
void call()
{}
void show()
{
// System.out.println("pic");
// System.out.println("name");
System.out.println("number");
}
}
應用場景
現在手機升級了，加了顯示姓名和圖片的功能。
但是如果我直接在源代碼上修改會增加修改成本，不好。
這時候我們就可以用繼承來解決。
class NewPhone extends Phone
{
void show()
{
System.out.println("pic");
System.out.println("name");
// System.out.println("number");
super.show();
}
}
class PhoneDemo
{
public static void main(String[] args)
{
// Phone p = new Phone();
// p.show();
NewPhone p = new NewPhone();
p.show();
}
}
子父類中構造函數的繼承
在子類構造對象時，發現訪問子類構造函數時，父類也運行了。
為什麽呢?
原因是：在子類的構造函數中第一行有一個默認的隱式語句---super();
子類的實例化過程：子類中所有的構造函數默認都會訪問父類中的空參數的構造函數。
class Fu
{
Fu()
{
System.out.println("fu run");
}
}
class Zi extends Fu
{
Zi()
{
//super(); //默認的隱式語句. 調用的就是父類中的空參數的構造函數.
System.out.println("zi run");
}
}
class ExtendsDemo4
{
public static void main(String[] args)
{
new Zi();
/*
結果為:
fu run
zi run
*/
}
}
還有一種情況
class Fu
{
Fu()
{
System.out.println("fu run");
}
Fu(int x)
{
System.out.println("fu run...."+x);
}
}
class Zi extends Fu
{
Zi()
{
//super(); //默認的隱式語句. 調用的就是父類中的空參數的構造函數.
System.out.println("zi run...");
}
Zi(int x)
{
System.out.println("zi run...."+x);
}
}
class ExtendsDemo4
{
public static void main(String[] args)
{
new Zi(4);
/*
結果為:
fu run
zi run....4
*/
}
}
為什麽子類實例化的時候要訪問父類中的構造函數呢?
那是因為子類繼承了父類，獲取到了父類中的內容(屬性)，所以在使用父類內容之前，要先看父類是如何對自己的內容進行初始化的。
所以子類在構造對象時，必須訪問父類中的構造函數。
為什麽完成這個必須的動作，就子啊子類的構造函數中加了super(). 語句。
如果父類中沒有定義空參數構造函數，那麽子類的構造函數必須用super明確要調用父類中哪個構造函數。
同時子類構造函數中如果使用this調用了本類構造函數時，
那麽super就沒有了，因為super和this都只能定義第一行.所以只能有一個。
但是可以保證的是，子類中肯定會有其他的構造函數訪問父類的構造函數。
註意：super語句必須要定義在子類構造函數的第一行，因為父類的初始化動作要先完成。
class Fu
{
Fu()
{
super();
show();
return;
}
void show()
{
System.out.println("fu show");
}
}
class Zi extends Fu
{
int num = 8;
Zi()
{
//super(); //默認的隱式語句. 調用的就是父類中的空參數的構造函數.
//-->通過super初始化父類內容時，子類的成員變量並未顯示初始化.
//等super()父類初始化完畢後，才進行子類的成員變量顯示初始化.
//也就是說要先忙完父類那邊的事，然後才能忙自己的事.
System.out.println("zi cons run..."+num);
}
void show()
{
System.out.println("zi show ..."+num);
}
}
class ExtendsDemo5
{
public static void main(String[] args)
{
Zi z = new Zi();
z.show();
/*
結果為:
zi show...0
zi cons run...8
zi show...8
*/
}
}
一個對象實例化的過程：
Person p = new Person();
1. jvm會去讀取指定路徑下的Person.class文件，並加載進內存。
並會先加載Person的父類(如果有直接的父類的情況下)。
2. 在堆內存中的開辟空間，分配地址。
3. 並在對象空間中，對對象中的屬性進行默認初始化。
4. 調用對應的構造函數進行初始化。
5. 在構造函數中，第一行會先調用父類中的構造函數進行初始化。
6. 父類初始化完畢後，再對子類的屬性進行顯示初始化。
7. 在進行子類構造函數的特定初始化。
8. 初始化完畢後，將地址賦值給引用變量。
Java學習個人備忘錄之繼承