关于JAVA里面的内部类的一些理解

         关于开通技术博客，其实我的心态就是为了有助于学习和交流。因为学习这个过程中，归纳和总结相当重要，每当遇到难的知识点，重要的知识点或者容易混淆的知识点，我们就需要不断地思考，然后进行归纳总结，方便于理解和记忆。好了下面开始进入正题了，由于前些日子学习JAVA的时候对于内部类的概念感觉还是有点模糊，于是我就又查找了一些资料进行学习，然后总结一下自己的结论和理解，进行了一些归纳。

        首先是关于内部类的定义：在一个外部类的内部再定义一个类，就是所谓的内部类。

        内部类的修饰符：内部类可以用的修饰符没啥特别的，跟普通方法一样，public，protected，private,default都可以。（外部类只能用public或者缺省）

        内部类的作用：为啥要用内部类呢？难道是闲的蛋疼？当然不是。内部类一般是继承自某个类或者实现某个接口，这样内部类就提供了可以继承多个具体或抽象类的能力，也就间接实现了所谓的“多重继承”（当然JAVA的类是不支持直接多重继承的，这里只是一种间接的方式而已，相当于实现了“多重继承”这个功能）。

        内部类的分类：内部类可以分为4种类型：1.成员内部类 2.局部内部类 3.静态内部类 4.匿名内部类。

       1.成员内部类：作为外部类的成员存在，与外部属性方法并列。

        

public class Outer {
	
	private static int i=1;
	
	private int j=10;
	
	private int k=20;
	
	class Inner {
		
		static int inner_i=0;/*这个语句很显然错了，非静态内部类
		中是不允许定义静态成员的，这是为什么呢，你试想一下，静态
		成员都是在编译的时候就加载到了方法区，但是作为内部类，必须
		等到外部类实例化后才会存在，这就互相矛盾了，所以当然不能有
		静态变量*/
		
		int j=100;//内部类外部类的实例变量可以共存
		
		void inner_f1(){
			System.out.println(this.j);//这里访问的是内部类中的j
			
			System.out.println(Outer.this.j);//这里访问的是外部类中的j
		}
		
	}
	//外部类非静态方法访问成员内部类
	public void outer_f1(){
		Inner inner=new Inner();
		inner.inner_f1();
	}
	
	public static void outer_f2(){
		Outer out=new Outer();
		//请注意了，这里想要访问内部类中的方法，必须先实例化一个外部类对象，因为这里是静态方法
		Inner inner=out.new Inner();
		//然后还要建立一个内部类的对象
		inner.inner_f1();
	}
	
	/*注意：内部类是编译时就加载的，一旦编译成功就成为不同的两个类
	    会出现outer.class和out$inner.class两个类文件名
	  PS：由于是演示代码，所以主函数没写什么的就不要在意啦*/

}

       2.局部内部类：在方法中定义的内部类，如局部变量类似，不能被访问，但是可以访问外部类中的所有成员。

        

public class Outer {
	
	private int i=100;
	
	private int out_j=1;
	
	public void out_f(){
		final int i=200;
		
		class Inner{
			int i=300;//可定义与外部类同名变量
			
			static int m=10;//错误，不能定义静态成员
			
			void inner_f(){
				System.out.println(this.i);//内部类中的i
				
				System.out.println(Outer.this.i);//外部内中的i
			}
			
		}
	}
	//PS:要访问局部内部类，必须先有外部对象
}

       3.静态内部类：与普通内部类的区别是，普通内部类会隐含保存一个引用，但是静态内部类不会。

       

public class Outer {
	
	private static int out_i=0;
	
	private int j=10;
	
	public static void out_f1(){
		
	}
	
	static class Inner{
		int inner_i=100;
		
		static void inner_f(){
			out_f1();//可以访问外部类中的静态方法
			
			System.out.println("Outer.i="+i);//错误，访问了外部类中的非静态成员
		}
	}
	public void out_f2(){
		Inner.inner_f();//外部类访问内部类静态成员
		
		Inner in=new Inner();//如果需要访问非静态成员，必须实例化内部类
		
		in.inner_i=10;
		
	}
	
	//PS:生成一个静态内部类不需要外部类成员，可以直接生成 Outer.Inner in=new Outer.Inner();
}

       4.匿名内部类：只能用到类的一个实例，一定在new的后面，实现一个接口或者类。

         

interface Car{
	public void run();
}

public class Outer {
	
	public static void main(String[]args){
		
		Car c=new Car(){
			public void run(){
				System.out.println("启动");
			}
		};//记住，这里一定要有分号
	}
}