在一个类中存在的其他类,叫做内部类。
1 内部类作用
-
内部类可以很好的实现隐藏,对同一个包中的其他类不可见。一般的非内部类,是不允许有 private 与 protected 权限的,但内部类可以。
-
内部类拥有外围类的所有元素的访问权限。
-
使一个类间接实现多重继承。
-
当定义一个回调函数,使用匿名内部类会使代码变得简洁(匿名内部类应实现接口或是继承一个基类)。
2 内部类原理
内部类既可以访问自身的数据域,也可以访问创建它的外围类对象的数据域。
-
内部类的对象有一个隐式的引用,它引用了实例化该内部对象的外围类对象。对外围类的引用在构造器中设置,编译器修改了内部类的构造器,添加了外围类引用参数。故可以访问外围类对象的所有属性。
-
内部类是一种编译器现象与虚拟机无关。
3 内部类分类
局部内部类
-
定义在一个方法中的类,是局部内部类。不能用 public 或 private 声明。作用域限定在声明这个局部类的块中。
-
局部内部类可访问包含它的外部类,还可访问这个块中(局部类外)final 属性(即为 final 的局部变量)。
匿名内部类
- 只创建一个类的对象,就不需要命名。匿名内部类无构造器,取而代之是将构造器参数传递给超类构造器;当匿名内部类实现接口的时候,无构造参数。
- 多用匿名内部类实现事件监听器和其他回调。现推荐用 lambda 表达式。
静态内部类
- 当使用内部类只是为了把一个类隐藏在另外一个类的内部,并不需要内部类引用外围类对象。可将内部类声明为 static,以便取消产生的引用。
- 静态内部类与常规内部类不同,静态内部类可以有静态域和方法。
4 内部类间接多继承用例
ClassA 基类
/**
* @version $Id: ClassA.java, v 0.1 2017年7月23日 上午10:51:08
*/
public class ClassA {
public void printA(String ags)
{
System.out.println("[ClassA]--printA()--ags:"+ags);
}
}
ClassB 基类
/**
* @version $Id: ClassB.java, v 0.1 2017年7月23日 上午10:51:25
*/
public class ClassB {
public void printB(String ags)
{
System.out.println("[ClassB]--printB()--ags:"+ags);
}
}
Printable 接口
/**
* @version $Id: Printable.java, v 0.1 2017年7月23日 上午10:52:02
*/
public interface Printable {
public void print();
}
ClassInner 类(间接多继承)
/**
* @version $Id: ClassInner.java, v 0.1 2017年7月23日 上午10:55:02
*/
public class ClassInner implements Printable {
//外部类成员
private String outerName = "outerName";
private int outerAge;
public void pirntName() {
System.out.println("[ClassInner]--outerName:" + outerName);
}
public void printAge() {
System.out.println("[ClassInner]--outerAge:" + outerAge);
}
/**
* 继承ClassA
* @version $Id: ClassInner.java, v 0.1 2017年7月23日 下午5:09:44
*/
private class InnerClassA extends ClassA {
//内部类使用外部类的成员
private String innerAName = outerName;
//内部类使用外部类的成员
public void printInnerA() {
print();
pirntName();
printAge();
System.out.println("[outerName]:" + innerAName);
}
//内部类构造器
public InnerClassA() {
super();
}
}
/**
* 继承ClassB,间接多继承
* @version $Id: ClassInner.java, v 0.1 2017年7月23日 下午5:09:48
*/
public class InnerClassB extends ClassB {
private String innerBName;
public InnerClassB() {
super();
}
//内部类构造器
public InnerClassB(String innerBName) {
super();
this.innerBName = innerBName;
}
public String getInnerBName() {
return innerBName;
}
public void setInnerBName(String innerBName) {
this.innerBName = innerBName;
}
}
/**
* 获取内部类实例方法
* @return
*/
public InnerClassA getInnerClassA() {
return new InnerClassA();
}
/**
* 获取内部类实例方法
* @return
*/
public InnerClassB getInnerClassB() {
return new InnerClassB();
}
/**
* @see InnerClass.Printable#printable()
*/
@Override
public void print() {
System.out.println("[Printable]--print()");
}
public String getOuterName() {
return outerName;
}
public void setOuterName(String outerName) {
this.outerName = outerName;
}
public int getOuterAge() {
return outerAge;
}
public void setOuterAge(int outerAge) {
this.outerAge = outerAge;
}
/**
* 测试用例
*/
@Test
public void test() {
//内部类测试用例
InnerClassA innerClassA = this.getInnerClassA();
innerClassA.printInnerA();
}
}
TestCase 测试用例
/**
* @version $Id: TestCase.java, v 0.1 2017年7月23日 上午10:51:34
*/
public class TestCase {
@Test
public void test() {
ClassInner classInner = new ClassInner();
classInner.setOuterName("outerName");
classInner.setOuterAge(20);
//继承接口的方法
System.out.println("----继承接口的方法----");
classInner.print();
//外部类自己的成员方法
System.out.println("----外部类成员方法----");
classInner.printAge();
classInner.pirntName();
//创建内部类,方法一通过外部类对象创建,内部类修饰符是private则只能在它的外部类范围使用
InnerClassB innerClassB1 = classInner.new InnerClassB("innerBName1");
//创建内部类,方法二在外部类中提供一个获取内部类实例的方法,这种方式常推荐
InnerClassB innerClassB2 = classInner.getInnerClassB();
//内部类继承它的父类方法
System.out.println("----内部类继承父类的方法----");
innerClassB1.printB(innerClassB1.getInnerBName());
innerClassB2.setInnerBName("innerClassB2");
innerClassB2.printB(innerClassB2.getInnerBName());
//内部类只能在它的内部获取并使用它的外部类成员
//innerClassB1.print();//错误
}
}