3分钟学会java内部类

成员内部类：

public class Outer {
	public int number;
	/*
	 * 1.成员内部类
	 * a.创建成员内部类的对象必须依赖与外部类对象
	 * b.成员内部类中不能有static成员
	 * c.访问外类的属性和方法可以通过外部类.this.xxxx
	 * d.外部类不能直接访问内部的成员，必须通过类部类的对象
	 */
	public class MemberInner{
		public int number;
		public void fun() {
			Outer.this.number=10;//访问外部类的属性
			System.out.println("成员内部中的number:"+number);
			System.out.println("成员内部中访问外部类的number:"+Outer.this.number);
		}
	}
	public void fun1() {
		MemberInner m=new MemberInner();
		m.number=6;
		m.fun();
	}
	public static void main(String[] args) {
		 new Outer().fun1();//调用fun1()
	}
}

运行结果

静态内部类：

/*
	 * 2.静态内部类
	 * a.创建静态内部类对象不依赖外部类对象，new 外部类.内不类()
	 * b.可以有static 成员
	 * c.外部不能直接访问静态内部类的非静态成员
	 * d.静态内部类中不能访问外部类的非静态成员
	 */
public class Outer {
	public int number;
	public static int count;
	public static class StaticTnner{
		public int number;
		public static int count;
		public void fun() {
			System.out.println("静态内部类的非静态number："+number);
		}
		public static void sfun() {
			Outer.count=9;  //静态内部类访问外部静态成员count
			System.out.println("静态内部类的静态成员count："+count);
			System.out.println("静态内部类访问外部静态成员count："+Outer.count);
		}
	}
	public void fun2() {
		//访问静态内部类的成员
		StaticTnner sta=new StaticTnner();
		StaticTnner.count=100;
		sta.number=2;
		sta.fun();
		StaticTnner.sfun();
	}
	public static void main(String[] args) {
		new Outer().fun2();
	}
}

运行结果：

局部内部类：

package com.outer.inner;
public class Outer{
	public void fun3() {
		final int testNumber=888;
		/*
		 * 3.局部内部类
		 * 同局部变量一样，方法中的内部类前面不能用public private,protectd,也不能用static修饰，但可以被final或abstract修饰。
		 * a.只能在代码块、方法体内和作用域中使用
		 * b.局部内部类访问作用域中的局部变量是该变量需要定义为常量或等效常量
		 * c.可以修饰为abstract(抽象类)
		 */
		class LocalInner{
			public int number;
			public void fun() {
				System.out.println("局部内部类中的number:"+number);
				System.out.println("局部内部类所在方法中的局部变量testNumber:"+testNumber);
				
			}
		}
		LocalInner localInner=new LocalInner();
		localInner.number=99;
		localInner.fun();
	}
	public static void main(String[] args) {
		new Outer().fun3();
	}
}

运行结果：

匿名内部类：

//Outer.java
package package com.anonymous;
public class Outer {
	public int number;
	public void fun4() {
		/*
		 * 4.匿名内部类
		 * a.必须继承一个类或者实现一个接口,如果抽象类或者接口，要求匿名内部类必须实现所有抽象方法
		 * b.不能定义构造方法
		 * c.可以定义代码快，用于实例初始化，但是不能定义静态代码快
		 * d.是局部内部类，符合局部内部类的特点（不能定义为抽象）
		 */
		AbstactInner in=new AbstactInner() {
			{
				number=1;
			}
			@Override
			public void absfun() {
				System.out.println("匿名内部类");
			}	
		};
		in.fun();
		in.absfun();
		AbstactInner.count=9;
		AbstactInner.sfun();
	}
}


//接口
/*AbstactInner.java*/
package package com.anonymous;

public abstract class AbstactInner {
	public int number;
	public static int count;
	public void fun() {
		System.out.println("抽象类中的成员number:"+number);
	}
	public static void sfun() {
		System.out.println("抽象类中静态方法访问静态成员count:"+count);
	}
	public abstract void absfun();
}

/*测试类Test.java*/
package com.anonymous;

public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Outer outer=new Outer();
		outer.fun4();
	}
}

运行结果：