浅谈内部类

public class OuterClass 
{
	private static int i = 1;
	private int j = 2;
	private int k = 3;
	private int p = 9;
	
	public OuterClass()
	{
		//InterClass ic = new InterClass();
		System.out.println("外部类");
	}
	
	public static void out_f1()
	{
		//
		System.out.println("外部类的静态方法");
	}
	
	public void out_f2()
	{
		//
		System.out.println("外部类的非静态方法");
	}
	
	/**
	 * 外部类的非静态方法 访问成员内部类
	 */
	public void out_f3()
	{
		Inner_Member im = new Inner_Member();
		im.inner_f1();
	}
	
	
	/**
	 * 外部类的静态方法访问成员内部类，与在外部类外部访问成员内部类一样
	 * 步骤1:建立外部类对象
	 * 步骤2:根据外部类对象建立内部类对象
	 * 步骤3:访问内部类的方法
	 */
	public static void out_f4()
	{
		OuterClass oc = new OuterClass();//外部类对象
		Inner_Member im = oc.new Inner_Member();//内部类对象
		im.inner_f1();
	}
	
	
	public static void main(String[] args) 
	{
		OuterClass oc = new OuterClass();//外部类对象
		
		out_f4();
		System.out.println("-------------------成员内部类-------------------------------");
		
		oc.out_f5(10);
		System.out.println("-------------------局部内部类-------------------------------");
		
		oc.out_f6();
		System.out.println("--------------------静态内部类------------------------------");
		
		
		
		System.out.println("---------------------匿名内部类-----------------------------");
	}
	
	
	/**1.成员内部类
	 * 即作为外部类的一个成员存在，与外部类的属性、方法并列。
	 * 
     * 注意：成员内部类中不能定义静态变量,但可以访问外部类的所有成员。
	 *
	 * 成员内部类的优点：
	 * ⑴ 内部类作为外部类的成员，可以访问外部类的私有成员或属性。（即使将外部类声明为PRIVATE，但是对于处于其内部的内部类还是可见的。）
	 * ⑵ 用内部类定义在外部类中不可访问的属性。这样就在外部类中实现了比外部类的private还要小的访问权限。
	 */
	private class Inner_Member
	{	
		int t = 12;
		int j = 11;
		//static int p = 5;//成员内部类中不能定义静态变量
		public Inner_Member ()
		{
			System.out.println("成员内部类");
		}
		
		void inner_f1()
		{
			System.out.println("外部变量 "+k);//外部类的变量如果和内部类的变量没有同名的，则可以直接使用变量名访问外部类的变量
			System.out.println("外部变量 "+OuterClass.this.i);
			System.out.println("外部变量 "+i);
			System.out.println("外部变量 "+OuterClass.this.j);//访问外部类中与内部类同名的变量可用'外部类名.this.变量名'
			
			System.out.println("内部变量 "+j);//在内部类中访问内部类自己的变量直接使用变量名
			System.out.println("内部变量 "+this.j);//也可以使用‘this.变量名’来访问内部类自己的变量
			System.out.println("内部变量 "+t);
			
			out_f1();
			out_f2();
			
		}
	}
	
	/**2.局部内部类
	 *  即在方法中定义的内部类，与局部变量类似，在局部内部类前不加修饰符public或private，其范围为定义它的代码块
	 * 注意：①局部内部类中不可定义静态变量
	 *      ②可以访问外部类的局部变量(即方法内的变量)，但是变量必须是final的
	 *
	 */
	public  void out_f5(int k)
	{
		final int s = 100;
		int f_i = 300;
		final int j = 200;
		
		class Inner_part
		{
			int s = 21;
			int p = 29;
			//static int m = 20;//不可以定义静态变量
			Inner_part(int k)
			{
				inner_f(k);
			}
			int inner_i = 22;
			
			void inner_f(int k)
			{
				System.out.println("外部类的实例变量 ："+i);//如果内部类没有与外部类同名的变量，在内部类中可以直接访问外部类的实例变量
				System.out.println("外部类的局部变量 ："+s);//可以访问外部类的局部变量(即方法内的变量)，但是变量必须是final的
				//System.out.println("外部类的局部变量 ："+f_i);
				System.out.println("内部类的变量 ："+p);//如果内部类中有与外部类同名的变量，直接用变量名访问的是内部类的变量
				System.out.println("内部类的变量 ："+this.p);//用"this.变量名" 访问的也是内部类变量
				System.out.println("外部类的变量 ："+OuterClass.this.p);//用外部"外部类类名.this.变量名" 访问的是外部类变量
//				OuterClass oc = new OuterClass();
//				System.out.println("外部类的变量 ："+oc.p);//如果内部类所在方法是静态方法，访问外部类变量需要创建外部类对象
				System.out.println("参数 ："+k);
			}
		}
		new Inner_part(k);
	}
	
	/**3.静态内部类
	 *  静态内部类定义在类中，任何方法外，用static定义
	 *  静态内部类可以用public,protected,private修饰
	 *注意：静态内部类中可以定义静态或者非静态的成员
	 */
	private static class Inner_Static
	{
		static int k = 31; 
		int j = 32;
		public Inner_Static()
		{
			System.out.println("静态内部类");
		}
		static void inner_f1()
		{
			System.out.println("访问外部类的变量："+i);//静态内部类只能直接访问外部类的静态成员
//			System.out.println("访问内部类的变量："+k);
//			System.out.println("访问外部类的变量："+);
//			System.out.println("访问外部类的变量："+k);
			out_f1();//包括静态变量和静态方法
//			out_f2();//静态内部类不能直接访问非静态变量和非静态方法，需创建外部类对象访问
			
			OuterClass oc = new OuterClass();
			oc.out_f2();
		}
		void inner_f2()
		{
			//
		}
	}
	/**
	 * 外部类访问静态内部类，对于其静态成员可以直接用内部类名访问，对于非静态成员需要实例化内部类
	 */
	public void out_f6()
	{
		System.out.println("外部访问静态内部类的静态变量"+Inner_Static.k);//  外部类访问内部类的静态成员：内部类.静态成员
		Inner_Static.inner_f1();
		
		//静态内部类可以直接创建类对象
		Inner_Static is = new Inner_Static();//  外部类访问内部类的非静态成员:实例化内部类即可
		System.out.println(is.j);
		is.inner_f2();
	}
	
	
	
	/**匿名内部类
	 * 
	 * 匿名内部类是一种特殊的局部内部类，它是通过匿名类实现接口
	 * 
	 * 匿名内部类的特点：
	 * 1，一个类用于继承其他类或是实现接口，并不需要增加额外的方法，只是对继承方法的事先或是覆盖。
	 * 2，只是为了获得一个对象实例，不需要知道其实际类型。
	 * 3，类名没有意义，也就是不需要使用到。
	 * 
	 * 注：一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类，没有类名，根据多态，
	 * 我们使用其父类名。因他是局部内部类，那么局部内部类的所有限制都对其生效。匿名内部类是唯一一
	 * 种无构造方法类。大部分匿名内部类是用于接口回调用的。匿名内部类在编译的时候由系统自动起名Out$1.class。
	 * 如果一个对象编译时的类型是接口，那么其运行的类型为实现这个接口的类。因匿名内部类无构造方法，
	 * 所以其使用范围非常的有限。当需要多个对象时使用局部内部类，因此局部内部类的应用相对比较多。
	 * 匿名内部类中不能定义构造方法。如果一个对象编译时的类型是接口，那么其运行的类型为实现这个接口的类。
	 */
	//具体实现一般是窗口监听时使用
	/*
	 * 
	 * void init(){
		p.add(yellow);
		p.add(blue);
		p.add(red);
		
		f.add(p);
		f.setSize(400, 300);
		f.setTitle("ActionDemo");
		f.setVisible(true);
		
		f.addWindowListener(new WindowAdapter(){
			public void windowClosing(WindowEvent e){
				f.setVisible(false);
				f.dispose();
				System.exit(0);
			}
		});
		yellow.addActionListener(new ButtonAction(Color.yellow));
		blue.addActionListener(new ButtonAction(Color.BLUE));
		red.addActionListener(new ButtonAction(Color.RED));
	}
	 */

	


}