包_繼承

1.包

包(package) 用於管理程式中的類，主要用於解決類的同名問題。包可以看成目錄。

包的作用：

【1】防止命名衝突

【2】允許類組成一個單元模塊，便於管理

【3】更好的保護類、屬性和方法

1.1定義包

package用於定義包，形如：package   路徑（包名）

必須寫到源文件的有效代碼的第一句。

1 package cm.wuhao;     //定義包
2 
3 public class Test01{
4     public static void main(String[] args){
5         System.out.println("test package");
6     }
7 }

編譯帶包的源文件

javac -d 目的地 源文件

編譯完成後生成的位元組碼的全路徑

運行編譯好的位元組碼文件

java 包路徑+類名

例如：

 1.2包的命名規範

原則：始終保持類的全路徑是唯一

規範：

[1]包名由小寫字母組成，不能以圓點開頭或結尾。圓點有特殊意義——包分隔符

[2]包名之前最好加上唯一的首碼，通常使用組織倒置的網路功能變數名稱。如javagroup.com.xx   avagroup.net.xx

[3]包名後續部分依不同機構內部的規範不同而不同

1.3導包

import 用於導包，告訴類需要的其他類在什麼位置（路徑）。

形如：

1 import com.wuhao.Student； // 導入com.wuhao下的Student類。 

2 import com.wuhao.*； // 導入com.wuhao下的所有類。

編譯時要先編譯導入的包，其他類生成該類的全路徑方能編譯本類成功。

1.4不同包中的同名

如果一個類中用到了兩個不同包但同名的類時，如何處理？

1 import java.util.Date; //兩個包中都有date類
2 import java.sql.Date;
3 
4 public class Test05{
5     public static void main(String[] args) { 
6     Date date = new Date(0);
7 }
8 
9 }

這時候系統報錯，並沒有通過編譯

我們可以這樣處理：

創建對象時寫其中一個對象的全路徑

 1 import java.sql.Date;//sql中的Date類
 2 
 3 public class Test05{
 4     public static void main(String[] args) { 
 5     java.util.Date date1 = new java.util.Date();//寫全路徑
 6     System.out.println("date1的地址"+date1);
 7     Date date2 = new Date(0); //調用sql中的Date類
 8     System.out.println("date2的地址"+date2);
 9 }
10 
11 }

2.jvm中提供的包

3.靜態導入

如果一個類中定義的屬性和方法都是靜態時，可以考慮使用靜態導入。jdk1.5+ 出現。

1 package cn.sxt01;
2 public class Calc{
3     public static float PI = 3.14f; //靜態屬性
4     
5     public static int add(int a,int b){
6         return a+b;
7     }
8 }

1 package cn.sxt02;
2 // 靜態導入
3 import static cn.sxt01.Calc.*;
4 public class Test01{
5     public static void main(String[] args){
6         System.out.println(PI);
7         System.out.println(add(1,2));
8     }
9 }

思考:如果一個類中還有實例成員，能不能用靜態導入？

4.繼承

4.1為什麼要繼承？

為了提取較少代碼的重覆性，把抽取重覆性的代碼到一個公共類中，這個公共的類稱為父類(super class)。繼承於父類的類稱為子類(sub class).

java 的繼承特性：

【1】單根性：只能有一個父類（只有一個爸爸）

【2】傳遞性：可以是爸爸從爺爺那繼承過來的非私有的屬性和方法，兒子在從爸爸那裡繼承下來（類似中國的香火延續）

類B繼承於類A，使用關鍵字extends，則B擁有了A中非私有的屬性和方法。

1 class Car { 　　　　　　　　　　　　　　　　　　//父類
2     private int site;  //座位數
3     public void setSite(int site){
4         this.site = site;
5     }
6     void print(){
7         System.out.print("載客量是"+site+"人");
8     }
9 }

1 class Bus extends Car { 　　　　　　　　　　//子類
2     Bus(int site){
3         setSite(site);
4     }
5 }

1 public class Test04{
2     public static void main(String[] args) { 　　
3     Bus bus = new Bus(20);    
4     bus.print();
5 }
6 
7 }    

如果Person中定義了private 屬性count

5.super關鍵字

super只是一個關鍵字，區別於this關鍵字，super並沒有引用有地址。

super的作用：

【1】訪問父類的構造方法

 1 public Dog(String name,int health,int love,String strain){
 2         /*
 3         this.setName(name);
 4         this.setHealth(health);
 5         this.setLove(love);
 6         */
 7         super(name,health,love);
 8         this.setStrain(strain);
 9         
10     }

super調用父類構造方法時，必須寫到構造方法有效代碼第一句

【2】super調用父類的非私有屬性

super可以訪問父類的非私有屬性。私有的屬性不能用super訪問。

變數隱藏(C)

當子類定義了一個和父類同名的屬性時，在子類中優先訪問子類的屬性，如果要訪問父類屬性一定要加super。

一句話:如果要訪問父類屬性，通過super；如果要訪問子類屬性，通過this.

[3] super訪問非私有父類方法

1 public void print(){
2         System.out.print("我的姓名"+super.getName());
3         System.out.print("，健康值"+super.getHealth());
4                 System.out.print("，親密度"+super.getLove());
5         super.showInfo();
6         System.out.println("，我是一隻"+this.getStrain());
7     }
8                         

6.子類不能繼承父類的資源

7.訪問修飾符

java中存在4類訪問修飾符，分別是private、預設、protected、public。

private ：只能訪問本類成員

friendly：預設的，同包可以訪問，包訪問符

protected：除了不同包的其它類不能訪問，其它都可以訪問

public：全都可以訪問

8.繼承的循序

繼承關係記憶體圖

9.方法的重寫

當子類從父類繼承過來的方法不能滿足自身需要時，子類可以根據自身情況進行方法重寫(overwrite/override)

方法重寫建立在繼承的基礎上，沒有繼承，就沒有重寫！

子類根據自身情況，可以選擇部分重寫和完全重寫。

 部分重寫

1 public void showInfo(){
2         super.showInfo();
3         System.out.println("我是一隻"+this.getStrain());
4     }

完全重寫

1 public void showInfo(){
2         System.out.println("--"+super.getName()+"--");
3         System.out.println("健康值:"+super.getHealth());
4         System.out.println("親密度:"+super.getLove());
5         System.out.println("品種:"+this.getStrain());
6     }

重寫的規則

[1]方法名稱相同

[2]參數列表相同

[3]子類的訪問許可權一定 >= 父類訪問許可權 private 特殊除外

[4]返回值和父類相同或者是其子類

1 public Pet create(){
2         Pet pet = new Pet();
3         return pet;
4 }

1 public Dog create(){
2         Dog dog = new Dog();
3         return dog;
4 }