一、包

包名

在講包名前，我們先來了解一下，包是用來干什么的？

Java中允許使用包（package），包將類組織在一個集合中。借助包可以方便管理組織自己的代碼，并將自己的代碼與別人的提供的代碼庫分開管理。

包是組織類的一種方式。使用包的主要目的就是保證類的唯一性。

在Windows操作系統(tǒng)中，我們都知道，同一個文件夾下，不能同時(shí)出現(xiàn)兩個一樣的文件名的文件。而我們的java類，對應(yīng)的就是一個.class文件，所以產(chǎn)生了包，而包其實(shí)就可以理解為路徑中所存放的文件夾，為了出現(xiàn)重命的類名，所以將各個類分布在不同的包（文件夾）中。

而包名的命名：包名必須全部是小寫字母，且一般包的命名方式是所在公司的官網(wǎng)（域名）的逆序?qū)?，假如www.xxxx.com，一般包名就是com.xxxx.——等等。

從編譯器的角度來看，嵌套的包之間沒有任何關(guān)系。例如：java.util包和java.util.jar包毫無關(guān)系。每一個包都是獨(dú)立的類集合。

類的導(dǎo)入與靜態(tài)導(dǎo)入

一個類可以使用所屬包中的所有類，以及其他包下的公共類（public class）。

訪問另一個包的類有兩種方式：

1.使用完全限定名，也就是說在包名后面跟著類名。

java.util.Scanner scan = new java.util.Scanner(); //類名前面，直接跟包名

2.使用import關(guān)鍵字

import語句應(yīng)該位于源文件的頂部，且位于package語句的后面。

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new scanner();
    }
}

對于導(dǎo)包，我們還有一種比較簡單的方式，如下

import java.util.*;

*，就是通配符。也就是在當(dāng)前類中，可以直接使用util包的所有類，從而不需要再次導(dǎo)包了。值得注意的是，這里的導(dǎo)入，并不是導(dǎo)入util包下的所有類，這里跟C語言的include，不一樣。C語言中的include，是導(dǎo)入頭文件下的所有內(nèi)容；而這里的import導(dǎo)入，只會在需要使用這個包下的類的時(shí)候，才會導(dǎo)入進(jìn)來。

當(dāng)然，對于import導(dǎo)入包時(shí)，還需要特別注意一個問題，如下：

import java.util.*;
import java.sql.*;
public class Main {
    public static void main(String[] args) {
        Date date = new Date(); //error， java.util.Date 還是 java.sql.Date?
    }
}

此時(shí)進(jìn)行編譯，就會產(chǎn)生一個如上面代碼的注釋部分的錯誤。此時(shí)的編譯器無法確定你想使用的是哪一個包下的Date類?，F(xiàn)在就可以添加一個特定的import來解決這個問題。

import java.util.*;
import java.sql.*;
import java.util.Date; //特別指出是使用這個包下的Date類
public class Main {
    public static void main(String[] args) {
        Date date = new Date();
    }
}

如果此時(shí)，兩個包中的Date都需要使用，那就只能使用完全限定名了。如下：

import java.util.*;
import java.sql.*;
public class Main {
    public static void main(String[] args) {
        java.util.Date date = new java.util.Date();
        java.sql.Date  date2 = new java.util.Date();
    }
}

靜態(tài)導(dǎo)入

我們還可以使用靜態(tài)導(dǎo)入包的方式，進(jìn)行代碼的縮寫。使用import static 可以導(dǎo)入包中的靜態(tài)方法和靜態(tài)字段。這樣就可以不必再加類名前綴。

import static java.lang.System.*;
public class Main {
    public static void main(String[] args) {
        out.println("hello world");
    }
}

只是有這樣一種機(jī)制，可以進(jìn)行代碼的縮寫，但在現(xiàn)實(shí)中，這樣的代碼，可能更不容易讀懂。所以大家使用時(shí)，酌情考慮。

在包中添加類

如果要想將類放入包中，就必須將包的名字放在源文件的開頭，即就是放在定義這個包中各個類的代碼之前。如下：

如果沒有在這個源文件的開頭，寫package語句，則這個源文件中類就屬于無名包（unnamed package）。無名包沒有包名。

基本規(guī)則：

• 在源文件的最上方加一個package語句，可以指定該代碼在哪個包
• 包名盡量指定成唯一的名字，通常會使用公司的域名逆序形成
• 包名要和代碼路徑相匹配。例如：package com.xxxx.demo，那么所對應(yīng)的文件路徑就是com/xxxx/demo
• 如果一個源文件沒有package語句，則該類會被放到無名包（默認(rèn)包）中

IDEA建包過程：

包訪問權(quán)限

在之前的文章中，我們介紹過public和private。而private修飾的方法或成員變量，只能在當(dāng)前這個類中訪問。

如果有個類，既沒有寫public，也沒有寫private訪問修飾限定符，則此時(shí)這個（類、方法或成員變量）可以在包內(nèi)部（當(dāng)前文件夾下）的其他類中使用，但是不能在包外部（其他文件夾下）的類中使用。如下代碼：

import com.xxxx.demo1;
//demo1 包
public class Main {
    public static void main(String[] args) {
        Test test = new Test(); //會報(bào)錯，訪問權(quán)限不夠。
    }
}
//=====假設(shè)下面是第二個文件夾下的文件=====
import com.xxxx.demo2;
class Test { //訪問修飾限定符：沒寫，我們就稱為 默認(rèn)
    public int number;
}
public class Demo2 {
    public int val;
}

訪問修飾限定符權(quán)限：

其中，protected會在繼承中講到，我們繼續(xù)往下看！??！

二、繼承

繼承的基本思想就是：在已有類的基礎(chǔ)之上，創(chuàng)建新的類。繼承已存在的類得到就是復(fù)用了（繼承）這些類的方法，而且可以增加一些新的方法和成員變量。

類、超類與子類

我們先來舉個例子，比如一只貓和一只狗。它們了分別有自己的名字、性別、還是吃東西等等的一些性質(zhì)。如下圖：

他們分別都有自己的這些特征，我們也可以很容易的發(fā)現(xiàn)，他們都有自己一些共有的特征：比如姓名，性別。所以如果我們分別在新建貓和狗的類，還得寫專屬于它們自己的成員變量，這樣的話，就顯得代碼重復(fù)累贅，如下圖這樣：

我們可以很清晰的看到，紅色框代碼部分，就是一模一樣的，所以出現(xiàn)了重復(fù)的代碼。而且這兩個類都是動物，所以說引出了一個繼承中的一個概念：“is -a”關(guān)系。

也就是說，什么是一個什么這樣的概念。就可能會用到繼承。

那該怎么實(shí)現(xiàn)繼承關(guān)系呢？我們來看下圖：

我們可以使用extends關(guān)鍵字來實(shí)現(xiàn)繼承關(guān)系，這樣的話，貓和狗兩個類，就能夠同時(shí)實(shí)現(xiàn)name和sex字段。這就是繼承。

此時(shí)貓和狗類，我們稱為子類或者派生類。而Animal類我們稱為父類、基類或超類。

總結(jié)：

• 使用extends指定父類
• Java中一個子類只能繼承一個父類。（而C++中可以實(shí)現(xiàn)多繼承）
• 子類會繼承父類所有的public的字段和方法
• 對于父類的private的字段和方法，子類是無法進(jìn)行訪問的
• 子類的實(shí)例中，也包含這父類的實(shí)例?？梢允褂胹uper關(guān)鍵字得到父類實(shí)例的引用。

重寫方法（override）

像上圖，子類和父類中，方法名和參數(shù)列表是一模一樣的。我們就稱為方法重寫（override）。可能有人就會問，我該怎么調(diào)用相應(yīng)的方法呢？

我們想調(diào)用Animal的eat方法，我們只需要new出一個Animal的對象，就能進(jìn)行調(diào)用，當(dāng)然，Cat類的實(shí)例對象也是如此。如果我們想在Cat類的實(shí)例對象調(diào)用父類的方法，則我們可以使用super關(guān)鍵字進(jìn)行調(diào)用。如下圖：

切記：

• super關(guān)鍵字，在使用的時(shí)候，只能調(diào)用他的直接父類的方法或字段。比如：Animal類還繼承了一個類，此時(shí)Cat類中，使用super，則只會調(diào)用Animal中的方法或字段。
• 在子類中重寫的方法，這個方法的訪問修飾限定符的等級，應(yīng)高于或等于父類的方法的訪問修飾限定符。比如：父類中的eat方法是public修飾，而子類中的eat方法也應(yīng)該是public，或者是更高的。（當(dāng)然只是舉個例子，public就是最高的訪問修飾限定符了）
• 被重寫的方法，不能是被static修飾的

this與super的區(qū)別：

子類構(gòu)造器

在上面說了，super關(guān)鍵字來調(diào)用父類的構(gòu)造方法，那具體是如何進(jìn)行調(diào)用的，我們來看一下具體的代碼實(shí)現(xiàn)：

public class Cat extends Animal{
    public Cat(String name, String sex) {
        super(name, sex); //調(diào)用父類的構(gòu)造方法，super語句必須在子類構(gòu)造器的第一行
        System.out.println("Cat的構(gòu)造方法"); 
    }
    public void eat() {
        System.out.println("吃魚");
    }
}

public class Animal {
    public String name;
    public String sex;
    public Animal(String name, String sex) { //父類的構(gòu)造方法
        this.name = name;
        this.sex = sex;
    }
    public void eat() {
        System.out.println("吃肉");
    }
}

總結(jié)：

• 使用super構(gòu)造方法的語句必須放在子類構(gòu)造方法中的第一行。
• 如果子類中，沒有顯示地調(diào)用父類的構(gòu)造方法，將自動地調(diào)用超類的無參構(gòu)造方法。
• 在進(jìn)行子類的實(shí)例化時(shí)，會調(diào)用子類的構(gòu)造方法，而在調(diào)用子類構(gòu)造方法時(shí)，將會先調(diào)用父類的構(gòu)造方法。也就是說：new Cat ，實(shí)際上將先會新建出父類，在父類新建完成后，才會回到子類的構(gòu)造方法，進(jìn)行新建子類。

下面是一道有趣的題：請問下列代碼的輸出結(jié)果是什么。

class X {
    Y y=new Y();
    public X() {
        System.out.print("X");
    }
}
class Y {
    public Y() { 
        System.out.print("Y");
    }
}
public class Z extends X {
    Y y=new Y();
    public Z() {
        System.out.print("Z");
    }
    public static void main(String[] args) {
        new Z();
    }
}

上面的代碼的輸出結(jié)果是：YXYZ。

分析：

• 如果調(diào)用的是子類，那么在進(jìn)入子類構(gòu)造方法后，將先執(zhí)行super語句（若沒寫，編譯器自帶），先構(gòu)造父類。
• 在父類構(gòu)造完成后，再次回到子類的構(gòu)造方法。此時(shí)將先初始化當(dāng)前類的成員變量。
• 在成員變量初始化之后，才會執(zhí)行構(gòu)造方法里面的語句。

上訴代碼執(zhí)行流程圖：

protected關(guān)鍵字

在上文中，我寫了一個訪問修飾限定符的表，表中第3個protected關(guān)鍵字。

前面我們學(xué)了public和private訪問修飾限定符，public的權(quán)限有大了，對于public來說，整個工程都可以進(jìn)行使用；而對于private來說，只能在當(dāng)前的類中進(jìn)行使用。二者之前，一個權(quán)限過大，一個權(quán)限過小。所以在Java的繼承中，還引入了這個關(guān)鍵字：protected；

對于protected來說，protected修飾的內(nèi)容，在這個包下，可以直接使用。而在不同的包下，只有繼承了這個類，才能在不同的包下使用該類被protected修飾內(nèi)容。

阻止繼承：final關(guān)鍵字

在前面的文章中，我們介紹過final關(guān)鍵字，final修飾的變量，在初始化之后，將不能被修改。

final int a = 10;
a = 20; //編譯出錯，此時(shí)的a被final修飾，存儲在方法區(qū)，且不能被修改

final也能修飾類，，表示不能再被繼承，稱為密封類。

final還能修飾方法，表示此時(shí)的方法不能被重寫，稱為密封方法。

切記：如果一個類被final修飾，那么其中的方法將自動地稱為final，但是不包括字段。如果一個方法沒有被重寫并且還很短，編譯器將會對此進(jìn)行優(yōu)化處理，這個過程稱為內(nèi)聯(lián)。

組合

和繼承類似的，還有一個叫組合的概念，也是用于表達(dá)類之間的關(guān)系，也能夠達(dá)到代碼的重復(fù)使用。

例如：一個公司由很多人組合而成，有當(dāng)經(jīng)理的、職員的、保潔員的等等……

class Person {
    public String name;
    public String sex;
}
class Manager extends Person { //繼承 人
    //經(jīng)理的薪水
    public double getSalary() {
    }
}
class Staff extends Person { //繼承 人
    //普通職員的薪水
    public double getSalary() {
    }
}
//組合
public class Company {
    public Manager[] manager; //經(jīng)理
    public Staff[] staff; //普通職員
}

組合并沒有涉及到特殊的語法，僅僅只是將一個類的實(shí)例作為另一個類的字段，這也是我們設(shè)計(jì)類的一種常用的方式或思想。

組合表示has- a 的語義：意為：一個事物 由 什么組合而成，也就是包含的意思。

繼承表示is-a的語義：意為：一個事物 是 一個什么事物的概念。

總結(jié)

本篇文章就到這里了，希望能夠給你帶來幫助，也希望您能夠多多關(guān)注腳本之家的更多內(nèi)容！