1、物件陣列

物件陣列就是數組裡包含的是一組物件，在使用之前，我們必須要先開闢陣列空間，一開始數組裡的每一個物件都是null值，在使用的時候，每一個物件都必須例項化。

1.1 物件陣列的宣告

類 物件陣列名稱 [] = new 類 [陣列長度]

class Person{
    private String name;

    public String getName(){
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
 

    public Person(String name){
        this.setName(name);
    }
}

public class ChapterFive {
    public static void main(String[] args){
        Person per[] = new Person[3];  // 開闢了三個空間大小的陣列
        System.out.println("============= 陣列宣告 ============");
        // 物件陣列初始化之前，每個值都是null
        for(int
 
 i=0;i<per.length;i++){
            System.out.println("per[" + i + "] = " + per[i]);
        }
        // 每個元素初始化
        per[0] = new Person("張三");
        per[1] = new Person("李四");
        per[2] = new Person("王五");

        System.out.println("============ 物件例項化 ===========");
        for(int i=
 
0;i<per.length;i++){
            System.out.println("per[" + i + "] = " + per[i].getName());
        }
    }
}

// 執行結果
============= 陣列宣告 ============
per[0] = null
per[1] = null
per[2] = null
============ 物件例項化 ===========
per[0] = 張三
per[1] = 李四
per[2] = 王五

1.2 陣列動態初始化

陣列可以靜態初始化，也可以動態初始化，物件陣列當然也一樣可以。

class Person{
    private String name;

    public String getName(){
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public Person(String name){
        this.setName(name);
    }
}

public class ChapterFive {
    public static void main(String[] args){
    	// 靜態初始化三個物件
        Person per[] = {new Person("張三"),new Person("李四"),new Person("王五")};  
        System.out.println("============ 陣列輸出 ===========");
        for(int i=0;i<per.length;i++){
            System.out.println("per[" + i + "] = " + per[i].getName());
        }
    }
}

2、內部類

在一個類裡還可以再定義另一個類，我們稱為內部類，定義了內部類的類稱為外部類，內部類可以宣告為private或者public，對內部類的訪問和外部類中其它成員變數或者方法一樣。

識別符號 class 外部類名稱{
	// 外部類成員
	識別符號 class 內部類名稱 {
		// 內部類成員
	}
}

class Outer{
    private String info="hello world!";  // 外部類私有屬性
    class Inner{  // 定義內部類
        public void print(){
            System.out.println(info);
        }
    }

    public void fun(){  // 定義外部類的方法
        new Inner().print();  // 通過內部類的例項化呼叫方法
    }
}

public class ChapterFive {
    public static void main(String[] args){
        new Outer().fun();  // 呼叫外部類的fun方法
    }
}

// 執行結果
hello world!

內部類既有優點又有缺點：

• 缺點： 破壞了類的結構，正常定義一個類，最好只定義屬性和方法。
• 優點： 可以方便的訪問外部類的私有屬性

2.1 使用 static 宣告內部類

如果一個內部類用static宣告，則此內部類稱為外部類，可以在類的外部呼叫，如果想要呼叫外部類的屬性，則必須宣告為static型別

class Outer{
    private static String info="hello world!";  // 外部類私有屬性
    static class Inner{  // 定義內部類
        public void print(){
            System.out.println(info);
        }
    }

    public void fun(){  // 定義外部類的方法
        new Inner().print();  // 通過內部類的例項化呼叫方法
    }
}

public class ChapterFive {
    public static void main(String[] args){
        new Outer.Inner().print();  // 呼叫外部類的print方法
    }
}

2.2 在外部訪問內部類

一個內部類可以在外部類中被訪問，也可以直接在其它類中呼叫，呼叫格式為：
外部類. 內部類 內部類物件 = new 外部類例項.new 內部類( );

class Outer{
    private String info="hello world!";  // 外部類私有屬性
    class Inner{  // 定義內部類
        public void print(){
            System.out.println(info);
        }
    }

    public void fun(){  // 定義外部類的方法
        new Inner().print();  // 通過內部類的例項化呼叫方法
    }
}

public class ChapterFive {
    public static void main(String[] args){
        Outer out = new Outer();   // 外部類例項化物件
        Outer.Inner in = out.new Inner();   // 例項化內部類物件
        in.print();    // 呼叫內部類的方法
    }
}

2.3 在方法中定義內部類

一個內部類可以定義在任意的位置，我們看一下在方法中定義的內部類

class Outer{
    private String info="hello world!";  // 定義外部類私有屬性
    public void fun(final int temp){  // 定義外部類的方法
        class Inner{                  // 在方法中定義內部類
            public void print(){      // 定義內部類的方法
                System.out.println("類中的屬性：" + info);  // 直接訪問外部類的私有屬性
                System.out.println("方法中的引數：" + temp);
            }
        }
        new Inner().print();
    }
}

public class ChapterFive {
    public static void main(String[] args){
        new Outer().fun(30);   // 呼叫外部類的方法
    }
}