內部類

基本介紹

一個類的內部又完整的嵌套了另一個類結構，被嵌套的類稱為內部類(inner class),嵌套其他類的類稱為外部類(outer class)，是我們類的第五大成員，內部類最大的特點就是可以直接訪問私有屬性，并且可以體現類與類之間的包含關系

基本語法：

class Outer{

	class Inner{

	}

}

內部類的分類：

1.定義在外部類區域位置上(比如方法內)：

1）.區域內那類(有類名)

2）.匿名內部類(沒有類名,重點);

定義在外部類的成員位置上：

1）成員內部類（沒用static 修飾）

2）靜態內部類（使用static 修飾）

區域內部類的使用：

區域內部類記住三點會比較好學：

（1）區域內部類定義在方法中/代碼塊

（2）作用域在方法體或者代碼塊中

（3）本質仍然是一個類

說明：區域內部類是定義在外部類的區域位置，比如方法中，并且有類名，

1.可以直接訪問外部類的所有成員，包含私有的 如下演示

class Outer{
	private int num=99;
	private void f1(){
		System.out.println("真好");
	}
	{
		class Inner{
			public void k() {
				System.out.println(num);//可以直接訪問到Outer類中的成員
				f1();//可以直接訪問到Outer類中的成員
			}
		}
	}
	
}

2.不能添加訪問修飾符，因為他的地位就是一個區域內部類，區域內部類是不能使用修飾符的，但是可以使用final修飾，因為區域變數也可以使用final

class Outer{
	private int num=99;
	private void f1(){
		System.out.println("真好");
	}
	{
        class Inner{//正確寫法
			public void k() {
				System.out.println(num);
				f1();
			}
		}
	 	final class Inner{}//正確寫法
        public class inner01{}//錯誤寫法
        //總結除final外的任何修飾符，都是錯誤寫法
	}
	
}

3.作用域：僅僅在定義他的方法或代碼塊中，

class Outer{
	private int num=99;
	private void f1(){
		System.out.println("真好");
	}
	{
		class Inner{
			public void k() {
				System.out.println(num);
				f1();
			}
		}
        Inner inner =new Inner();//正確寫法
	}
    Inner inner =new Inner();//錯誤寫法
	//總結出了方法或者代碼塊的作用域，都是錯誤寫法因為找不到
}

4.區域內部類—訪問—>外部類的成員[訪問方式：直接訪問]

class Outer{
	private int num=99;
	private void f1(){
		System.out.println("真好");
	}
	{
		class Inner{
			public void k() {
				System.out.println(num);//內部類可以直接訪問到外部類的成員
				f1();
			}
		}
	}
}

5.外部類—訪問—>區域內部類的成員 訪問方式：創建物件，在訪問（注意：必須在作用域內）

public class Usb {
	public static void main(String[] args) {
	}
}
class Outer{
	private int num=99;
	private void f1(){
		System.out.println("真好");
	}
	{
		class Inner{
			public void k() {
				System.out.println(num);
				f1();
			}
		}
        Inner inner=new Inner();//需要創建一個物件才可以訪問內部類的成員，還必須時在他的作用域中創建
        inner.k();
	}
}

6.外部其他類–不能訪問—>區域內部類（因為 區域內部類地位是一個區域變數）

public class Usb {
	public static void main(String[] args) {
        Inner inner=new Inner();//錯誤寫法
	}
}
class Outer{
	private int num=99;
	private void f1(){
		System.out.println("真好");
	}
	{
		class Inner{
			public void k() {
				System.out.println(num);
				f1();
			}
		}
	}
}

7.如果外部類和區域內部類的成員重名時，默認遵循就近原則，如果想訪問外部類的成員，則可以使用（外部類名.this.成員）去訪問

class Outer{
	private int num=99;
	private void f1(){
		System.out.println("真好");
	}
	{
		class Inner{
			private int num=9;
			public void k() {
				System.out.println(Outer.this.num);//類名.this可以找到這個類中的成員 this.可以找到類中的成員
				f1();
			}
		}
		Inner inner=new Inner();
		inner.k();
	}
}

匿名內部類：

匿名內部類的使用（重要）

（1）本質時類（2）內部類（3）該類沒有名字（4）同時還時一個物件

說明：匿名內部類時定義在外部類的區域位置，比如方法中并且沒有類名（表面沒有名字，但是在底層系統還是給分配了名字的）

1.匿名內部類的基本語法

public class Test {
	public static void main(String[] args) {
		temp anonymous=new temp() {
			public void h1() {
				System.out.println("驅羊攻虎");
			}
		};
		anonymous.h1();
		System.out.println(anonymous.getClass());//輸出匿名內部類的類名
	}
}
abstract class temp{
	public abstract void h1() ;
}

2.匿名內部類的語法比較奇特，請大家注意，因為匿名內部類既是一個類的定義同時他本身也是一個物件，因此從語法上看，他既有定義類的特征，也有創建物件的特征對前面代碼分析可以看出這個特點，因此可以呼叫匿名內部類方法，

3.可以直接訪問外部類的所有成員，包括私有的

public class Test {
    private static String str="以卵擊石";
	public static void main(String[] args) {
		temp anonymous=new temp() {
			public void h1() {
				System.out.println("驅羊攻虎\r"+str);//可以直接訪問外部類的所有成員，包括私有的
			}
		};
		anonymous.h1();
		System.out.println(anonymous.getClass());//輸出匿名內部類的類名
	}
}
abstract class temp{
	public abstract void h1() ;
}

4.不能添加訪問修飾符，因為他的地位就是一個區域變數而已，

5.作用域：匿名內部類與區域內部類一樣 僅僅在定義它的方法或代碼塊中

6.匿名內部類----訪問---->外部類成員[訪問方式：直接訪問]

7.外部其他類—不能訪問---->匿名內部類（因為 匿名內部類地位是一個區域變數）

8.如果外部類和匿名內部類的成員重名時，匿名內部類訪問的化，默認遵循就近原則，如果想要訪問外部類的成員，則可以使用（外部類名.this.成員）去訪問 如Test.this.str

成員內部類：

說明：成員內部類是定義在外部類的成員位置，并且沒有static修飾

基本用法：

public class InnerClassTest {

    public class InnerClassA {
        
    }
}

1.可以直接訪問外部類的所有成員，包含私有的

2.可以添加任意訪問修飾符(public、protected、默認、private), 因為它的地位就事一個成員，

3.作用域：和外部類的其他成員一樣，為整個類體，在外部類的成員方法中創建成員內部類物件，在呼叫方法，

4.成員內部類----訪問---->外部類(比如：屬性) [訪問方式：直接訪問]（說明）

5.外部類—>訪問---->內部類 (說明) 訪問方式：創建物件，在訪問

6.外部其他類----訪問---->成員內部類

7.如果外部類和內部類的成員重名時，內部類訪問的話，默認遵循就進原則，如果想訪問外部類的成員，則可以使用（外部類名.this.成員）去訪問

靜態內部類的使用：

說明：靜態內部類是定義在外部類的成員位置，并且有static修飾

public class InnerClassTest {

    static class InnerClassA {
        
    }

}

1.可以直接訪問外部類的所有靜態成員，包含私有的，但不能直接訪問非靜態成員

2.可以添加任意訪問修飾符(public、protected、默認、private),因為它的地位就是一個成員

3.作用域：同其他成員，為整個類體

4.靜態內部類—訪問—>外部類（比如：靜態屬性）[訪問方式：直接訪問所有靜態成員]

5.外部類—訪問—>靜態內部類 訪問方式：創建物件、在訪問

6.外部其他類—訪問—>靜態內部類

7.如果外部類和靜態內部類的成員重名時，靜態內部類訪問的時，默認遵循就近原則，如果想訪問外部類的成員，則可以使用（外部類名.this.成員）去訪問