寫在開頭

包、類、接口、方法、變量、參數、代碼塊，這些都是構成Java程序的核心部分，即便最簡單的一段代碼里都至少要包含里面的三四個內容，這兩天花點時間梳理了一下，理解又深刻了幾分。

Java中的包

Java 定義了一種名字空間，稱之為包：package。一個類總是屬于某個包，類名（比如Person）只是一個簡寫，真正的完整類名是包名.類名，這才是唯一確定一個類路徑的寫法，不同包中的類名允許重復。包名推薦使用倒置的域名，例如org.apache。

包的定義

//包名
package hello;

public class Person {
    // 包作用域:
    public void hello() {
        System.out.println("Hello!");
    }
}

包的作用域

通過訪問修飾符，可以確認類中方法與屬性相對于包的作用域，這在前面的文章中已經提過了，不再贅言，直接貼圖。

Java中包的引入通過import關鍵字實現，在寫import的時候，可以使用*，表示把這個包下面的所有class都導入進來（但不包括子包的class）：

import java.util.ArrayList;
public class test {
    public static void main(String[] args) {
        ArrayList<Object> objects = new ArrayList<>();
    }
}

當然處理import導入外，也可以通過完成的包名.類名的方式進行引入，但太麻煩了，很少用到。

Java中的類

Java中有個從1995年就喊出的口號“一切皆對象”，而對象在程序中的具象就是通過類（class）來實現！

類的創建

比如有這樣一個Person對象，擁有姓名，性別，年齡等特性，行為方式有吃飯，睡覺和跑步，那我們就可以在Java中如下定義：

public class Person {
	//姓名
    private String name;
    //年齡
    private int age;
    //性別
    private int sex;
	/**
	* 吃飯
	*/
    private void eat() {
    }
	/**
	* 睡覺
	*/
    private void sleep() {
    }
	/**
	* 跑步
	*/
    private void run() {
    }
}

類創建好了，如何用呢？這時候需要通過new關鍵字去創建一個類對應的對象
Person person = new Person();

類的初始化賦值

這行代碼創建了一個Person對象，并在堆內存中分配一定的空間，person被稱為對象Person的引用，通過這個引用可以對對象進行初始化賦值操作

通過引用變量賦值
示例代碼：

public class Person {
    private String name;
    private int age;
    private int sex;

    public static void main(String[] args) {
        Person person = new Person();
        person.name = "JavaBuild";
        person.age = 18;
        person.sex = 1;
        
        System.out.println(person.name);
        System.out.println(person.age);
        System.out.println(person.sex);
    }
}

通過構造方法賦值
示例代碼：

public class Person {
    private String name;
    private int age;
    private int sex;

    public Person(String name, int age, int sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    public static void main(String[] args) {
        Person person = new Person("JavaBuild", 18, 1);

        System.out.println(person.name);
        System.out.println(person.age);
        System.out.println(person.sex);
    }
}

內部類

根據上面的內容，我們已經熟悉了Java中的類，實際上在類的內部依舊可以創建一個類，這樣的類就被稱之為：內部類，內部類根據創建的位置，關鍵字等修飾符分為如下幾類：

1、成員內部類

編譯之后會生成兩個class文件：OuterClass.class和OuterClass$InnerClass.class

class OuterClass {
    class InnerClass {} //成員內部類
}

2、方法內部類

編譯之后會生成兩個class文件：OuterClass.class和OuterClass$1InnerClass.class
只能在定義該內部類的方法內實例化，方法內部類對象不能使用該內部類所在方法的非final局部變量
當一個方法結束，其棧結構被刪除，局部變量成為歷史。但該方法結束后，在方法內創建的內部類對象可能仍然存在于堆中

class OuterClass {
    public void doSomething(){
        class Inner{
        }
    }
}

3、匿名內部類

編譯后生成兩個class文件：Fish.class和Fish$1.class

public class Fish {
    /**
     * 游泳方法
     */
    public void swim() {
        System.out.println("我在游泳!");
    }

    public static void main(String[] args) {
        //創建魚對象
        Fish fish = new Fish() {
            //重寫swim方法
            public void swim() {
                System.out.println("我在游泳，突然發生海嘯，我撤了!");
            }
        };
        
        fish.swim();
    }
}

4、靜態內部類

靜態嵌套類，并沒有對實例的共享關系，僅僅是代碼塊在外部類內部
靜態的含義是該內部類可以像其他靜態成員一樣，沒有外部類對象時，也能夠訪問它
靜態嵌套類僅能訪問外部類的靜態成員和方法
在靜態方法中定義的內部類也是靜態嵌套類，這時候不能在類前面加static關鍵字

class OuterFish {
    static class InnerFish {
    }
}

class TestStaticFish { 
    public static void main(String[] args) {
        //創建靜態內部類對象
        OuterFish.InnerFish iFish = new OuterFish.InnerFish();
    }
}

內部類的特點

1、內部類提供了某種進入其繼承的類或實現的接口的窗口
2、與外部類無關，獨立繼承其他類或實現接口
3、內部類提供了Java的"多重繼承"的解決方案，彌補了Java類是單繼承的不足
4、內部類仍然是一個獨立的類，在編譯之后內部類會被編譯成獨立的.class文件，但是前面冠以外部類的類名和$符號
5、內部類不能用普通的方式訪問。內部類是外部類的一個成員，因此內部類可以*地訪問外部類的成員變量，無論是否是private的
6、內部類聲明成靜態的，就不能隨便的訪問外部類的成員變量了，此時內部類只能訪問外部類的靜態成員變量

Java中的接口

在講OOP時，我們提到過面向對象的四大特性，其中抽象就是那個第四大特性，而抽象的體現在Java中主要為抽象類和接口！
接口是通過interface 關鍵字修飾的，用來對一類具有共性對象的一種抽象，通過不同的類進行實現，來滿足各自需求。

接口的特性

1、接口中允許定義變量
2、接口中允許定義抽象方法
3、接口中允許定義靜態方法（Java 8 之后）
4、接口中允許定義默認方法（Java 8 之后）
5、接口不允許直接實例化
6、接口可以是空的
7、不要在定義接口的時候使用 final 關鍵字
8、接口的抽象方法不能是 private、protected 或者 final
9、接口的變量是隱式 public static final（常量）

接口的典型案例

我們在之前聊到對象的淺拷貝與深拷貝時提到過Cloneable接口，這就是一個典型的接口應用案例，Cloneable 和 Serializable 一樣，都屬于標記型接口，它們內部都是空的。實現了 Cloneable 接口的類可以使用 Object.clone() 方法，否則會拋出 CloneNotSupportedException。

接口與抽象類的區別

1、抽象類可以有構造方法；接口中不能有構造方法（因為不允許直接實例化）。
2、抽象類中可以有普通成員變量；接口中沒有普通成員變量。
3、抽象類中可以包含非抽象普通方法；JDK1.8 以前接口中的所有方法默認都是抽象的，JDK1.8 開始方法可以有 default 實現和 static 方法。
4、抽象類中的抽象方法的訪問權限可以是 public、protected 和 default；接口中的抽象方法只能是 public 類型的，并且默認即為 public abstract 類型。
5、抽象類中可以包含靜態方法；JDK1.8 前接口中不能包含靜態方法，JDK1.8 及以后可以包含已實現的靜態方法。
6、抽象類和接口中都可以包含靜態成員變量，抽象類中的靜態成員變量可以是任意訪問權限；接口中變量默認且只能是 public static final 類型。
7、一個類可以實現多個接口，用逗號隔開，但只能繼承一個抽象類。
接口不可以實現接口，但可以繼承接口，并且可以繼承多個接口，用逗號隔開。

未完待續......

總結

以上是生活随笔為你收集整理的一文搞清楚Java中的包、类、接口的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。