Java内部类及匿名内部类

 什么时候用内部类？

    当描述事物是，事物的内部还有事物，该事物用内部类来描述。因为内部事物在使用外部事物的内容。

 

内部类定义在局部变量时，不可以被成员变量修饰符修饰，但可以直接访问外部类中的成员

 不可以访问它所在的局部变量，只能访问被fina修饰的局部变量；

 

内部类的访问规则：1>内部类可以直接访问外部类的成员，包括私有；

                                  2>外部类要访问内部类必须建立内部类对象；

 

访问格式:当内部类定义在外部类的成员变量上，而且非私有可以在外部其他类中，直接建立内部类对象

                 格式如：外部类名.内部类名 变量名 = 外部对象.内部对象

                               Out.Inner in = new Outer().new Inner(); 

            当内部类直接定义在外部类的成员变量上时，可以被成员变量修饰符修饰；

                         如：private：将内部类在外部类中封装；

                                static：  用static修饰时内部类就具有了static的特性；

 

在外部其他类中访问static格式内部类的非静态成员： new.Outer.Inner().方法名；

在外部其它类中访问static内部类的静态成员：Outer.Inner.方法名；

 

外部类中静态方法访问内部类中的静态方法：内部类名.内部静态方法名  例： Inner.function();

外部类中静态方法访问内部类中的非静态方法：内部类对象.方法名  例：new Inner.function();

内部类定义在局部时：1>不可以被成员修饰符修饰；

                                     2>可以直接访问外部类中的成员，但是不可以访问它所在局部中的变量，只能访问final修饰的局部变量；

成员位置上的内部类的举例：

<span style="font-size:18px;"><strong>public class Outer {
	int x = 4; 
	class Inner{//内部类
		int x = 5;
		public void function(){
			int x = 6;
			System.out.println("Inner的局部变量:" + x);
			System.out.println("Inner的成员变量" + this.x);
			System.out.println("Outer的成员变量" + Outer.this.x);
		}
	}
	static class Inner1{//静态内部类
		public void method() {
			System.out.println("静态内部类的非静态成员被访问");
		}
	    public static void method1(){
	    	System.out.println("静态内部类的静态成员被访问");
	    }
	}
	
	public static void show(){
		Inner1.method1();//外部类的静态方法调用静态内部类中的静态成员
		new Inner1().method();//外部类的静态方法调用静态内部类的非静态成员
	}
	
	public static void main(String[] args) {
		Outer o = new Outer();//创建外部类对象
		o.show();//调用方法
		
		Outer.Inner in = new Outer().new Inner();//创建内部类对象
		in.function();//访问非静态内部类
		
		new Outer.Inner1().method();//外部其他类访问静态内部类的非静态成员
		Outer.Inner1.method1();//外部其他类访问静态内部类的静态成员
	}
}
</strong></span>

局部位置上的内部类：

<span style="font-size:18px;"><strong>public class Outer2 {
	
	int x = 4;
	
	public void function(final int a){//有内部类时这必须是final修饰的
		final int x = 5;//外部类的局部变量被final修饰时才可以被内部类访问
		class Inner{//内部类
			public void show(){
				System.out.println(Outer2.this.x);//内部类访问外部类成员变量
				System.out.println(x);//内部类访问外部类局部变量
				System.out.println(a);//内部类访问局部变量的参数
			}
		}
		 new Inner().show();//创建内部类调用方法
	}
	public static void main(String[] args) {
		Outer2 po = new Outer2();//创建外部类对象
		po.function(1);//调用方法，同时调用内部类的方法
		po.function(2);
	}
}</strong></span>

匿名内部类就是内部类的简写格式。也是匿名子类对象；

匿名内部类的格式：new 父类或者接口（）{ 定义子类的内容}

定义匿名内部类的前提：内部类必须是一个类或者实现接口

 匿名内部类举例：

<span style="font-size:18px;"><strong>public abstract class A {
	
	public abstract void show();

}
public class OuterNiming {
			int x = 4;
	
//		class Inner extends A{//简化成匿名内部类
//			public void show(){
//				System.out.println(x);//内部类访问外部类局部变量
//			}
//		}
		public void function(){
//		 new Inner().show();//创建内部类的对象调用方法
			A a = new A(){//这部分用来替换掉注释的部分,这是接口的子类对象
				int x = 9;
				public void show(){	//重写接抽象类的方法	
					System.out.println("外部类的成员变量" + OuterNiming.this.x);//重写抽象类的方法
				System.out.println("匿名内部类的变量" + x);
				}
				public void meth(){
					System.out.println("自定义内容");
				}
			};
			a.show();
		    //a.meth();//不可以调用，接口中没有该方法
		}
		
	public static void main(String[] args) {
		
		new OuterNiming().function();//调用外部类的方法
	}
}
</strong></span>