Java内部类

内部类之成员内部类

内部类就是将一个类定义在一个类的内部，就是内部类

class Outer
{
	class Inner{}
}

内部类主要特点

• 内部类可以很好的实现隐藏，可以使用protected、private修饰符
• 内部类可以直接访问外部类的所有成员，包括私有的成员
• 外部类不能直接访问内部类的成员，必须首先建立内部类的对象才能访问

使用案例：

//外部类名.内部类名  实例 = 外部类实例名.new 内部类构造方法(参数)
Outer o = new Outer();
Outer.Inner test = o.new Inner();
test.InnerPrint();

class Outer
{
	int data;
	void printData(){
		System.out.println("外部类打印");
	}
	class Inner{
		int data;
		void InnerPrint(){
			System.out.println("内部类打印");
		}
	}
}

public class Test {
	public static void main(String[] args) {
		//外部类名.内部类名  实例 = 外部类实例名.new 内部类构造方法(参数)
		Outer o = new Outer();
		Outer.Inner test = o.new Inner();
		test.InnerPrint();
	}
}

执行结果：

成员内部类及应用

• 成员内部类属于外部类的实例成员，成员内部类可以有public，private，default，protected权限修饰符。

• 在成员内部类中访问外部类的成员方法和属性，要使用“外部类名.this.成员方法”和“外部类名.this.成员属性”的形式。

成员内部类使用外部类的方法和属性使用案例：

Outer.this.printData();
System.out.println("外部类data="+Outer.this.data);

class Outer
{
	int data;
	void printData(){
		System.out.println("外部类打印");
	}
	class Inner{
		int data;
		void InnerPrint(){
			System.out.println("内部类打印");
			Outer.this.printData();
			System.out.println("外部类data="+Outer.this.data);
		}
	}
}

public class Test {
	public static void main(String[] args) {
		//外部类名.内部类名  实例 = 外部类实例名.new 内部类构造方法(参数)
		Outer o = new Outer();
		o.data = 20;
		Outer.Inner test = o.new Inner();
		test.InnerPrint();
	}
}

执行结果：

外部类使用成员内部类的方法和属性使用案例：

void visitInner(){
	Inner i= new Inner();   //需要实例化内部类成员才能访问内部类里的方法，属性
	i.data = 90;     //通过实例去访问内部类成员的属性
	System.out.println("外部打印内部类的data="+i.data);
}

class Outer
{
	int data;
	void printData(){
		System.out.println("外部类打印");
	}
	void visitInner(){
		Inner i= new Inner();
		i.data = 90;
		System.out.println("外部打印内部类的data="+i.data);
	}
	class Inner{
		int data;
		void InnerPrint(){
			System.out.println("内部类打印");
		}
	}
}

public class Test {
	public static void main(String[] args) {
		//外部类名.内部类名  实例 = 外部类实例名.new 内部类构造方法(参数)
		Outer o = new Outer();
		o.visitInner();
	}
}

执行结果：

另一种实现方式：

class Outer
{
	int data;
	void printData(){
		System.out.println("外部类打印");
	}
	void initInner(int data){
		i = new Inner();
		i.data = data;
	}
	void visitInner(){
		System.out.println("外部打印内部类的data="+i.data);
	}
	class Inner{
		int data;
		void InnerPrint(){
			System.out.println("内部类打印");
		}
	}
	Inner i;
}

public class Test {
	public static void main(String[] args) {
		//外部类名.内部类名  实例 = 外部类实例名.new 内部类构造方法(参数)
		Outer o = new Outer();
		o.initInner(60);
		o.visitInner();
	}
}

执行结果：

• 创建成员内部类的实例使用“外部类名.内部类名 实例 = 外部类实例名.new 内部类构造方法(参数)”的形式。

成员内部类限制

• 成员内部类不能与外部类重名
• 不能在成员内部类中定义static属性，方法和类（static final形式的常量定义除外）因为一个成员内部类实例必然与一个外部类实例关联，static完全可以移到其外部类中去

匿名内部类及应用

匿名内部类的特点

• 匿名内部类是没有名称的内部类，没办法引用它们。必须在创建时，作为new语句的一部份来声明并创建它们的实例。
• 匿名内部类必须继承一个类（抽象的，非抽象的都可以）或者实现一个接口。所有父类（或者父接口）是抽象类，则匿名内部类必须实现其所有抽象方法。

语法：
new interface/superclass(){类体}

这种形式的new语句声明一个新的匿名类，它对一个给定的类进行扩展，或者实现一个给定的接口，并同时创建该匿名类的一个新实例。

匿名内部类之抽象类使用案例：

abstract class Demo1
{
	abstract void printInfo();
}

public class Test {
	public static void main(String[] args) {
		new Demo1() {
			void printInfo() {
				// TODO Auto-generated method stub
				System.out.println("这不是Demo1，而是匿名内部类的方法");
			}
		}.printInfo();
	}
}

执行结果：

另一种写法：

abstract class Demo1
{
	abstract void printInfo();
}

public class Test {
	public static void main(String[] args) {
		Demo1 d = new Demo1() {   //这里不是实例化了Demo1，而是创建了一个Demo1的子类
			void printInfo() {
				// TODO Auto-generated method stub
				System.out.println("这不是Demo1，而是匿名内部类的方法");
			}
		};
		d.printInfo();
	}
}

匿名内部类之接口使用案例：

interface Demo2
{
	abstract void interPrint();
}

public class Test {
	public static void main(String[] args) {
		Demo2 i = new Demo2() {
			
			public void interPrint() {
				// TODO Auto-generated method stub
				System.out.println("这不是接口的实例，而是匿名内部类的方法");
			}
		};
		i.interPrint();
	}
}

执行结果：