Java内部类简介.

一, 什么是内部类

Java中所谓内部类, 就是定义在另1个类内的类.

例如:

class A{int a;class B{int b;}
}

上面类B就是类A的一个内部类.

但是下面的写法, B只是A的一个成员.

class A{private int a;B b;
}class B{int bb;
}

因为B的定义体在类A之外, 注意区别.

Java编译器编译后, 还是会把面的代码编译成两个class.

1个是A

另1个是 A$B

对于Jvm来讲,它们实际上还是两个单独的类.

二,内部类的好处.

的确, 内部类的写法的确会破坏Java代码的良好结构以及可读性.

但是内部类也有它存在的意义.

例如一部法拉利跑车类, 它里面包括了1个发动机, 而发动机本身也有很多方法(例如,启动, 变速等). 所以发动机本身也是1个类.

但是法拉利的发动机技术很好, 为了技术机密保护, 法拉利本身不想外部知道发动机的细节, 就可以把发动机作为1个内部类.

也就是说, 外部不能直接实例化1个法拉利发动机, 用在别的车上.

好处:

1. 限制外部世界对内部类的访问.

2. 内部类可以直接访问外部类的成员.

其中第2点很重要, 甚至比第一点还重要.

三,什么情况下需要用到内部类.

这里我举1个具体点的例子.

加入1个聊天窗口Form类.

有很多控件类对象成员(例如输入框, 显示框等).

现在要启动2个线程, 分别用于接受和发送消息.

问题来了, 启动线程必须要重写Thread类或实现Runable接口,总结要写新的类.

那么新的类写在哪里呢.

如果写在外面, 那么新的类必须写入很多控件类的成员.

如果写入在Form类里面, 就可以直接使用Form类的所有成员. 这样就方便很多.

而且这个两个类也不想被其他类使用, 所以内部类就很适合了.

四,内部类的种类.

没错, Java内部类也可以根据定义的位置和访问权限分成下面若干种内部类.

4.1 定义在另1个类的方法体外的内部类.

4.1.1 非私有内部类(非静态)

这种内部i类(B)虽然定义在另1个类(A)的内部, 但实际上它是被第三个类(C)实例化的.

不过C类想实例化类B. 则必须先实例化类A.

public class InternalClass1{public static void f(){A a = new A(3);A.B b = a.new B();b.print();A.B b2 = new A(4).new B();b2.print();}
}class A{private int i;public A(int i){this.i = i;}class B{public void print(){System.out.printf("A.i is %d\n",i);}}
}

上面的例子定义了外部类A和内部类B.

可以见到内部类B是无限制地访问A的私有成员的.

反过来, 类A也同样可以无限制的内部类B的私有成员.

而B可以被第三个类(InternalClass1)实例化.

实例化的写法上面写了两种, 但是都必须事先实例化1个A对象.

也就是说Java必须为A的1个对象分配内存, 才能为A的内部类对象分配内存.

4.1.2 私有内部类(非静态)

私有内部类指的是private 修饰的内部类(注意外部类不能被private修饰)

这样的话

内部类B不能被第三方类C直接访问和实例化

但是能通过A的封装方法访问.

例子:

public class InternalClass2{public static void f(){//A2.B2 b = new A2(3).new B2(); //errorA2 a = new A2(3);a.f();}
}class A2{private int i;public A2(int i){this.i = i;}public void f(){B2 b = new B2();System.out.println(i + b.b);}private class B2{private int b =3;public void print(){System.out.printf("A.i is %d\n",i);}}
}

4.1.3 静态内部类

跟外部类不同, 内部类可以用static关键字来修饰. 代表这个是1个静态内部类.

静态内部类跟非静态内部类有两点不同.

1. 实例化1个非静态内部类之前必须实例化其外部类. 而静态内部类不需要. 可以直接被实例化, 也就是说静态内部类不需要1个外部类对象.

2. 同样地, 内部类只能访问其外部类的静态成员. 因为外部类的非静态成员依赖于外部类对象实例化.

例子:

public class InternalClass3{public static void f(){A3.printj(3);}
}class A3{private int i;private static int j;public static void printj(int j){B3 b = new B3(j);b.print();}private static class B3{public B3(int j){//A3.i= 3;//errorA3.j = j;}public void print(){System.out.printf("A.j is %d\n",j);}}
}

4.1.4 方法体内部类

下面开始恶心了, 就是内部类可以定义在方法体内.

假如B 是 A的方法f(int a)内的1个内部类.

1. B还是无限制访问A的所有成员.

2. A只能在方法f()内访问和使用B.

假如B定义在f() 里面的if() 或 try{}字句内, 那么同样地, A只能在if,try的作用范围内使用B.

3. 在方法体f()内, 代码还是严格按照顺序执行的, 那就是说必须先定义内部体B, 再使用.

4. 假如B定义的内部使用到参数a 那么a必须用Final修饰.

例子:

public class InternalClass4{public static void f(){new A4(2).printB(3,6);}
}class A4{private int i;public A4(int i){this.i = i;}public void printB(final int x, int y){//class Bclass B4{public int getSum(){return i + x;}}        System.out.println(new B4().getSum() + y);}
}

例如上面的printB方法, 有两个参数x, y 但是内部类B只访问了x, 所以x必须用final修饰, 而y不用.

可以看出, 这个种内部类已经大大影响java代码的可读性了.

幸好这种内部类不可能被其他类访问. 作用域也只在方法体内. 但是起名字还是需要避免和同包内的其它类冲突.

4.1.5 匿名内部类

所谓匿名内部类就是定义1个内部类时不指定类名字

听起来不合常理啊.

在外部类A内定义1个匿名内部类B(注意B不是类名, 只是1个代号) 有两个必要天剑.

1.内部类B只能定义在A的方法体内.

2.内部类必须是继承自另1个类Bp(Bp是类名). 或者是实现另1个接口Bi(Bi是接口名).

而Bp和Bi必须事先定义.

对于第一种, 一般用于调用1个超类的重写工公共方法.. 例如重写Thread类Run方法, 开启1个新进程.

public class InternalClass5{public static void f(){new A5().printB(3);}
}class A5{private int i = 100;public void printB(final int x){//a new internal class which inherits Thread new Thread(){public void run(){while(i > 0){System.out.println(i);i = i -x;}}}.start();}
}

对于第2种, 一般是返回1个接口的实现类对象:

例如:

public class InternalClass6{public static void f(){Ib b = new A6().GetIB(4);b.f();}
}class A6{private int i = 100;public Ib GetIB(final int x){//a new internal class which implements interface Ib return new Ib(){public void f(){System.out.println("this is a method implemented from a interface!");System.out.println(i+x);}};}
}interface Ib{void f();
}

注意这个接口必须是事先定义的.

匿名内部类的好处是随写随用, 而且无非担心命名冲突.