Java的内部类

//学习笔记

内部类

内部类访问特点：
1，内部类可以直接访问外部类中的成员。
2，外部类要访问内部类，必须建立内部类的对象。

一般用于类的设计。

分析事物时，发现该事物描述中还有事物，而且这个事物还在访问被描述事物的内容。
这时就是“还有的事物”定义成内部类来描述。

    class Outer
    {
    	private static int num = 31;
    
    	class Inner// 内部类。
    	{
    		void show()
    		{
    			System.out.println("show run..."+num);
    		}
    		/*static void function()//如果内部类中定义了静态成员，该内部类也必须是静态的。
    		{
    			System.out.println("function run ...."+num);
    		}
    		*/
    	}
    
    	public void method()
    	{
    		Inner in = new Inner(); //外部类要访问内部类，必须建立内部类的对象
    		in.show();
    	}
    }
    
    
    class InnerClassDemo
    {
    	public static void main(String[] args) 
    	{
    //		Outer out = new Outer();
    //		out.method();
    	
    		//直接访问外部类中的内部类中的成员。
    //		Outer.Inner in = new Outer().new Inner();   //注意格式
    //		in.show();
    
    		//如果内部类是静态的。 相当于一个外部类
    //		Outer.Inner in = new Outer.Inner();  //格式不同
    //		in.show();
    
    		//如果内部类是静态的，成员也是静态的。
    //		Outer.Inner.function();  //不需要对象了
    		
    	}
    }

为什么内部类能直接访问外部类中成员呢？
那是因为内部类持有了外部类的引用： 外部类名.this

    class Outer
    {
    	int num = 3;
    	class Inner
    	{
    		int num = 4;
    		void show()
    		{
    			int num = 5;
    			System.out.println(Outer.this.num);  //输出3
    			System.out.println(this.num);        //输出4
    		}
    	}
    	void method()
    	{
    		new Inner().show();
    	}
    }
    
    
    class InnerClassDemo2 
    {
    	public static void main(String[] args) 
    	{
    		new Outer().method();
    	}
    }

内部类可以存放在局部位置上。
内部类在局部位置上，只能访问局部中被final修饰的局部变量。

    class Outer
    {
    	int num = 3;
    	Object method()
    	{
    
    		final int x = 9;
    
    		class Inner
    		{
    			void show()
    			{
    				System.out.println("show..."+x);
    			}
    		}
    
    		Object in = new Inner();
    		return in;//0x0045
    //		in.show();
    	}
    
    
    	
    }
    
    class InnerClassDemo3 
    {
    	public static void main(String[] args) 
    	{
    		Outer out = new Outer();
    		Object obj = out.method();//0x0045
    		System.out.println(obj);
    
    	}
    }

匿名内部类

匿名内部类。就是内部类的简写格式。

必须有前提：
内部类必须继承或者实现一个外部类或者接口。

匿名内部类：其实就是一个匿名子类对象。

格式：new 父类or接口(){子类内容}

    abstract class Demo
    {
    	abstract void show();
    }
    
    class Outer
    {
    	int num = 4;
    	
    	public void method()
    	{
    		
    		new Demo()//匿名内部类，其实这是Demo的子类
    		{
    			void show()  //覆盖了父类中的抽象方法
    			{
    				System.out.println("show ........"+num);
    			}
    		}.show();   //就是一种简写格式
    	}
    }
    
    
    class InnerClassDemo4 
    {
    	public static void main(String[] args) 
    	{
    		new Outer().method();  //输出4
    	}
    }

通常的使用场景之一：
当函数参数是接口类型时，而且接口中的方法不超过三个。
可以用匿名内部类作为实际参数进行传递。

    interface Inter
    {
    	void show1();
    	void show2();
    }
    class Outer
    {
    	
    	class Inner implements Inter
    	{
    		public void show1()
    		{
    		}
    		public void show2()
    		{
    		
    		}
    	}
    	
    
    	public void method()
    	{
 

			Inter in = new Inter()
			{
				public void show1()
				{
					
				}
				public void show2()
				{
				
				}
				
			};
		in.show1();
		in.show2();
	}
    }
    class InnerClassDemo5 
    {

	class Inner
	{
	}
		public static void main(String[] args) 
		{
		
			
			show(new Inter()
			{
				public void show1(){}
				public void show2(){}
			} ）;
		}
	}

细节：

        class Outer
    {
    	void method()
    	{
    		Object obj = new Object()
    		{
    			public void show()
    			{
    				System.out.println("show run");
    			}
    
    		};
    		obj.show();//因为匿名内部类这个子类对象被向上转型为了Object类型。
    					//这样就不能在使用子类特有的方法了。
    
    
    	}
    }
    
    class InnerClassDemo6 
    {
    	public static void main(String[] args) 
    	{
    		new Outer().method();
    	}
    }