java内部类用法解析

定义：一个类的定义放在另一个类的内部,这个类就叫做内部类。
java内部类分为:成员内部类、方法内部类、静态内部类、嵌套类。

package com.hmkcode;

/**
 * 成员内部类用法
 * 1链接到外部类: 创建了内部类对象时,它会与创造它的外围对象有了某种联系,于是能访问外围类的所有成员,不需任何特殊条件。
 * 2内部类可以使用外部类的成员实现:用外部类创建内部类对象时,此内部类对象会秘密的捕获一个指向外围类的引用.于是,可以通过这个引用来访问外部类的成员。
 * 3创建内部类对象时,必须与外围类对象相关联。(嵌套类除外)
 */
public class MemberInnerClass 
{	
	//定义外部类成员变量outerNum
	private int outerNum;
	
	//外部类无参构造器
	public MemberInnerClass(){}
	
	//外部类有参构造器
	public MemberInnerClass(int outerNum)
	{
		this.outerNum = outerNum;
	}
	
	//声明一个外部类方法
	public void outerFunction(){
		System.out.println("outerNum:"+outerNum);
	}
	
	//得到内部类的实例
	public Inner getInner(int innerNum){
		return new Inner(innerNum);
	}
	
	public class Inner
	{
		//定义内部类成员变量innerNum
		private int innerNum;
		
		//内部类无参构造器
		public Inner(){}
		
		//内部类有参构造器
		public Inner(int innerNum)
		{
			this.innerNum = innerNum;
		}
		
		//使用.this得到外部类对象的引用
		public MemberInnerClass getThisMemberInsideClass()
		{
			return MemberInnerClass.this;
		}
		
		//使用.new得到外部类对象的引用
		public MemberInnerClass getNewMemberInsideClass()
		{
			return new MemberInnerClass();
		}
		
		//调用外部类MemberInsideClass的方法outerFunction
		public void getOuterNum()
		{
			outerFunction();
		}
		
		//调用外部类MemberInsideClass的成员变量outerNum
		public void getOuterNum1(){
			System.out.println("outerNum:"+MemberInnerClass.this.outerNum);
		}
		
		//输出内部类的成员变量innerNum
		public void getInnerNum(){
			System.out.println("innerNum:"+innerNum);
		}
	}
	
	
	public static void main(String[] args) 
	{
		//实例化一个外部类
		MemberInnerClass outer = new MemberInnerClass(5);
		//通过外部类的对象来创建一个内部类的对象
		MemberInnerClass.Inner inner = outer.new Inner(6);
		//通过调用外部类的方法outerFunction输出成员变量outerNum
		inner.getOuterNum();
		//直接调用外部类MemberInsideClass的成员变量outerNum
		inner.getOuterNum1();
		//获取指向内部类的一个引用,调用内部类的方法getInnerNum()输出内部类的成员变量innerNum
		outer.getInner(6).getInnerNum();
	}

}

方法内部类用法解析

package com.hmkcode;

/**
 * 方法内部类调用解析
 * 1:方法内部类只能在定义该内部类的方法内实例化,不可以在此方法外对其实例化。
 * 2:方法内部类对象不能使用该内部类所在方法的非final局部变量。
 * 3:方法内部类不能定义修饰符。
 * 因为方法的局部变量位于栈上，只存在于该方法的生命期内。当一个方法结束,其栈结构被删除，局部变量成为历史。
 * 但是该方法结束之后，在方法内创建的内部类对象可能仍然存在于堆中！例如,如果对它的引用被传递到其他某些代码,
 * 并存储在一个成员变量内。正因为不能保证局部变量的存活期和方法内部类对象的一样长,所以内部类对象不能使用它们。
 */
public class MethodInnerClass {
	//定义一个final的成员常量str
	private final String str = "test";
	
	//定义外部类方法doSomeing,在此方法中定义内部类Inner
	public void doSomeing(){
		//定义一个final的成员常量num
		final int num = 10;
		//定义一个成员变量count
		int count;
		class Inner
		{
			//输出外部类的成员常量num
			public void getOuterField()
			{
				System.out.println(num);
			}
			
			//调用外部类的成员方法getStr
			public void getOuterMethod(){
				getStr();
			}
			
			//内部类不能使用方法的变量count
			public void getOuterCount(){
				//System.out.println(count);
			}
		}
		//创建内部类的一个实例
		Inner inner = new Inner();
		inner.getOuterField();
		inner.getOuterMethod();
	}
	
	//定义外部类方法getStr
	public void getStr(){
		System.out.println("str:"+str);
	}
	
	public static void main(String[] args) {
		//创建外部类MethodInnerClass的实例
		MethodInnerClass outer = new MethodInnerClass();
		//调用自己的成员方法
		outer.doSomeing();
	}

}