java内部类_02

1.内部类的成员使用

1.1在外部类内部使用

在外部类中使用内部类的成员，与一般的成员使用差别不大，但是不能在不能在外部类的静态成员中使用非静态内部类。

1.2在外部类以外使用非静态内部类成员

在外部类以外使用内部类时，不能使用private修饰符，可以根据情况选择使用default、protected、public修饰；在外部类以为的地方定义内部类的变量语法格式如：

外部类名称.内部类名称 变量名称
OuterClass.InnerClass varName

在外部类以外的地方创建非静态内部类实例时：

外部类实例.new 内部类构造函数
OuterInstance.new InnerConstructor()

1.3在外部类以外使用静态内部成员

因为静态内部类是与类相关的，所以创建静态内部类对象时无需创建外部类对象，在外部类以外的地方创建静态内部类实例的语法：

new 外部类.内部类构造函数
new OuterClass.InnerConstructor()

1.4示例代码

class Out {
	public static void main(String[] args) {
		// 在外部类中直接访问内部类静态成员
		System.out.println(Inner.StaInVar);
		System.out.println(StaInner.StaInVar);
		// 在静态成员中无法访问非静态成员，下面代码出错
		// System.out.println(new StaInner.InVar);
	}

	public void OutIdea() {
		// 在外部类中，通过显式创建对象来访问内部类的非静态成员
		System.out.println(new Inner().InVar);
		System.out.println(new StaInner().InVar);
	}

	// 非静态内部类
	public class Inner {
		public int InVar = 1;
		static final int StaInVar = 2;
	}

	// 静态内部类
	static class StaInner {
		public int InVar = 3;
		static final int StaInVar = 4;
	}
}

public class Other {
	public static void main(String[] args) {
		// 在外部类外访问非静态内部类的成员
		Out.Inner in = new Out().new Inner();
		System.out.println(in.InVar);
		System.out.println(in.StaInVar);
		// 在外部类外访问静态内部类的成员
		Out.StaInner stain = new Out.StaInner();
		System.out.println(stain.InVar);
		System.out.println(stain.StaInVar);
	}
}

2.局部内部类

2.1局部内部类的定义

如果把一个类A定义在另一个类B的方法中，那么这个类A就是局部内部类；局部内部类仅在该方法中有效，所以无法使用访问控制符，不能用static修饰。

2.2示例代码

public class Out {
	public static void main(String[] args) {
		// 局部内部类
		class InnerA {
			int a = 1;
		}
		
		// 局部内部类可以继承
		class InnerB extends InnerA {
			int b = 2;
		}
		
		// 创建局部内部类的对象
		InnerB info = new InnerB();
		System.out.println(info.a);
		System.out.println(info.b);
	}
}

3.匿名内部类

3.1匿名内部类的定义

匿名内部类适合创建一个只需要使用一次的类，这个类用来实现某一个接口或继承某一个父类，并不需要复用，并且，匿名内部类不能是抽象类，匿名内部类不能定义构造器。

3.2示例代码

// 接口Info
interface Info {
	public double getPrice();

	public String getName();
}

// 抽象类Demo
abstract class Demo {
	private String name;

	public abstract double getPrice();
	// 构造器
	public Demo() {
	}

	public Demo(String name) {
		this.name = name;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
}

public class Out {
	// 使用接口Info的方法
	public void InfoIdea(Info in) {
		System.out.println("价格为：" + in.getPrice() + "，名字为：" + in.getName());
	}
	
	//使用抽象类Demo的方法
	public void DemoIdea(Demo demo) {
		System.out.println("价格为：" + demo.getPrice() + "，名字为：" + demo.getName());
	}

	public static void main(String[] args) {
		// 创建外部类的对象
		Out is = new Out();
		// 使用匿名内部类传入Info所需的参数
		is.InfoIdea(new Info() {

			// 匿名内部类实现接口的方法
			@Override
			public double getPrice() {
				// TODO Auto-generated method stub
				return 8.5;
			}

			@Override
			public String getName() {
				// TODO Auto-generated method stub
				return "笔";
			}

		});
		// 使用有参数的构造器创建Demo匿名实现类的对象
		is.DemoIdea(new Demo("本子") {
			// 实现抽象类的抽象方法
			@Override
			public double getPrice() {
				// TODO Auto-generated method stub
				return 12;
			}

		});
		// 使用无参数的构造器创建Demo匿名实现类的对象
		Demo demo = new Demo() {
			{
				System.out.println("匿名内部类的初始化块");
			}
			// 实现抽象类的抽象方法
			@Override
			public double getPrice() {
				// TODO Auto-generated method stub
				return 28;
			}
			// 因为无参数的构造器，所以重写getName实例方法传入参数
			public String getName() {
				return "书";
			}
		};
		is.DemoIdea(demo);
	}
}