Java基礎知識13

阿新 • • 發佈：2020-12-19

技術標籤：java

內部類

1.什麼是內部類？

將一個java類定義到另一個java類中的java類就是內部類。
外部類---包含內部類的類。
內部類---外部類中的類。
內部類編譯後會形成一個新的位元組碼檔案【外部類類名$內部類型別.class】

2.內部類有幾種表現形式分別都是如何編寫的？每一種內部類各自都有哪些特徵？

1.成員內部類--類中方法外【成員變數】

1.成員內部類可以使用任意的訪問限制修飾符。
2.成員內部類可以有例項變數、例項方法、構造方法，不能有靜態元素。
3.成員內部類中的構造方法可以訪問其他的構造方法【new】,可以訪問例項變數/方法【物件.例項變數/方法 ,this.例項

變數/方法,可以省略物件/this】。
4.成員內部類中的例項方法可以訪問構造方法【new】,可以訪問例項變數/方法【物件.例項變數/方法 ,this.例項變數/方法,
可以省略物件/this】。
5.成員內部類中的構造方法可以訪問外部類的構造方法，例項方法/變數，類方法/變數。
6.成員內部類中的例項法可以訪問外部類的構造方法，例項方法/變數，類方法/變數。
7.外內部類中的構造方法/例項法可以訪問成員內部類的構造方法，例項方法/變數，外內部類中的類方法不能訪問成員內部類。
8.其他類中是可以訪問成員內部類的，需要依賴外部類物件，注意訪問限制修飾符。
例如:

package com.wangxing.neifangnei;
//成員內部類中方法訪問成員內部類元素
public class Hello {
   //成員內部類
   //1.成員內部類可以使用任意的訪問限制修飾符。
   //2.成員內部類可以有例項變數，例項方法，構造方法，不能有靜態元素
   public class World{
	   public String world_name="內部類例項變數";
	// public static String WORLD_NAME="內部類類變數";
	   public World(String testname){
		   System.out.println("內部類的構造方法,引數testname=="+testname);
	   }
	   public void worldShiLiMethod(){
		   System.out.println("內部類的例項方法");
	   }
    /* public static void worldStaticMethod(){
		   System.out.println("內部類的類方法");
	   }*/
	 
	   //3.成員內部類中的構造方法可以訪問本成員內部類中的其它構造方法【new】，
	   //可以訪問例項變數/例項方法【物件.例項變數/例項方法；this.例項變數/例項方法；可以省略物件/this】
	   public World(){
		   System.out.println("內部類的構造方法");
		   World w1=new World("zhangsan");
		   System.out.println(w1.world_name);
		   System.out.println(this.world_name);
		   System.out.println(world_name);
		   w1.worldShiLiMethod();
		   this.worldShiLiMethod();
		   worldShiLiMethod();
	   }
	  //4.成員內部類中的例項方法可以訪問本成員內部類中的構造方法【new] 
	  //可以訪問例項變數/例項方法【物件.例項變數/例項方法；this.例項變數/例項方法；可以省略物件/this】
	   public void worldTestShiLiMethod(){
		   System.out.println("內部類的例項方法");
		   World w1=new World("lisi");
		   System.out.println(w1.world_name);
		   System.out.println(this.world_name);
		   System.out.println(world_name);
		   w1.worldShiLiMethod();
		   this.worldShiLiMethod();
		   worldShiLiMethod();
	   }
   }
}

package com.wangxing.neifangwai;
//成員內部類中方法訪問外部類元素
public class Hello {
	   public String hello_name="外部類例項變數";
	   public static String HELLO_NAME="外部類類變數";
	   public Hello(){
		   System.out.println("外部類的構造方法");
	   }
	   public void helloShiLiMethod(){
		   System.out.println("外部類的例項方法");
	   }
	   public static void helloStaticMethod(){
		   System.out.println("外部類的類方法");
	   }
	   //成員內部類
	   //1.成員內部類可以使用任意的訪問限制修飾符。
	   //2.成員內部類可以有例項變數，例項方法，構造方法，不能有靜態元素
	   public class World{
		 
		   //5.成員內部類中的構造方法可以訪問外部類中的構造方法【new】，
		   //可以訪問例項變數/例項方法【物件.例項變數/例項方法；外部類名.this.例項變數/例項方法；可以省略物件/外部類名.this】
		   //可以訪問類變數/類方法【物件.類變數/類方法；外部類名.this.類變數/類方法；外部類名.類變數/類方法可以省略物件/外部類名.this/外部類名】
		   //Hello.this表示外部類物件
		   public World(){
			   System.out.println("內部類的構造方法");
			  Hello h1=new Hello();
			  System.out.println(h1.hello_name);
			  System.out.println(Hello.this.hello_name);
			  System.out.println(hello_name);
			  h1.helloShiLiMethod();
			  Hello.this.helloShiLiMethod();
			  helloShiLiMethod();
			  System.out.println(h1.HELLO_NAME);
			  System.out.println(Hello.HELLO_NAME);
			  System.out.println(Hello.this.HELLO_NAME);
			  System.out.println(HELLO_NAME);
			  h1.helloStaticMethod();
			  Hello.this.helloStaticMethod();
			  Hello.helloStaticMethod();
			  helloStaticMethod();
		   }
		  //6.成員內部類中的例項方法可以訪問 外部類中的構造方法【new】，
		  //可以訪問例項變數/例項方法【物件.例項變數/例項方法；外部類名.this.例項變數/例項方法；可以省略物件/外部類名.this】
		 //可以訪問類變數/類方法【物件.類變數/類方法；外部類名.this.類變數/類方法；外部類名.類變數/類方法可以省略物件/外部類名.this/外部類名】
		  //Hello.this表示外部類物件
		   public void worldTestShiLiMethod(){
			   System.out.println("內部類的例項方法");
			   Hello h1=new Hello();
				  System.out.println(h1.hello_name);
				  System.out.println(Hello.this.hello_name);
				  System.out.println(hello_name);
				  h1.helloShiLiMethod();
				  Hello.this.helloShiLiMethod();
				  helloShiLiMethod();
				  System.out.println(h1.HELLO_NAME);
				  System.out.println(Hello.this.HELLO_NAME);
				  System.out.println(Hello.HELLO_NAME);
				  System.out.println(HELLO_NAME);
				  h1.helloStaticMethod();
				  Hello.this.helloStaticMethod();
				  Hello.helloStaticMethod();
				  helloStaticMethod();
		   }
	   }
	}

package com.wangxing.waifangnei;
//外部類中的方法訪問本成員內部類中的元素
public class Hello {
	   //7.外部類中的構造方法可以訪問成員內部類中的構造方法【new】
	   //可以訪問例項方法/例項變數【物件.例項變數/例項方法】
	   public Hello(){
		   System.out.println("外部類的構造方法");
		   World w1=new World("world");
		   System.out.println(w1.world_name);
		   w1.worldShiLiMethod();
	   }
	   //8.外部類中的例項方法可以訪問成員內部類中的構造方法【new】
	   //可以訪問例項方法/例項變數【物件.例項變數/例項方法】
	   public void helloShiLiMethod(){
		   System.out.println("外部類的例項方法");
		   World w1=new World("world");
		   System.out.println(w1.world_name);
		   w1.worldShiLiMethod();
	   }
	   //9.外部類中的類方法不可以訪問成員內部類中的元素
	   public static void helloStaticMethod(){
		   System.out.println("外部類的類方法");
		   //World w1=new World("world");
		   //System.out.println(w1.world_name);
		   //w1.worldShiLiMethod();
	   }
	   //成員內部類
	   //1.成員內部類可以使用任意的訪問限制修飾符。
	   //2.成員內部類可以有例項變數，例項方法，構造方法，不能有靜態元素
	       public class World{
		   public String world_name="內部類例項變數";
		// public static String WORLD_NAME="內部類類變數";
		   public World(String testname){
			   System.out.println("內部類的構造方法,引數testname=="+testname);
		   }
		   public void worldShiLiMethod(){
			   System.out.println("內部類的例項方法");
		   }
	    /* public static void worldStaticMethod(){
			   System.out.println("內部類的類方法");
		   }*/
		
	}
}

package com.wangxing.qitaneifangnei;
//10.其他類中是可以訪問成員內部類的，需要依賴外部類物件，注意訪問限制修飾符
//其他內中的構造方法可以訪問成員內部類中的構造方法【new】；可以訪問例項變數/例項方法【物件.例項變數/例項方法】
//其他內中的例項方法可以訪問成員內部類中的構造方法【new】；可以訪問例項變數/例項方法【物件.例項變數/例項方法】
//其他內中的類方法可以訪問成員內部類中的構造方法【new】；可以訪問例項變數/例項方法【物件.例項變數/例項方法】
public class Other {
   public Other(){
	   /*
	    *1. 這種需要導包。
	   //import com.wangxing.qitaneifangnei.Hello.World;
	   Hello h=new Hello();//外部類物件
	   World w1=h.new World();//內部類物件
	   World w2=new Hello().new World();//內部類物件
	   System.out.println(w1.world_name);
	   w2.worldShiLiMethod(); 
	   */
	   //2.這種不需要導包
	   Hello h=new Hello();//外部類物件
	   Hello.World w1=h.new World();//內部類物件
	   Hello.World w2=new Hello().new World();//內部類物件
	   System.out.println(w1.world_name);
	   w2.worldShiLiMethod();
   }
   public void testOther(){
	   /*
	    *1. 這種需要導包。
	   //import com.wangxing.qitaneifangnei.Hello.World;
	   Hello h=new Hello();//外部類物件
	   World w1=h.new World();//內部類物件
	   World w2=new Hello().new World();//內部類物件
	   System.out.println(w1.world_name);
	   w2.worldShiLiMethod(); 
	   */
	   //2.這種不需要導包
	   Hello h=new Hello();//外部類物件
	   Hello.World w1=h.new World();//內部類物件
	   Hello.World w2=new Hello().new World();//內部類物件
	   System.out.println(w1.world_name);
	   w2.worldShiLiMethod();
   }
   public static void testStaticOther(){
	   /*
	    *1. 這種需要導包。
	   //import com.wangxing.qitaneifangnei.Hello.World;
	   Hello h=new Hello();//外部類物件
	   World w1=h.new World();//內部類物件
	   World w2=new Hello().new World();//內部類物件
	   System.out.println(w1.world_name);
	   w2.worldShiLiMethod(); 
	   */
	   //2.這種不需要導包
	   Hello h=new Hello();//外部類物件
	   Hello.World w1=h.new World();//內部類物件
	   Hello.World w2=new Hello().new World();//內部類物件
	   System.out.println(w1.world_name);
	   w2.worldShiLiMethod();
   }
}

2.方法內部類--類中方法中【區域性變數】

1.方法內部類不能使用任何訪問限制修飾
2.方法內部類可以有例項變數/方法，構造方法，不能有靜態元素。
3.方法內部類可以訪問本類的例項變數/方法【物件/this，也可以省略】，構造方法
4.方法內部類可以訪問本方法的區域性變數【直接變數名稱】
5.方法內部類可以訪問外部類的構造方法，例項方法/變數，類方法/變數。
6.外部類是不能訪問到方法內部類。
例如:

package com.wangxing.neifangnei;
//方法內部類中的方法訪問方法內部類中元素
public class Hello {
   //1.方法內部類中不能有任何訪問限制修飾符
   //2.方法內部類可以有例項變數/方法，構造方法，不能有靜態元素。
   public void  testHello1(){
		//方法的區域性變數
		String  testvalue="value";
      class World{
	   public String world_name="內部類例項變數";
	//public static String WORLD_NAME="內部類類變數";
	   public World(String testname){
		   System.out.println("內部類的構造方法,引數testname=="+testname);
	   }
	   public void worldShiLiMethod(){
		   System.out.println("內部類的例項方法");
	   }
    /* public static void worldStaticMethod(){
		   System.out.println("內部類的類方法");
	   }*/
	   //3.方法內部類中的構造方法可以訪問方法內部類中的其它構造方法【new】，
	   //可以訪問例項變數/例項方法【物件.例項變數/例項方法；this.例項變數/例項方法；可以省略物件/this】
	   public World(){
		   System.out.println("內部類的構造方法");
		   World w1=new World("zhangsan");
		   System.out.println(w1.world_name);
		   System.out.println(this.world_name);
		   System.out.println(world_name);
		   w1.worldShiLiMethod();
		   this.worldShiLiMethod();
		   worldShiLiMethod();
	   }
	  //4.方法內部類中的例項方法可以訪問方法內部類中的構造方法【new] 
	  //可以訪問例項變數/例項方法【物件.例項變數/例項方法；this.例項變數/例項方法；可以省略物件/this】
	   public void worldTestShiLiMethod(){
		   System.out.println("內部類的例項方法");
		   World w1=new World("lisi");
		   System.out.println(w1.world_name);
		   System.out.println(this.world_name);
		   System.out.println(world_name);
		   w1.worldShiLiMethod();
		   this.worldShiLiMethod();
		   worldShiLiMethod();
	   }
   }
   }
}

package com.wangxing.neifangwai;
//方法內部類中的方法訪問外部類的元素
public class Hello {
	   public String hello_name="外部類例項變數";
	   public static String HELLO_NAME="外部類類變數";
	   public Hello(){
		   System.out.println("外部類的構造方法");
	   }
	   public void helloShiLiMethod(){
		   System.out.println("外部類的例項方法");
	   }
	   public static void helloStaticMethod(){
		   System.out.println("外部類的類方法");
	   }
	 //2.方法內部類可以有例項變數/方法，構造方法，不能有靜態元素。
	   public void  testHello1(){
			//方法的區域性變數
			String  testvalue="value";
	        class World{
		   //5.方法內部類中的構造方法可以訪問外部類中的構造方法【new】，
		   //可以訪問例項變數/例項方法【物件.例項變數/例項方法；外部類名.this.例項變數/例項方法；可以省略物件/外部類名.this】
		   //可以訪問類變數/類方法【物件.類變數/類方法；外部類名.this.類變數/類方法；外部類名.類變數/類方法；可以省略物件/外部類名.this/外部類名】
		   //Hello.this表示外部類物件
		   public World(){
			   System.out.println("內部類的構造方法");
			  Hello h1=new Hello();
			  System.out.println(h1.hello_name);
			  System.out.println(Hello.this.hello_name);
			  System.out.println(hello_name);
			  h1.helloShiLiMethod();
			  Hello.this.helloShiLiMethod();
			  helloShiLiMethod();
			  System.out.println(h1.HELLO_NAME);
			  System.out.println(Hello.this.HELLO_NAME);
			  System.out.println(Hello.HELLO_NAME);
			  System.out.println(HELLO_NAME);
			  h1.helloStaticMethod();
			  Hello.this.helloStaticMethod();
			  Hello.helloStaticMethod();
			  helloStaticMethod();
			  //7.方法內部類中的構造方法可以訪問本方法的區域性變數。
			  System.out.println(testvalue);
		   }
		  //6.方法內部類中的例項方法可以訪問 外部類中的構造方法【new】，
		  //可以訪問例項變數/例項方法【物件.例項變數/例項方法；外部類名.this.例項變數/例項方法；可以省略物件/外部類名.this】
		 //可以訪問類變數/類方法【物件.類變數/類方法；外部類名.this.類變數/類方法；外部類名.類變數/類方法；可以省略物件/外部類名.this/外部類名】
		  //Hello.this表示外部類物件
		   public void worldTestShiLiMethod(){
			   System.out.println("內部類的例項方法");
			   Hello h1=new Hello();
				  System.out.println(h1.hello_name);
				  System.out.println(Hello.this.hello_name);
				  System.out.println(hello_name);
				  h1.helloShiLiMethod();
				  Hello.this.helloShiLiMethod();
				  helloShiLiMethod();
				  System.out.println(h1.HELLO_NAME);
				  System.out.println(Hello.this.HELLO_NAME);
				  System.out.println(Hello.HELLO_NAME);
				  System.out.println(HELLO_NAME);
				  h1.helloStaticMethod();
				  Hello.this.helloStaticMethod();
				  Hello.helloStaticMethod();
				  helloStaticMethod();
				//8.方法內部類中的例項方法可以訪問本方法的區域性變數。
				  System.out.println(testvalue);
		   }
	   }
	}
}

package com.wangxing.waifangnei;
//本方法內部類的方法中可以訪問方法內部類中的元素
public class Hello {
	   //2.方法內部類可以有例項變數/方法，構造方法，不能有靜態元素。
	   public void  testHello1(){
			//方法的區域性變數
			String  testvalue="value";
	    class World{
		   public String world_name="內部類例項變數";
		   public World(String  testname){
			   System.out.println("內部類的構造方法,引數testname=="+testname);
		   }
		   public World(){
			   System.out.println("內部類的無參構造方法");
		   }
		   public void worldShiLiMethod(){
			   System.out.println("內部類的例項方法");
		   }
	   }	
	       //9.定義本方法內部類的方法中可以訪問方法內部類中的構造方法，例項變數/例項方法【物件訪問】
	       World w3=new World();
	       System.out.println(w3.world_name);
	       w3.worldShiLiMethod();
	   }
}

3.靜態巢狀類---成員內部類使用static修飾【類變數】

1.靜態巢狀類中可以有構造方法，例項變數/方法，類變數/方法。
2.靜態巢狀類中構造方法/例項方法可以訪問本靜態巢狀類中的構造方法，例項變數/方法，類變數/方法。
3.靜態內部類中類方法可以訪問本靜態巢狀類中的構造方法，例項變數/方法【只能物件】，類變數/方法.
4.靜態內部類中的構造方法/例項方法/類方法可以訪問外部類的構造方法，例項變數/方法【只能物件】，類變數/方法。
5.靜態巢狀類中不能有this.
6.外部類的構造方法/例項方法/類方法可以訪問，靜態內部類中構造方法，例項變數/方法【只能物件】，類變數/方法.
7.其他類中可以訪問靜態巢狀類【new 外部類類名.靜態巢狀類名()】。注意訪問限制修飾符
例如：

package com.wangxing.neifangnei;
//靜態巢狀類中方法訪問靜態巢狀類中元素
public class Hello {
 //靜態巢狀類
 //1.靜態巢狀類可以使用任意的訪問限制修飾符。
 //2.靜態巢狀類可以有例項變數、例項方法、構造方法，類變數，類方法。
   public static class World{
	   public String world_name="內部類例項變數";
	   public static String WORLD_NAME="內部類類變數";
	   public World(String testname){
		   System.out.println("內部類的構造方法,引數testname=="+testname);
	   }
	   public void worldShiLiMethod(){
		   System.out.println("內部類的例項方法");
	   }
       public static void worldStaticMethod(){
		   System.out.println("內部類的類方法");
	   }
//3.靜態巢狀內部類中的構造方法可以訪問本成員內部類中的其它構造方法【new】，
//可以訪問例項變數/例項方法【物件.例項變數/例項方法；this.例項變數/例項方法；可以省略象/this】
//可以訪問類變數/類方法【物件.類變數/類方法；this.類變數/類方法；類名.類變數/類方法;可以省略物件/this/類名】
	   public World(){
		   System.out.println("內部類的構造方法");
		   World w1=new World("zhangsan");
		   System.out.println(w1.world_name);
		   System.out.println(this.world_name);
		   System.out.println(world_name);
		   w1.worldShiLiMethod();
		   this.worldShiLiMethod();
		   worldShiLiMethod();
		   System.out.println(w1.WORLD_NAME);
		   System.out.println(World.WORLD_NAME);
		   System.out.println(this.WORLD_NAME);
		   System.out.println(WORLD_NAME);
		   w1.worldStaticMethod();
		   this.worldStaticMethod();
		   World.worldStaticMethod();
		   worldStaticMethod();
	   }
//4.靜態巢狀內部類中的例項方法可以訪問本成員內部類中的構造方法【new] 
//可以訪問例項變數/例項方法【物件.例項變數/例項方法；this.例項變數/例項方法；可以省略象/this】
//可以訪問類變數/類方法【物件.類變數/類方法；this.類變數/類方法；類名.類變數/類方法;可以省略物件/this/類名】
	   public void worldTestShiLiMethod(){
		   System.out.println("內部類的例項方法");
		   World w1=new World("lisi");
		   System.out.println(w1.world_name);
		   System.out.println(this.world_name);
		   System.out.println(world_name);
		   w1.worldShiLiMethod();
		   this.worldShiLiMethod();
		   worldShiLiMethod();
		   System.out.println(w1.WORLD_NAME);
		   System.out.println(World.WORLD_NAME);
		   System.out.println(this.WORLD_NAME);
		   System.out.println(WORLD_NAME);
		   w1.worldStaticMethod();
		   this.worldStaticMethod();
		   World.worldStaticMethod();
		   worldStaticMethod();
	   }
//5.靜態巢狀內部類中的類方法可以訪問本成員內部類中的構造方法【new] 
//可以訪問例項變數/例項方法【物件.例項變數/例項方法；；不可以省略物件。不能有this】
//可以訪問類變數/類方法【物件.類變數/類方法；類名.類變數/類方法;可以省略物件/類名。不能this】
	   public static void worldTestStaticMethod(){
		   System.out.println("內部類的類方法");
		   World w1=new World("lisi");
		   System.out.println(w1.world_name);
		 //System.out.println(this.world_name);
		 //System.out.println(world_name);
		   w1.worldShiLiMethod();
		 //this.worldShiLiMethod();
		 //worldShiLiMethod();
		   System.out.println(w1.WORLD_NAME);
		 //System.out.println(this.WORLD_NAME);
		   System.out.println(World.WORLD_NAME);
		   System.out.println(WORLD_NAME);
		   w1.worldStaticMethod();
		 //this.worldStaticMethod();
		   World.worldStaticMethod();
		   worldStaticMethod();
	   }
   }
}

package com.wangxing.neifangwai;
//靜態巢狀類中方法訪問外部類中元素
public class Hello {
	   public String hello_name="外部類例項變數";
	   public static String HELLO_NAME="外部類類變數";
	   public Hello(){
		   System.out.println("外部類的構造方法");
	   }
	   public void helloShiLiMethod(){
		   System.out.println("外部類的例項方法");
	   }
	   public static void helloStaticMethod(){
		   System.out.println("外部類的類方法");
	   }
	 //靜態巢狀類
	 //1.靜態巢狀類可以使用任意的訪問限制修飾符。
	 //2.靜態巢狀類可以有例項變數、例項方法、構造方法，類變數，類方法。
	   public static class World{
		   //6.靜態巢狀內部類中的構造方法可以訪問外部類中的構造方法【new】，
		   //可以訪問例項變數/例項方法【物件.例項變數/例項方法；不可以省略物件】
		   //可以訪問類變數/類方法【物件.類變數/類方法；外部類名.類變數/類方法；可以省略物件/外部類名。不可以有this】
		   public World(){
			   System.out.println("內部類的構造方法");
			  Hello h1=new Hello();
			  System.out.println(h1.hello_name);
			//System.out.println(Hello.this.hello_name);
			//System.out.println(hello_name);
			  h1.helloShiLiMethod();
			//Hello.this.helloShiLiMethod();
			//helloShiLiMethod();
			  System.out.println(h1.HELLO_NAME);
			System.out.println(Hello.HELLO_NAME);
			  System.out.println(HELLO_NAME);
			  h1.helloStaticMethod();
			//Hello.this.helloStaticMethod();
			  Hello.helloStaticMethod();
			  helloStaticMethod();
		   }
		  //7.靜態巢狀內部類中的例項方法可以訪問 外部類中的構造方法【new】，
		  //可以訪問例項變數/例項方法【物件.例項變數/例項方法；不可以省略物件】
		  //可以訪問類變數/類方法【物件.類變數/類方法；外部類名.類變數/類方法；可以省略物件/外部類名。不可以有this】		  
		   public void worldTestShiLiMethod(){
			   System.out.println("內部類的例項方法");
			   Hello h1=new Hello();
				  System.out.println(h1.hello_name);
				//System.out.println(Hello.this.hello_name);
				//System.out.println(hello_name);
				  h1.helloShiLiMethod();
				//Hello.this.helloShiLiMethod();
				//helloShiLiMethod();
				  System.out.println(h1.HELLO_NAME);
				System.out.println(Hello.HELLO_NAME);
				  System.out.println(HELLO_NAME);
				  h1.helloStaticMethod();
				//Hello.this.helloStaticMethod();
				  Hello.helloStaticMethod();
				  helloStaticMethod();
		   }
		 //8.靜態巢狀內部類中的類方法可以訪問 外部類中的構造方法【new】，
		 //可以訪問例項變數/例項方法【物件.例項變數/例項方法；不可以省略物件】
		 //可以訪問類變數/類方法【物件.類變數/類方法；外部類名.類變數/類方法；可以省略物件/外部類名。不可以有this】
		   public static void worldTestStaticMethod(){
			   System.out.println("內部類的類方法");
			   Hello h1=new Hello();
				  System.out.println(h1.hello_name);
				//System.out.println(Hello.this.hello_name);
				//System.out.println(hello_name);
				  h1.helloShiLiMethod();
				//Hello.this.helloShiLiMethod();
				//helloShiLiMethod();
				  System.out.println(h1.HELLO_NAME);
				System.out.println(Hello.HELLO_NAME);
				  System.out.println(HELLO_NAME);
				  h1.helloStaticMethod();
				//Hello.this.helloStaticMethod();
				  Hello.helloStaticMethod();
				  helloStaticMethod();
		   }
	   }
	}

package com.wangxing.waifangnei;
//外部類中方法訪問靜態巢狀類中元素
public class Hello {
	   //9.外部類中的構造方法可以訪問靜態巢狀內部類中的構造方法【new】
	   //可以訪問例項方法/例項變數【物件.例項變數/例項方法】
	   //可以訪問類方法/類變數【物件.類方法/類變數；類名.類方法/類變數。不可以省略物件/類名】
	   public Hello(){
		   System.out.println("外部類的構造方法");
		   World w1=new World("world");
		   System.out.println(w1.world_name);
		   System.out.println(w1.WORLD_NAME);
		   System.out.println(World.WORLD_NAME);
		 //System.out.println(WORLD_NAME);
		   w1.worldShiLiMethod();
		   w1.worldStaticMethod();
		   World.worldStaticMethod();
	   }
	   //10.外部類中的例項方法可以訪問靜態巢狀內部類中的構造方法【new】
	   //可以訪問例項方法/例項變數【物件.例項變數/例項方法】
	   //可以訪問類方法/類變數【物件.類方法/類變數；類名.類方法/類變數。不可以省略物件/類名】
	   public void helloShiLiMethod(){
		   System.out.println("外部類的例項方法");
		   World w1=new World("world");
		   System.out.println(w1.world_name);
		   System.out.println(w1.WORLD_NAME);
		   System.out.println(World.WORLD_NAME);
		   w1.worldShiLiMethod();
		   w1.worldStaticMethod();
		   World.worldStaticMethod();
	   }
	   //11.外部類中的例項方法可以訪問靜態巢狀內部類中的類方法【new】
	   //可以訪問例項方法/例項變數【物件.例項變數/例項方法】
	   //可以訪問類方法/類變數【物件.類方法/類變數；類名.類方法/類變數。不可以省略物件/類名】
	   public static void helloStaticMethod(){
		   System.out.println("外部類的類方法");
		   World w1=new World("world");
		   System.out.println(w1.world_name);
		   System.out.println(w1.WORLD_NAME);
		   System.out.println(World.WORLD_NAME);
		   w1.worldShiLiMethod();
		   w1.worldStaticMethod();
		   World.worldStaticMethod();
	   }
	 //靜態巢狀類
	 	//1.靜態巢狀類可以使用任意的訪問限制修飾符。
	 	//2.靜態巢狀類可以有例項變數、例項方法、構造方法，類變數，類方法。
	       public static class World{
		   public String world_name="內部類例項變數";
		   public static String WORLD_NAME="內部類類變數";
		   public World(String testname){
			   System.out.println("內部類的構造方法,引數testname=="+testname);
		   }
		   public void worldShiLiMethod(){
			   System.out.println("內部類的例項方法");
		   }
	       public static void worldStaticMethod(){
			   System.out.println("內部類的類方法");
		   }
		
	}
}

package com.wangxing.qitaleifangnei;
//12.其他類中可以訪問靜態巢狀類中的構造方法【new】，例項方法/例項變數【物件訪問】，
//類方法/類變數【物件和類名都可以】
//注意是否匯入靜態巢狀類的程式包
public class Other {
	public Other(){
	/*
	 * import com.wangxing.qitaleifangnei.Hello.World;
	World w1=new World();
	System.out.println(w1.world_name);
	w1.worldShiLiMethod();
	System.out.println(w1.WORLD_NAME);
	System.out.println(World.WORLD_NAME);
	w1.worldStaticMethod();
	World.worldStaticMethod();
	*/
	Hello.World w1=new Hello.World();//內部類物件
	System.out.println(w1.world_name);
	w1.worldShiLiMethod();
	System.out.println(w1.WORLD_NAME);
	System.out.println(Hello.World.WORLD_NAME);
	w1.worldStaticMethod();
	Hello.World.worldStaticMethod();
}
	public void testShiLiMethod(){
		/*
		 * import com.wangxing.qitaleifangnei.Hello.World;
		World w1=new World();
		System.out.println(w1.world_name);
		w1.worldShiLiMethod();
		System.out.println(w1.WORLD_NAME);
		System.out.println(World.WORLD_NAME);
		w1.worldStaticMethod();
		World.worldStaticMethod();
		*/
		Hello.World w1=new Hello.World();//內部類物件
		System.out.println(w1.world_name);
		w1.worldShiLiMethod();
		System.out.println(w1.WORLD_NAME);
		System.out.println(Hello.World.WORLD_NAME);
		w1.worldStaticMethod();
		Hello.World.worldStaticMethod();
	}
	public static void testStaticMethod(){
		/*
		 * import com.wangxing.qitaleifangnei.Hello.World;
		World w1=new World();
		System.out.println(w1.world_name);
		w1.worldShiLiMethod();
		System.out.println(w1.WORLD_NAME);
		System.out.println(World.WORLD_NAME);
		w1.worldStaticMethod();
		World.worldStaticMethod();
		*/
		Hello.World w1=new Hello.World();//內部類物件
		System.out.println(w1.world_name);
		w1.worldShiLiMethod();
		System.out.println(w1.WORLD_NAME);
		System.out.println(Hello.World.WORLD_NAME);
		w1.worldStaticMethod();
		Hello.World.worldStaticMethod();
	}
}

4.匿名內部類---【沒有名字的內部類】就相當於某一個類/介面的子類,只是這個子類沒有名字

1.繼承式的匿名內部類

package com.wangxing.test1;
public class MyClass {
	public  void  testMyClass() {
		System.out.println("MyClass類的例項方法");
	}
}

package com.wangxing.test1;
//測試類
public class Test1 {
	public static void main(String[] args) {
		MyClass mc=new MyClass() {
			@Override
			public void testMyClass() {
			 System.out.println("重寫MyClass類的testMyClass方法");	
			}
		};
		mc.testMyClass();
	}
}

當一個類中的方法引數是抽象類型別時，我們可以傳遞上轉型物件/子類物件，如果不想額外的
建立一個子類，這時我們使用匿名內部類也是可以的

package com.wangxing.test1;
//建立一個抽象類
public abstract class TestClass {
	public abstract void  testTClass();
}

package com.wangxing.test1;
//普通類中引數為抽象類的例項方法
public class MyClass {
	public  void  testMyClass2(TestClass  tc) {
		tc.testTClass();
	}
}

package com.wangxing.test1;
//使用匿名內部類傳遞引數
public class Test1 {
	public static void main(String[] args) {
		MyClass mc=new MyClass();
		mc.testMyClass2(new TestClass() {
			@Override
			public void testTClass() {
				System.out.println("重寫抽象類TestClass的抽象方法");
			}
		});	
	}
}

2.介面式的匿名內部類

package com.wangxing.test2;
public interface MyInterface {
	void  testMethod();
}

package com.wangxing.test2;
public class Test2 {
	public static void main(String[] args) {
		MyInterface  inter=new MyInterface() {
			@Override
			public void testMethod() {
				System.out.println("重寫介面的抽象方法");
			}
		};
	}
}

當一個類中的方法引數是介面型別時，我們可以傳遞介面回撥物件/子類物件，如果不想額外的建立
一個介面的子類，這時我們使用匿名內部類也是可以的。

package com.wangxing.test2;
public interface MyInterface {
	void  testMethod();
}

package com.wangxing.test2;
public class DoClass {
	public  void  testDoMethod(MyInterface inter) {
		inter.testMethod();
	}
}


package com.wangxing.test2;
public class Test2 {
	public static void main(String[] args) {
		DoClass dc=new DoClass();
		dc.testDoMethod(new MyInterface() {
			@Override
			public void testMethod() {
				System.out.println("重寫介面的抽象方法");
			}
		});
	}
}

優點:避免建立額外的獨立子類
缺點：不易理解，不易閱讀

Java基礎知識13

內部類

Java基礎知識13

JAVA基礎知識複習-Springboot原理

JAVA基礎知識複習-JVM篇

Java基礎知識

java基礎知識 super和this使用解析

初識Java Java基礎知識

java基礎知識--資料型別

java基礎知識--入門程式說明

Java基礎知識-型別

java基礎知識--Object類

java基礎知識--Iterator迭代器

java基礎知識總結超詳細

Java基礎知識入門

java基礎知識--可變引數

java基礎知識--異常

自學Java基礎知識第三天

你不得不知的Java基礎知識

Java基礎知識回顧（陣列，函式，遞迴,物件，匿名內部類，介面，泛型）

《Java基礎知識》Java 淺拷貝與深拷貝

java基礎知識總結（續寫）

Java基礎知識13

內部類

相關推薦