java内部类

1.基本的内部类

package com.innerclass;
//1.内部类可以访问外部类的成员，但是外部类不可以访问内部类的成员
//2.想到方位内部类的变量，只有通过内部类的实例来实现
//3. 内部类不能定义静态成员
public class Outer {

	private int a1;
	private int a2;
	static int a3;
	public Outer(int a1,int a2)
	{
		this.a1=a1;
		this.a2=a2;
		
	}
	protected int methodA(){return a1*a2;}
	class Inner
	{
		
		int b1=a1;
		int b2=a2;
		int b3=a3;
		int b4=new Outer(3,4).a1;
		int b5=methodA();
				
	}
	public static void main(String[] args)
	{
		
		Outer.Inner b=new Outer(3,4).new Inner();
		System.out.println("b.b1="+b.b1);
		System.out.println("b.b2="+b.b2);
		System.out.println("b.b3="+b.b3);
		System.out.println("b.b4="+b.b4);
		System.out.println("b.b5="+b.b5);
		
	}
	
}

2、静态内部类

package com.innerclass;
/**
 * 静态内部类
 * @author Administrator
 *
 */
public class StaticInner {
	private int a1;
	private static int a2;
	public static class A
	{
		//int b1=a1;//编译出错，不能直接访问
		int b2=a2;
		int b4=new StaticInner().a1;//需要通过实例来访问
		static int b3=0;
		
		
	}
	public static void main(String[] args)
	{
		StaticInner.A a=new StaticInner.A();
		System.out.println(StaticInner.A.b3);
		//System.out.println(StaticInner.A.b2);//不能访问
		
	}
	

}

3.局部内部类

package com.inner;
/**
 * 局部内部类
 * 1.是在一个类的方法里面定义的，和局部变量一样，不能用private,public,protected修饰
 * 2.内部类的内部类也不能用上述的修饰
 * 3.局部内部类可以方位外部类的所有成员
 * @author Administrator
 *
 */
public class PartInnerClass {
	int a;
	public void method()
	{
		class B
		{
			int b=a;
			int c=0;
		
		}
		System.out.println(new B().b);
		
	}
	public static void main(String[] args)
	{
		new PartInnerClass().method();
		
	}
	}

4.匿名类

package com.inner;
/**
 *匿名类
 *1.匿名类没有构造函数，他会调用父类的构造函数
 *2. 匿名类在引用外部局部变量时，必须要定义为final
 *3.匿名类可以继承可以实现接口
 *4.匿名类的名字和方法对外是不可见的，可以封装
 *
 */
public class Anonymous {
	int a;
	Anonymous(int a){System.out.println("another constructor");}
	Anonymous(){System.out.println("default constructor");}
	void method(){System.out.println("from a");}
	public static void main(String[] args)
	{
		new Anonymous().method();
		Anonymous a=new Anonymous()
		{
			void method()
			{System.out.println("from anonymous");}
			
		};
		a.method();
		
		final int v=1;//在内部使用到v，必须定义为final
		Anonymous b=new Anonymous(v)
		{
			void method()
			{
				System.out.println("from anonymous"+v);
				
			}
		};
		b.method();
	}
}

5.继承内部类

package com.inner;
/**
 * 继承内部类
 * 1.必须要要构造函数里面先初始化所继承内部类的外部类
 * 2.
 * @author Administrator
 *
 */
public class ExtendsInner {

	private int a;
	public ExtendsInner(int a){this.a=a;}
	class B
	{
		int b=a;
		int c=0; 
		public    B(){}
	}
	public static void main(String[] args)
	{
		ExtendsInner e=new ExtendsInner(1);
		C c1=new C(e);
		System.out.println(c1.b);
		
	}

}
class C extends ExtendsInner.B
{
  C(ExtendsInner e)
  {
	e.super();
   }

}

6.内部类的用途

package com.inner;
/**
 *内部类的用途
 *1.封装.如果一个内部类仅仅为特定的方法提供服务，那么可以把内部类定义在方法里面 
 *2.可以直接访问外部的属性
 *3.回调
 */
public class UseInner {
	private class InnerTool{
		public int add(int a,int b)
		{
			return a+b;
		}
		public InnerTool getTool(){return new InnerTool();}
	}

}

package com.inner;
/**
 * 1.内部类实现回调
 *
 */
//可以调节温度的接口
interface Adjustable
{
 public void adjust(int temperature);	
}
//基础类，可以更改速度
class Base
{
private int speed;
public void adjust(int speed)
{
this.speed=speed;	
}
}
//利用回调，既可以实现调节温度，又可以调节速度
public class CallBack extends Base{
	private int temperature;
	private void adjustTemperature(int temperature)
	{
		this.temperature=temperature;
	}
	private class Closure implements Adjustable
	{
		public void adjust(int temperature)
		{adjustTemperature(temperature);}
	}
	public Adjustable getClassBackReference()
	{
		return new Closure();
		
	}
	public void main(String[] args)
	{
		CallBack cb=new CallBack();
		cb.adjust(1);
		Adjustable ad=cb.getClassBackReference();
		ad.adjust(1);
		
	}

}