java中内部类的使用
1.定义
内部类是指在一个外部类的内部在定义一个类.内部类作为外部类的一个成员,并且依附于外部类而存在的.内部类可为静态,可用protected和private修饰(外部类只能是public和缺省的包访问权限).内部类主要有以下几种:成员内部类,局部内部类,静态内部类,匿名内部类.
2.为什么需要内部类
典型情况是:内部类继承自某个类或实现某个接口,内部类的代码操作创建其外部类的对象.所以你可以认为内部类提供了某种进入其外部类的窗口.使用内部类最吸引人的原因是:每个内部类都能独立的继承自接口的一个实现,无论外部类是否已经继承了这个实现对于内部类都没有影响.如果没有内部类提供的可以继承多个具体的或抽象的类的能力,一些设计与编程问题很难解决.从这个角度看,内部类是的多重继承的解决方案变得完整:接口解决了部分问题,内部类有效的实现了"多继承".
3.成员内部类
作为外部类的一个成员存在,与外部类的属性和方法并列:
>>在外部类访问内部类时,需创建一个内部类的对象.
>>每一个内部类的对象都会链接到一个外部类的对象(除非是一个静态内部类,下面会说到).
>>在内部类中,可以访问所有外部类的成员,但自身不能定义静态成员.
>>在内部类中,可以定义与外部类相同名称的实例变量,在内部类访问自己的变量和与外部类的非同名变量可以直接使用;访问外部类的同名变量时,通过"外部类名.this.变量名"使用.
>>内部类是一个编译时的概念,一旦编译成功,会成为完全不同的两类.本例中编译完成后会出现Outer3.class和Outer3$Inner3.class两个文件.
例:
public class Outer3 {
private static int i = 10;
private int j = 20;
private int k = 30;
public static void outer_method1() {
}
public void outer_method2() {
}
class Inner3 {
// static int inner_i;
private int inner_j = 200;
private int k = 300;
public void inner_method() {
System.out.println(inner_j);
System.out.println(this.k);
System.out.println(Outer3.this.k);
System.out.println(j);
outer_method1();
outer_method2();
}
}
public void outer_method3() {
this.new Inner3().inner_method();
}
public static void outer_method4() {
Outer3 outer = new Outer3();
Inner3 inner = outer.new Inner3();
inner.inner_method();
}
public static void main(String[] args) {
outer_method4();
}
}
4.局部内部类
在方法中定义的内部类,与局部变量类似.除了有和成员内部类一样的特性外:
>>局部内部类不能有访问修饰符,因为它不是外部类的一部分.
>>可以访问作用域内的变量,但是在访问时隐式的将变量当做final处理.
例:
public class Outer4 {
public void outer_method() {
int i = 10;
// i++;
class Inner4 {
void inner_method() {
System.out.println(i);
}
}
}
}
5.静态内部类
如果不需要内部来的对象与外部类的对象之间有联系,可以将内部类声明为static.非静态内部类对象都隐含的保存了一个引用,指向外部类的对象,但是静态内部类就不是这样了:
>>可以直接通过外部类创建内部类的对象.
>>不能在内部类的对象中访问非静态的外部类对象.
>>内部类可以定义静态和非静态成员.
>>内部类无法访问外部类的非静态成员.
例:
public class Outer5 {
private static int i = 10;
private int j = 20;
private int k = 30;
public static void outer_method1() {
}
public void outer_method2() {
}
static class Inner5 {
private static int inner_i;
private int inner_j = 200;
private int k = 300;
public void inner_method() {
System.out.println(inner_j);
System.out.println(k);
// System.out.println(j);
outer_method1();
// outer_method2();
}
}
public void outer_method3() {
System.out.println(new Inner5().inner_j);
}
public static void outer_method4() {
new Inner5().inner_method();
}
public static void main(String[] args) {
outer_method4();
}
}
6.匿名内部类
匿名内部类就是没有类名的内部类,一般适用的条件有:
>>只用到类的一个实例.
>>类在定义后马上用到.
>>类非常的小(推荐是4行代码以下).
>>给类命名并不会使你的代码更容易理解.
在使用匿名内部类时,需要记住的原则:
>>匿名类不能有构造方法.
>>匿名类内部不能定义任何静态成员(属性,方法,类).
>>匿名类不能是public,protected,private,static.
>>只能创建一个实例.
>>一定是在new关键字的后面,用其隐含实现一个接口或类.
>>其他内部类的特性.
例:
import java.util.List;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
public class Outer6 {
public static void main(String[] args) {
List<String> name = Arrays.asList("James", "Kobe", "Yao");
Collections.sort(name, new Comparator<String>() {
public int compare(String s1, String s2) {
return s1.compareTo(s2);
}
});
}
}
静态方法Collections.sort接收一个list和一个Comparator作为输入参数,实现对输入的list中的元素进行比较并排序. 看上去我们直接new了一个Comparator,实际上是定义了一个实现Comparator的匿名类,通过new创建了这个匿名类的一个对象.在本例中编译成功后会出现Outer6$1.class文件,代表匿名类通过编译.
7.多层嵌套类
在多层嵌套类中,一个内部类被嵌套多少层并不重要,它能访问所有他所嵌入的外部类的成员(即使是private的).例:
public class Outer7 {
private int i = 10;
private void outer_method() {
}
class A {
int j = 20;
void a() {
}
class B {
void b() {
outer_method();
a();
System.out.println(i);
System.out.println(j);
}
}
}
public static void main(String[] args) {
new Outer7().new A().new B().b();
}
}
8.内部类重载
如果创建了一个类,继承了外部类并重新定义了次内部类时,是否内部类会被重载呢?但是"重载"内部类好像它是外部类的一个方法,并不起什么作用.例:
public class Outer8 {
private Inner inner;
class Inner {
public Inner() {
System.out.println("Outer8.Inner()");
}
}
public Outer8() {
System.out.println("new Outer8()");
inner = new Inner();
}
}
public class SubOuter8 extends Outer8 {
private Inner subinner;
class Inner {
public Inner() {
System.out.println("SubOuter8.Inner()");
}
}
public SubOuter8() {
System.out.println("new SubOuter8()");
subinner = new Inner();
}
public static void main(String[] args) {
new SubOuter8();
}
}
运行结果:
new Outer8()
Outer8.Inner()
new SubOuter8()
SubOuter8.Inner()
由此可见,当继承外部类的时候,内部类并没有什么特别的变化,这两个内部类完全是相对独立的两个实体,各自在自己的命名空间内.当然也可以明确的继承某个内部类.例:
public class Outer8 {
private Inner inner;
class Inner {
public Inner() {
System.out.println("Outer8.Inner()");
}
}
public Outer8() {
System.out.println("new Outer8()");
inner = new Inner();
}
}
public class SubOuter8 extends Outer8 {
private Inner subinner;
class Inner extends Outer8.Inner {
public Inner() {
System.out.println("SubOuter8.Inner()");
}
}
public SubOuter8() {
System.out.println("new SubOuter8()");
subinner = new Inner();
}
public static void main(String[] args) {
new SubOuter8();
}
}
运行结果:
new Outer8()
Outer8.Inner()
new SubOuter8()
Outer8.Inner()
SubOuter8.Inner()
和前面的结果相比多输出了一个"Outer8.Inner()",说明子类的内部类在实例化时先创建了父类内部类的对象.
小结:不同环境下的内部类有着不同的特性,成员内部类与类的其他成员特性相似;局部内部类与局部变量特性相似;静态内部类与静态变量特性相似;匿名内部类经常在为了某个功能而实现某个接口时使用.同时内部类也是类的一种表现形式.