Java--内部类总结

内部类：外部类中再定义一个类，这个类作为外部类中的一个成员，并且依附于外部类而存在;

 1.内部类可以直接访问外部类中的成员，包括私有;外部类要访问内部类，必须建立内部类对象
 2.内部类可为静态，可用protected private修饰，而外部类不可以，外部类只能使用public ,default修饰
 3.内部类是一个编译时的概念，一旦编译成功，就会成为完全不同的两类，对于一个名为outer的外部类
    和其内部定义的名为inner的内部类。编译完成后出现outer.class和outer$inner.class两类。

内部类的优点：
 1.内部类作为外部类的成员，可以访问外部类的私有成员或属性
 2.用内部类定义在外部类中不可访问的属性，这样就在外部类中实现了比外部类的private还要小的访问权限
 3.隐藏一些不想让别人知道的操作

1.成员内部类：定义在外部类的成员位置上
 作为外部类的一个成员存在，与外部类的属性、方法并列。
 内部类和外部类的实例变量可以共存，
 在内部类中访问实例变量：this.属性
 在内部类访问外部类的实例变量：外部类名.this.属性。

class Outer{
	//内部类可以直接访问外部类中成员，包括私有成员
	private int age=24;
	String name="lidaofu";
	class Inner{
		int age=25;
		public void show(){
			System.out.println("name="+name);
			//内部类中访问自己的实例变量this.属性
			System.out.println("inner age="+this.age);
			//内部类中访问外部类的实例变量:外部类名.this.属性
			System.out.println("outer age="+Outer.this.age);
		}
	}
	public void method(){
		//内部类定义在外部类的成员位置上时，外部类访问内部类，必须先建立内部类对象
		Inner in=new Inner();
		in.show();
	}
}
public class InnerTest{
	public static void main(String[] args){
		Outer out=new Outer();
		out.method();
		//建立内部类对象
		Outer.Inner in=new Outer().new Inner();
		in.show();
	}
}

2.局部内部类：在方法中定义的内部类称为局部内部类
 与局部变量类似，在局部内部类前不加修饰符public和private，其范围为定义它的代码块。
 局部内部类不仅可以访问外部类实例变量，还可以访问外部类的局部变量（但此时要求外部类的局部变量必须为final）
 在类外不可直接生成局部内部类（保证局部内部类对外是不可见的）。
 要想使用局部内部类时需要生成对象，对象调用方法，在方法中才能调用其局部内部类。

class Outer{
	private int age=24;
	String name="lidaofu";
	public void show(){
		//局部内部类访问局部变量时，局部变量必须被final修饰
		final String sex="man";
		//具有局部变量所具有的特性
		class Inner{
			int age=23;
			public void out(){
				System.out.println("name="+Outer.this.name);
				System.out.println("Outer age="+Outer.this.age);
				//局部内部类不仅可以访问外部类的属性，还可以访问局部中的变量
				System.out.println("sex="+sex);
				System.out.println("Inner age="+age);
			}
		}
		//在外部类的方法中生成内部类对象，调用内部类中的方法
		Inner in=new Inner();
		in.out();
	}
}
public class InnerTest{
	public static void main(String[] args){
		//外部类无法直接生成局部内部类,必须通过生成外部类通过调用外部类的方法来调用内部类
		Outer out=new Outer();
		out.show();
	}
}

静态内部类：定义在外部类的成员位置上，被static所修饰
 静态内部类只能访问外部类的静态成员。
 生成一个静态内部类不需要外部类成员，静态内部类的对象可以直接生成：Outer.Inner in=new Outer.Inner()；
 当类与接口（或者是接口与接口）发生方法命名冲突的时候，此时必须使用内部类来实现。
 用接口不能完全地实现多继承，用接口配合内部类才能实现真正的多继承。

class Outer{
	private static int age=24;
	static String name="lidaofu";
	//被static所修饰，具有static所具有的特性(这里不可用private来修饰，不然在外部无法直接来创建内部类对象)
	static class Inner{
		String sex="man";
		public void out(){
			//外部类和内部类中的变量不同名时，可以省略Outer.this.属性
			System.out.println("name="+name);
			//静态内部类只能访问被static修饰的外部类成员
			System.out.println("Outer age="+age);
			System.out.println("set="+sex);
		}
	}
}
public class InnerTest{
	public static void main(String[] args){
		//可以不用创建外部类而直接创建内部类对象
		Outer.Inner in=new Outer.Inner();
		in.out();
	}
}

匿名内部类:匿名内部类是一种特殊的局部内部类，其实就是内部类的简写形式
 定义匿名内部类的前提：内部类必须是继承一个类或者实现接口
 匿名内部类的格式：new 父类或者接口(){定义子类的内容}
 匿名内部类中定义的方法最好不要超过3个
 匿名内部类是唯一一种无构造方法类
 因其为局部内部类，那么局部内部类的所有限制都对其生效
 匿名内部类在编译的时候由系统自动起名Out$1.class

 

interface Test{
	public void out();
}
class Inner{
	 String name="lidaofu";
	 int age=24;
	
	 public void show(){
		String sex="man";
		//匿名内部类,定义在局部变量上，具有局部内部类的特性
		Test t=new Test(){
			public void out(){
			System.out.println("name="+name);
			System.out.println("age="+age);
			//System.out.println("sex="+sex); 错误，这一句是无法通过编译的，因为sex没有被final所修饰
			}
		};
		t.out();
	}
	/*
		其实匿名内部类也可以定义在成员变量上，只要在用时，在外部类中定义个方法调用即可
		Test t=new Test(){
			public void out(){
				System.out.println("name="+name);
			    System.out.println("age="+age);
			};
		}
		public void show(){
			t.out();
		}
		*/
	
}
public class InnerTest{
	public static void main(String[] args){
		Inner in=new Inner();
		in.show();
	}
}