注意注意!!!前排提示!!!本篇文章过长,最好收藏下来慢慢看,如果你之前对内部类不是很熟悉,一次性看完,大概你会懵逼。。。
1. 内部类概述
一个类的定义放在另一个类的内部,这个类就叫做内部类。内部类是一种非常有用的特性,因为它允许你把一些逻辑相关的类组织在一起。
内部类大体上可以分为四种:
成员内部类,静态内部类,局部内部类,匿名内部类
我们先来详细的看一下这四种内部类。
2. 成员内部类
成员的内部类,就是最基础的内部类,没有那些花里胡哨的修饰:
//外部类
public class Outer {
private String a = "a";
public int i = 1;
//内部类
class Inner{
private String b = "b";
public String c = "c";
public int getInt(){
return i; // 内部类可以访问外部类变量
}
private String getString(){
return a + b + c; // 内部类可以访问外部类的private变量
}
}
public String getParam(){
Inner inner = new Inner();
inner.b = "bb"; // 外部类可以访问内部类的private变量
inner.c = "cc";
return inner.getInt() + inner.getString();
}
}
//测试类
class Test {
public static void main(String[] args) {
Outer outer = new Outer();
System.out.println(outer.getParam()); // 输出:1abbcc
Outer.Inner oi = outer.new Inner();
oi.c = "ccc";
//oi.b = "bbb"; 编译失败
System.out.println(oi.getInt()); // 输出:1
//System.out.println(oi.getString()); 编译失败
}
}
从这段代码中,我们总结一下普通内部类的要点:
- 内部类可以访问外部类变量,包括私有变量
- 在外部类中使用内部类的方法需要new一个内部类的对象。
- 在外部类中可以访问到内部类的任何变量,包括私有变量。
- 在其他类中创建内部类对象需要使用这样的形式:
OuterClassName.InnerClassName name = new OuterClassName().new InnerClassName()。
- 在其他类中定义的内部类对象不能访问内部类中的私有变量。
当然,除了以上知识点以外,在内部类中,可以通过【.this】访问到外部类对象。
public class Outer {
private int num ;
public Outer(){}
public Outer(int num){
this.num = num;
}
private class Inner{
public Outer getTest2(){
return Outer.this; // Outer.this指的是外部类的对象
}
public Outer newTest2(){
return new Outer();
}
}
public static void main(String [] args){
Outer test = new Outer(5);
Outer.Inner inner = test.new Inner();
Outer o1 = inner.getTest2();
Outer o2 = inner.newTest2();
System.out.println(o1.num); // 5
System.out.println(o2.num); // 0
}
}
注意通过.this得到的对象,和通过new出来的对象的区别。使用.this后,得到时创建该内部类时使用的外围类对象的引用,new则是创建了一个新的引用。
到这里了我们需要明确一点,内部类是个编译时的概念,一旦编译成功后,它就与外围类属于两个完全不同的类(当然他们之间还是有联系的)。对于一个名为OuterClass的外围类和一个名为InnerClass的内部类,在编译成功后,会出现这样两个class文件:OuterClass.class和OuterClass$InnerClass.class。
3. 内部类与向上转型
到目前为止,你可能觉得内部类不过如此,没什么新奇的地方,毕竟如果只是为了隐藏一个类,java本身已经有了很好的隐藏机制——只给某个类包访问权限,而用不着把类创建为内部类。
但是,当一个内部类向上转型为其基类,尤其是转型为一个接口的时候,内部类就有了用武之地。这是因为这样的内部类(某个接口的实现类)对于其他人来说完全不可见,并且不可用。所得到的只是指向基类或者接口的引用,所以能很方便的隐藏实现细节。
我们来看一段代码:
//定义两个接口
public interface Run {
void run();
}
public interface Eat {
void eat();
}
//外部类
public class Person {
//这里是private
private class PEat implements Eat {
@Override
public void