Java基础知识、十二（内部类）

Java中的内部类

一、什么是内部类？

           将一个java类定义到另一个java类中的java类就是内部类。

           外部类---包含内部类的类。

           内部类---外部类中的类。

           内部类编译后会形成一个新的字节码文件【外部类类名$内部类类型.class】

二、内部类有几种表现形式分别都是如何编写的？每一种内部类各自都有哪些特征？

       1、成员内部类--类中方法外【成员变量】

pubic  class  Hello{
public class  World{
}
}

package com.wangxing.test1;

public class Hello {
	public String hello_name="外部类实例变量";
	public static String HELLO_STATIC_NAME="外部静态变量";
//外部类构造方法
	public Hello() {
		// TODO 自动生成的构造函数存根
		System.out.println("外部类的构造方法");
		//8.外部类中的构造方法可以访问成员内部类的构造方法，实例方法/变量【对象方法】，
		World wneibu=new World("world");
		System.out.println(wneibu.world_name);
		wneibu.worldShiliMethod();
		
	}
//外部类实例方法
	public void helloshiliMethod(){
		System.out.println("外部类的实例方法");
		//9.外部类中的实例方法可以访问成员内部类的构造方法，实例方法/变量【对象方法】，
		World wneibu=new World("world");
		System.out.println(wneibu.world_name);
		wneibu.worldShiliMethod();
	}
//外部类的类方法（静态方法）
	public static void helloStaticMethod(){
		System.out.println("外部类的类方法（静态方法）");
		//10.外部类中的类方法可以访问成员内部类中的元素
		/*若是想访问则需要实例化一个外层对象来限定分配
		 * 在方法中创建类Person，视为方法内部类，可以在方法体内直接new Person() 获得该类实例。
                            在方法外创建的类Person，如果方法是static修饰的
                            ，如static main()，而类没有用static修饰，
                            要在static main方法中获得实例Person对象，
                            则 需要先实例化一个外层的对象A,再通过A.new来获得Person对象
		 */
		//World wneibu=new World("world");
		Hello ha=new Hello();//实例化外层对象A
		World wneibu=ha.new World("world"); 
		//这样写也可以其本质都是实例化一个外部类来限定分配
		//World wneibu=new Hello().new World("world");
		System.out.println(wneibu.world_name);
		wneibu.worldShiliMethod();
		 System.out.println(World.wostatic); 
	}
	
//成员内部类
//1.成员内部类可以使用任意的访问限制修饰符
//2.成员内部类可以有实例变量，静态常量，实例方法，构造方法，不能有静态方法
 //方法内部类中不能定义静态方法，只能在顶级类型或者静态类型中才能声明静态方法）
//（想要用静态变量必须用final修饰初始化，为静态常量）
public class World{
	//内部类的静态常量
	public static final String wostatic="静态常量";
	//内部类的实例变量
		public String world_name="内部类的实例变量";
		
		//内部类带参数的构造方法
		public World(String testname){
			System.out.println("内部类带参数的构造方法，参数是=="+testname);
			
			}
		//内部类的实例方法
		public void worldShiliMethod(){
			System.out.println("内部类的实例方法");
		}
		//内部类的构造函数
				public World() {
					// TODO 自动生成的构造函数存根
	//3.成员内部类中的构造方法可以访问本成员内部类中的其他构造方法【new】
	//可以访问实例变量/实例方法【对象.实例变量/方法，this.实例变量/方法，可以省略对象/this】
					World w=new World("world");//实质上==new Hello.World.World()
					System.out.println(w);
					System.out.println(w.world_name);
					System.out.println(this.world_name);
					System.out.println(world_name);
					w.worldShiliMethod();
					this.worldShiliMethod();
					worldShiliMethod();
	//5.成员内部类中的构造方法可以访问外部类的构造方法，实例方法/变量，类方法/变量
					  //Hello hellothis=Hello.this;---外部类对象（这里this指的是什么？指的是外部类Hello.this表示外部类调用指向所以它指的就是外部类对象）
					Hello h=new Hello();
					System.out.println(h.hello_name);
					System.out.println(Hello.this.hello_name);
					System.out.println(hello_name);
					h.helloshiliMethod();
					Hello.this.helloshiliMethod();
					helloshiliMethod();
					//成员内部类中访问外部类的静态元素
					System.out.println(h.HELLO_STATIC_NAME);
					System.out.println(Hello.this.HELLO_STATIC_NAME);
					System.out.println(Hello.HELLO_STATIC_NAME);
					System.out.println(HELLO_STATIC_NAME);
					h.helloStaticMethod();
					Hello.this.helloStaticMethod();
					Hello.helloStaticMethod();
					helloStaticMethod();
				}//成员内部类的构造方法测试结束了
				//成员内部类的实例方法
				public void worldTestShiliMethod(){
					System.out.println("成员内部类的实例方法");
					//成员内部类中的实例方法可以访问构造方法【new】
					//可以访问实例变量/方法【对象.实例变量/方法，this.实例变量/方法，可以省略对象/this】
					World w2=new World("world");
					System.out.println(w2.world_name);
					System.out.println(this.world_name);
					System.out.println(world_name);
					w2.worldShiliMethod();
					this.worldShiliMethod();
					worldShiliMethod();
					//6.成员内部类中的实例方法可以访问外部类的构造方法，实例方法/变量，类方法/变量
					Hello h2=new Hello();
					System.out.println(h2.hello_name);
					System.out.println(Hello.this.hello_name);
					System.out.println(hello_name);
					h2.helloshiliMethod();
					Hello.this.helloshiliMethod();
					helloshiliMethod();
					//内部类的实例方法中访问外部类的静态元素
					System.out.println(h2.HELLO_STATIC_NAME);
					System.out.println(Hello.this.HELLO_STATIC_NAME);
					System.out.println(Hello.HELLO_STATIC_NAME);
					System.out.println(HELLO_STATIC_NAME);
					h2.helloStaticMethod();
					Hello.this.helloStaticMethod();
					Hello.helloStaticMethod();
					helloStaticMethod();
					
				}
				
		
	
	
	
}

	

}

//其他类中访问内部类，有两种访问方式：

1.导入成员内部类所在的包

2.用成员内部类所在类的类名.成员内部类的类名来创建对象

package com.wangxing.test1;

import com.wangxing.test1.Hello.World;

//11.其他类中是可以访问成员内部类的，需要依赖外部类对象，注意访问限制修饰符

//import com.wangxing.test1.Hello.World;

public class Other {
	//其他类的构造函数访问内部类
	public Other(){
		//第一种方式，导入内部类所在的包
		/*	
		Hello hello=new Hello();
			//不在一个内存中时想要访问内部类则必须先实例化一个外部类（外层实例）来限定分配即引导jvm找到内部类
			World w1=hello.new World();//内部类对象
			World w2=new Hello().new World();//内部类对象
			System.out.println(w2.world_name);
			w1.worldShiliMethod();
			*/
		//第二种方式
		Hello hello=new Hello();//外部类的对象
		//Hello.World指明内部类所在的位置
		Hello.World w1=hello.new World();//内部类的对象
		Hello.World w2=new Hello().new World();
		System.out.println(w2.world_name);
		w1.worldShiliMethod();
	}
	
	//其他类的实例方法访问内部类
	public void testOther(){
		//第一种方式，导入内部类所在的包
				/*	
				Hello hello=new Hello();
					//不在一个内存中时想要访问内部类则必须先实例化一个外部类（外层实例）来限定分配即引导jvm找到内部类
					World w1=hello.new World();//内部类对象
					World w2=new Hello().new World();//内部类对象
					System.out.println(w2.world_name);
					w1.worldShiliMethod();
					*/
				//第二种方式
				Hello hello=new Hello();//外部类的对象
				//Hello.World指明内部类所在的位置
				Hello.World w1=hello.new World();//内部类的对象
				Hello.World w2=new Hello().new World();
				System.out.println(w2.world_name);
				w1.worldShiliMethod();
	}
	//其他类的静态方法访问内部类
	public static void testStaticOther(){
		//第一种方式，导入内部类所在的包
		/*	
		Hello hello=new Hello();
			//不在一个内存中时想要访问内部类则必须先实例化一个外部类（外层实例）来限定分配即引导jvm找到内部类
			World w1=hello.new World();//内部类对象
			World w2=new Hello().new World();//内部类对象
			System.out.println(w2.world_name);
			w1.worldShiliMethod();
			*/
		//第二种方式
		Hello hello=new Hello();//外部类的对象
		//Hello.World指明内部类所在的位置
		Hello.World w1=hello.new World();//内部类的对象
		Hello.World w2=new Hello().new World();
		System.out.println(w2.world_name);
		w1.worldShiliMethod();
		
	}
	



}

总结：

1. 成员内部类可以使用任意的访问限制修饰符。
2. 成员内部类可以有实例变量、静态常量，实例方法、构造方法，不能有静态方法。（不能定义静态方法，只能在顶级类型或者静态类型中才能声明静态方法，想要有静态变量必须用final修饰初始化为静态常量）例如：public static final String wostatic="静态";
3. 成员内部类中的构造方法可以访问其他的构造方法【new】,可以访问实例变量/方法【对象.实例变量/方法 ,this.实例变量/方法,可以省略对象/this】。
4. 成员内部类中的实例方法可以访问构造方法【new】,可以访问实例变量/方法【对象.实例变量/方法 ,this.实例变量/方法,可以省略对象/this】。
5. 成员内部类中的构造方法可以访问外部类的构造方法，实例方法/变量，类方法/变量。
6. 成员内部类中的实例法可以访问外部类的构造方法，实例方法/变量，类方法/变量。
7. 外内部类中的构造方法/实例法可以访问成员内部类的构造方法，实例方法/变量，外内部类中的类方法也可以访问成员内部类。（类方法访问时需要需要实例化一个外层对象来限定分配）

例如：           

                    Hello ha=new Hello();//实例化外层对象A
                   World wneibu=ha.new World("world"); 
                   //这样写也可以其本质都是实例化一个外部类来限定分配
                   //World wneibu=new Hello().new World("world");

                    System.out.println(wneibu.world_name);
                    wneibu.worldShiliMethod();
                     System.out.println(World.wostatic); 

    8.其他类中是可以访问成员内部类的，需要依赖外部类对象，注意访问限制修饰符。

            2.方法内部类--类中方法中【局部变量】

例如:

package com.wangxing.test1;
//1.方法内部类不能使用任何访问限制修饰符
public class Hello {
	//外部实例变量
	public String hello_name="外部实例变量";
	//外部类变量【静态变量】
	public static String HELLO_STATIC_NAME="外部类变量";
	//10.外部类中不能访问方法内部类中的元素
	
	//外部类的构造方法
	public Hello(){
		System.out.println("外部类的构造方法");
	}
	//外部类被实例方法
	public void  helloShiliMethod(){
		System.out.println("外部类的实例方法");
		
	}
	//外部类的类方法【静态方法】
	public static void helloStaticMethod(){
		System.out.println("外部类的类方法");
	}
	//2.方法内部类可以有实例变量/方法，构造方法，不能有静态方法(如果要用静态变量则必须用常量表达式初始化【final】为静态常量)
	
	public void testHello1(){
		//方法的局部变量
		String testvalue="value";
		//方法内部类不能使用任何访问限制修饰符
		class WorldInner{
			//方法内部类的实例变量
			public String worldinner_name="方法内部类的实例变量";
			//在非静态内部类型中的字段 worldstatic_name 不能声明为 static，除非用常量表达式初始化。
			//方法内部类的静态变量【类变量】
			public final static String worldstatic_name="方法内部类的静态变量";
			
			//方法内部类的构造方法
			public WorldInner (String  testname){
				System.out.println("方法内部类的构造方法,参数是testname="+testname);	
			}

			//方法内部类的实例方法
			public void  woldinnerShiliMethod1(){
				System.out.println("方法内部类的实例方法");
			}
			//方法内部类的构造方法
			public WorldInner() {
				// TODO 自动生成的构造函数存根
				System.out.println("方法内部类的构造方法");
				//3.方法内部类的构造方法中可以访问本类的构造方法，实例变量/方法【对象/this，也可以省略】
				WorldInner inner=new WorldInner("test");
				System.out.println(inner.worldinner_name);
				System.out.println(this.worldinner_name);
				System.out.println(worldinner_name);
				//访问本类中的静态常量
				System.out.println(inner.worldstatic_name);
				//方法内部类中不能定义静态方法，只能在顶级类型或者静态类型中才能声明静态方法
				inner.woldinnerShiliMethod1();
				this.woldinnerShiliMethod1();
				woldinnerShiliMethod1();
				//5.方法内部类中的构造方法可以访问外部类的构造方法，实例方法/变量，类方法/变量。	
				Hello h=new Hello();
				System.out.println(h.hello_name);
				System.out.println(Hello.this.hello_name);
				System.out.println(worldinner_name);
				h.helloShiliMethod();
				Hello.this.helloShiliMethod();
				helloShiliMethod();
				System.out.println(h.HELLO_STATIC_NAME);
				System.out.println(Hello.this.HELLO_STATIC_NAME);
				System.out.println(Hello.HELLO_STATIC_NAME);
				System.out.println(HELLO_STATIC_NAME);
				h.helloStaticMethod();
				Hello.this.helloStaticMethod();
				Hello.helloStaticMethod();
				helloStaticMethod();
				//7.方法内部类中的构造方法可以访问本方法的局部变量。
				System.out.println(testvalue);
			}
			
			//方法内部类中的实例方法
			public void  woldinnerShiliMethod2(){
				System.out.println("方法内部类的实例方法");
				//4.方法内部类的实例方法中可以访问本类的构造方法，实例变量/方法，以及静态常量【对象/this，也可以省略】
				WorldInner inner=new WorldInner("test");
				System.out.println(inner.worldinner_name);
				System.out.println(this.worldinner_name);
				System.out.println(worldinner_name);
				//方问静态常量
				System.out.println(worldstatic_name);
				inner.woldinnerShiliMethod1();
				this.woldinnerShiliMethod1();
				woldinnerShiliMethod1();
				//6.方法内部类中的实例方法可以访问外部类的构造方法，实例方法/变量，类方法/变量。
				Hello h=new Hello();
				System.out.println(h.hello_name);
				System.out.println(Hello.this.hello_name);
				System.out.println(worldinner_name);
				h.helloShiliMethod();
				Hello.this.helloShiliMethod();
				helloShiliMethod();
				System.out.println(h.HELLO_STATIC_NAME);
				System.out.println(Hello.this.HELLO_STATIC_NAME);
				System.out.println(Hello.HELLO_STATIC_NAME);
				System.out.println(HELLO_STATIC_NAME);
				h.helloStaticMethod();
				Hello.this.helloStaticMethod();
				Hello.helloStaticMethod();
				helloStaticMethod();
				//8.方法内部类中的实例方法可以访问本方法的局部变量。
				System.out.println(testvalue);
				
			}
			
			
			
		}
		//9.定义本方法内部类的方法中可以访问方法内部类中的构造方法，实例变量/实例方法【对象访问】
		WorldInner inner=new WorldInner();
		System.out.println(inner.worldinner_name);
		System.out.println(inner.worldstatic_name);
		inner.woldinnerShiliMethod1();
	}
	
	
	

}

package com.wangxing.test1;

//1.方法内部类不能使用任何访问限制修饰
public class HelloDemo1 {
	//方法内部类可以在构造函数中
	public HelloDemo1() {
		// TODO 自动生成的构造函数存根
		class WoldInner{
			
		}
	}
	//方法内部类可以在实例方法中
	public void testHellodemo1(){
		class WoldInner{
			
		}
	}
	//放啊内部类可以在静态方法中
	public static void testStaticHelloDemo1(){
		class WorldInner{
			
		}
	}
	
	
}

总结：

1. 方法内部类不能使用任何访问限制修饰
2. .方法内部类可以有实例变量/方法，构造方法，不能有静态方法(如果要用静态变量则必须用常量表达式初始化【final】为静态常量)
3. 方法内部类可以访问本类的实例变量/方法【对象/this，也可以省略】，构造方法
4. 方法内部类可以访问本方法的局部变量【直接变量名称】
5. 方法内部类可以访问外部类的构造方法，实例方法/变量，类方法/变量。
6. 外部类是不能访问到方法内部类。

3.静态嵌套类---成员内部类使用static修饰【类变量】

package com.wangxing.test1;
//外部类
public class Hello{
		public String hello_name="外部类实例变量";
		public static String HELLO_STATIC_NAME="外部类类变量";
		//外部类的构造方法
		public Hello() {
			// TODO 自动生成的构造函数存根
			System.out.println("外部类的构造方法");
			//9.外部类中的构造方法可以访问静态嵌套类的构造方法，实例方法/变量【对象访问】
			//类方法/类变量【对象/类名访问】
			
		
		}
		//外部类的实例方法
		public void helloShiliMethod(){
			System.out.println("外部类的实例方法");
			//10.外内部类中的实例方法可以访问静态嵌套类的构造方法，实例方法/变量[对象访问]，
			//类方法/类变量[对象/类名访问]
			
		}
		//外部类的静态方法
		public static void helloStaticMethod(){
			System.out.println("外部类的类方法");
			//11.外内部类中的实例方法可以访问静态嵌套类的构造方法，实例方法/变量[对象访问]，
			//类方法/类变量[对象/类名访问]
			
		}
		//测试顶层类型
		//成员内部类
		//public class  shili{
			//public static class jingtai{
				
		//	}
		//}
		
		//静态嵌套类
		//1.静态嵌套类可以使用任意的访问限制修饰符。
		//2.静态嵌套类可以有实例变量、实例方法、构造方法，类变量，类方法。
		public static class World{
             // public static class jingtai{
				
			//}
			public String world_name="静态嵌套类实例变量";
			//在静态嵌套类中能定义静态变量而不用final修饰是因为静态嵌套类是一个静态内部类所以不用final修饰
			//静态方法要在内部类中定义则1.内部类必须是静态内部类
			//2.或者在顶级类型中才能声明静态方法
			//（至于顶级类型可能是包裹着内部类的类的最外层，测试的话可以试试多个类嵌套？ 
			//测试结果不是，顶级类型可能是静态类必须是最外层的不能被别的类包含，
			//而静态内部类和外部类可能是一种并列关系，并不是包含）
			public static String world_static_name="静态嵌套类类变量";
			//静态嵌套类构造方法
			public World(String testname){
				System.out.println("静态嵌套类的构造方法,参数是=="+testname);
			}
			//静态嵌套类的实例方法
			public void  worldShiliMethod(){
				System.out.println("静态嵌套类的实例方法");
			}
			//静态嵌套类的类方法
			public static void  worldStaticShiliMethod(){
				System.out.println("静态嵌套类的类方法");
			}
			//静态嵌套类的构造方法
			public World() {
				// TODO 自动生成的构造函数存根
				System.out.println("静态嵌套类的构造方法");
				//3.静态嵌套类中的构造方法可以访问本静态嵌套类中的其他的构造方法【new】,
				//可以访问实例变量/实例方法【对象.实例变量/方法,this.实例变量/方法,可以省略对象/this】
				//可以访问类变量/类方法【对象/类名.实例变量/方法,this.实例变量/方法,可以省略对象/this/类名】
				World w=new World("Word");
				System.out.println(w.world_name);
				System.out.println(this.world_name);
				System.out.println(world_name);
				w.worldShiliMethod();
				this.worldShiliMethod();
				worldShiliMethod();
				//静态嵌套类中的静态元素
				System.out.println(w.world_static_name);
				System.out.println(this.world_static_name);
				System.out.println(World.world_static_name);
				System.out.println(world_static_name);
				w.worldStaticShiliMethod();
				this.worldStaticShiliMethod();
				World.worldStaticShiliMethod();
				worldStaticShiliMethod();
				//6.静态嵌套类中的构造方法可以访问外部类的构造方法
				//可以访问外部类的实例方法/变量【只能对象】
				//可以访问外部类的类方法/变量【对象/类名.类变量/类方法,可以省略对象/类名】
				Hello hello=new Hello();
				System.out.println(hello.hello_name);
				hello.helloShiliMethod();
				System.out.println(hello.HELLO_STATIC_NAME);
				System.out.println(Hello.HELLO_STATIC_NAME);
				System.out.println(HELLO_STATIC_NAME);
				hello.helloStaticMethod();
				Hello.helloStaticMethod();
				helloStaticMethod();
				
			}
			
			//静态嵌套类实例方法
			public void  worldTestShiliMethod(){
				System.out.println("静态嵌套类实例方法");
				//4.静态嵌套类中的实例方法可以访问本静态嵌套类中的其他的构造方法【new】,
				//可以访问实例变量/实例方法【对象.实例变量/方法,this.实例变量/方法,可以省略对象/this】
				//可以访问类变量/类方法【对象/类名.实例变量/方法,this.实例变量/方法,可以省略对象/this/类名】
				World w=new World("world");
				System.out.println(w.world_name);
				System.out.println(this.world_name);
				System.out.println(world_name);
				w.worldShiliMethod();
				this.worldShiliMethod();
				worldShiliMethod();
				System.out.println(w.world_static_name);
				System.out.println(this.world_static_name);
				System.out.println(World.world_static_name);
				System.out.println(world_static_name);
				w.worldStaticShiliMethod();
				this.worldStaticShiliMethod();
				World.worldStaticShiliMethod();
				worldStaticShiliMethod();
				//7.静态嵌套类中的实例方法可以访问外部类的构造方法
				//可以访问外部类的实例方法/变量【只能对象】
				//可以访问外部类的类方法/变量【对象/类名.类变量/类方法,可以省略对象/类名】
				Hello h=new Hello();
				System.out.println(h.hello_name);
				h.helloShiliMethod();
				System.out.println(h.HELLO_STATIC_NAME);
				System.out.println(Hello.HELLO_STATIC_NAME);
				System.out.println(HELLO_STATIC_NAME);
				h.helloStaticMethod();
				Hello.helloStaticMethod();
				helloStaticMethod();
			}
			//静态嵌套类的类方法
			public static void worldTestStaticShiliMethod(){
				System.out.println("静态嵌套类的类方法");
				//5.静态嵌套类中的类方法可以访问本静态嵌套类中的其他的构造方法【new】,
				//可以访问实例变量/实例方法【对象.实例变量/方法】
				//可以访问类变量/类方法【对象/类名.类变量/类方法,可以省略对象/类名】
				World w=new World("world");
				System.out.println(w.world_name);
				w.worldShiliMethod();
				System.out.println(w.world_static_name);
				System.out.println(World.world_static_name);
				System.out.println(world_static_name);
				w.worldStaticShiliMethod();
				World.worldStaticShiliMethod();
				worldStaticShiliMethod();
				//8.静态嵌套类中外部类方法可以访问外部类的构造方法
				//可以访问外部类的实例方法/变量【只能对象】
				//可以访问外部类的类方法/变量【对象/类名.类变量/类方法,可以省略对象/类名】
				Hello h=new Hello();
				System.out.println(h.hello_name);
				h.helloShiliMethod();
				System.out.println(h.HELLO_STATIC_NAME);
				System.out.println(Hello.HELLO_STATIC_NAME);
				System.out.println(HELLO_STATIC_NAME);
				h.helloStaticMethod();
				Hello.helloStaticMethod();
				helloStaticMethod();
			}
			
		}
	
}

//其它类中访问静态嵌套类有两种方式

1.导入静态嵌套类所在类的包，然后直接用静态嵌套类的类名创建对象（导入包后就可以直接调用了）

2.借用外部类的类名来指定静态嵌套类，外部类的类名.静态嵌套类的类名  变量名=new 外部类类名.静态嵌套类类名

 

package com.wangxing.test1;

//import com.wangxing.test1.Hello.World;

//12.其他类中可以访问静态嵌套类中的构造方法，实例方法，实例变量，类方法，类变量
//注意是否导入静态嵌套类的程序包
public class Other {
	public Other() {
			/*
		// TODO 自动生成的构造函数存根
		//由于内部类是静态的所以可以直接调用
		World w1=new World();//内部类对象
		World w2=new World();//内部类对象
		System.out.println(w2.world_name);
		w1.worldShiliMethod();
		System.out.println(w2.world_static_name);
		System.out.println(World.world_static_name);
		w1.worldStaticShiliMethod();
		World.worldStaticShiliMethod();
			*/
		Hello.World w1=new Hello.World();//内部类对象
		//Hello.World指明内部类所在的位置
		Hello.World w2=new Hello.World();//内部类对象
		System.out.println(w2.world_name);
		w1.worldShiliMethod();
		//静态元素
		System.out.println(w2.world_static_name);
		System.out.println(Hello.World.world_static_name);
		w1.worldStaticShiliMethod();
		Hello.World.worldStaticShiliMethod();
		
	
	}
		//其他类的实例方法访问内部类
	  public void testOther(){
	    	/*
			
			World w1=new World(); //内部类对象
			World w2=new World();//内部类对象
			System.out.println(w2.world_name);
			w1.worldShiliMethod();
			System.out.println(w2.world_static_name);
			System.out.println(World.world_static_name);
			w1.worldStaticShiliMethod();
			World.worldStaticShiliMethod();
			*/
			Hello.World w1=new Hello.World(); //内部类对象
			Hello.World w2=new Hello.World();//内部类对象
			System.out.println(w2.world_name);
			w1.worldShiliMethod();
			//静态元素
			System.out.println(w2.world_static_name);
			System.out.println(Hello.World.world_static_name);
			w1.worldStaticShiliMethod();
			Hello.World.worldStaticShiliMethod();
		}
	//其他类的静态方法访问内部类
	  public static void testStaticOther(){
	    	/*

			World w1=new World(); //内部类对象
			World w2=new World();//内部类对象
			System.out.println(w2.world_name);
			w1.worldShiliMethod();
			System.out.println(w2.world_static_name);
			System.out.println(World.world_static_name);
			w1.worldStaticShiliMethod();
			World.worldStaticShiliMethod();
			*/
			Hello.World w1=new Hello.World(); //内部类对象
			Hello.World w2=new Hello.World();//内部类对象
			System.out.println(w2.world_name);
			w1.worldShiliMethod();
			//静态元素
			System.out.println(w2.world_static_name);
			System.out.println(Hello.World.world_static_name);
			w1.worldStaticShiliMethod();
			Hello.World.worldStaticShiliMethod();
		}

}

 

1. 静态嵌套类中可以有构造方法，实例变量/方法，类变量/方法。
2. 静态嵌套类中构造方法/实例方法可以访问本静态嵌套类中的构造方法，实例变量/方法，类变量/方法。
3. 静态内部类中类方法可以访问本静态嵌套类中的构造方法，实例变量/方法【只能对象】，类变量/方法.
4. 静态内部类中的构造方法/实例方法/类方法可以访问外部类的构造方法，实例变量/方法【只能对象】，类变量/方法。
5. 静态嵌套类中不能有this.
6. 外部类的构造方法/实例方法/类方法可以访问，静态内部类中构造方法，实例变量/方法【只能对象】，类变量/方法.
7. 其他类中可以访问静态嵌套类【new 外部类类名.静态嵌套类名()】。注意访问限制修饰符

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("重写接口的抽象方法");
			}
		});
	}
}

使用匿名内部类的

         优点:避免创建额外的独立子类

         缺点：不易理解，不易阅读