本文包括:
一.什么是内部类
二.内部类的特点
三.为什么要使用内部类
四.内部类的分类
一.什么是内部类
内部类是指在外部类的内部再定义一个类。
二.内部类的特点
内部类可以为静态,可用protected,private修饰,而外部类只能用public或者缺省的访问权限。
三.为什么要使用内部类
每个内部类都可以独立的继承一个(接口的)实现,所以无论外部类是否已经继承了某个接口的实现,对于内部类都没有影响。这样,其实内部类就帮助有效的实现了多重继承的问题。
四.内部类的分类
内部类主要有以下几类:成员内部类,局部内部类,静态内部类,匿名内部类。
4.1 成员内部类
作为外部类的一个成员存在,与外部类的属性、方法并列。
- publicclass Outer {
- privatestaticinti = 1;
- privateintj = 10;
- privateintk = 20;
- publicstaticvoidouter_f1() {
- }
- publicvoidouter_f2() {
- }
- // 成员内部类中,不能定义静态成员
- // 成员内部类中,可以访问外部类的所有成员
- class Inner {
- // static int inner_i = 100;//内部类中不允许定义静态变量
- intj = 100; // 内部类和外部类的实例变量可以共存
- intinner_i = 1;
- void inner_f1() {
- System.out.println(i);
- //在内部类中访问内部类自己的变量直接用变量名
- System.out.println(j);
- //在内部类中访问内部类自己的变量也可以用this.变量名
- System.out.println(this.j);
- //在内部类中访问外部类中与内部类同名的实例变量用外部类名.this.变量名
- System.out.println(Outer.this.j);
- //如果内部类中没有与外部类同名的变量,则可以直接用变量名访问外部类变量
- System.out.println(k);
- outer_f1();
- outer_f2();
- }
- }
- //外部类的非静态方法访问成员内部类
- publicvoidouter_f3() {
- Inner inner = new Inner();
- inner.inner_f1();
- }
- // 外部类的静态方法访问成员内部类,与在外部类外部访问成员内部类一样
- publicstaticvoidouter_f4() {
- //step1 建立外部类对象
- Outer out = new Outer();
- //step2 根据外部类对象建立内部类对象
- Inner inner = out.new Inner();
- //step3 访问内部类的方法
- inner.inner_f1();
- }
- publicstaticvoid main(String[] args) {
- //outer_f4();//该语句的输出结果和下面三条语句的输出结果一样
- //如果要直接创建内部类的对象,不能想当然地认为只需加上外围类Outer的名字,
- //就可以按照通常的样子生成内部类的对象,而是必须使用此外围类的一个对象来
- //创建其内部类的一个对象:
- //Outer.Inner outin = out.new Inner()
- //因此,除非你已经有了外围类的一个对象,否则不可能生成内部类的对象。因为此
- //内部类的对象会悄悄地链接到创建它的外围类的对象。如果你用的是静态的内部类,
- //那就不需要对其外围类对象的引用。
- Outer out = new Outer();
- Outer.Inner outin = out.new Inner();
- outin.inner_f1();
- }
- }
4.2 局部内部类
在方法中定义的内部类称为局部内部类。与局部变量类似,局部内部类不能有访问说明符,因为它不是外围类的一部分,但是它可以访问当前代码块内的常量,和此外围类所有的成员。
- publicclass Outer {
- privateints = 100;
- privateintout_i = 1;
- publicvoid f(finalint k) {
- finalint s = 200;
- int i = 1;
- finalint j = 10;
- //定义在方法内部
- class Inner {
- ints = 300;// 可以定义与外部类同名的变量
- // static int m = 20;//不可以定义静态变量
- Inner(int k) {
- inner_f(k);
- }
- intinner_i = 100;
- voidinner_f(int k) {
- //如果内部类没有与外部类同名的变量,在内部类中可以直接访问外部类的实例变量
- System.out.println(out_i);
- //可以访问外部类的局部变量(即方法内的变量),但是变量必须是final的
- System.out.println(j);
- //System.out.println(i);
- //如果内部类中有与外部类同名的变量,直接用变量名访问的是内部类的变量
- System.out.println(s);
- //用this.变量名访问的也是内部类变量
- System.out.println(this.s);
- //用外部类名.this.内部类变量名访问的是外部类变量
- System.out.println(Outer.this.s);
- }
- }
- new Inner(k);
- }
- publicstaticvoid main(String[] args) {
- // 访问局部内部类必须先有外部类对象
- Outer out = new Outer();
- out.f(3);
- }
- }
4.3静态内部类
如果你不需要内部类对象与其外围类对象之间有联系,那你可以将内部类声明为static。这通常称为嵌套类(nested class)。想要理解static应用于内部类时的含义,你就必须记住,普通的内部类对象隐含地保存了一个引用,指向创建它的外围类对象。然而,当内部类是static的时,就不是这样了。嵌套类意味着:
1. 要创建嵌套类的对象,并不需要其外围类的对象。
2. 不能从嵌套类的对象中访问非静态的外围类对象。
- publicclass Outer {
- privatestaticinti = 1;
- privateintj = 10;
- publicstaticvoidouter_f1() {
- }
- publicvoidouter_f2() {
- }
- // 静态内部类可以用public,protected,private修饰
- // 静态内部类中可以定义静态或者非静态的成员
- staticclass Inner {
- staticintinner_i = 100;
- intinner_j = 200;
- staticvoidinner_f1() {
- //静态内部类只能访问外部类的静态成员(包括静态变量和静态方法)
- System.out.println("Outer.i" + i);
- outer_f1();
- }
- voidinner_f2() {
- // 静态内部类不能访问外部类的非静态成员(包括非静态变量和非静态方法)
- // System.out.println("Outer.i"+j);
- // outer_f2();
- }
- }
- publicvoidouter_f3() {
- // 外部类访问内部类的静态成员:内部类.静态成员
- System.out.println(Inner.inner_i);
- Inner.inner_f1();
- // 外部类访问内部类的非静态成员:实例化内部类即可
- Inner inner = new Inner();
- inner.inner_f2();
- }
- publicstaticvoid main(String[] args) {
- newOuter().outer_f3();
- }
- }
4.4匿名内部类
java的匿名内部类的语法规则看上去有些古怪,不过如同匿名数组一样,当你只需要创建一个类的对象而且用不上它的名字时,使用内部类可以使代码看上去简洁清楚。它的语法规则是这样的:
new interfacename(){......}; 或 new superclassname(){......};
- public class Parcel6 {
- public Contents cont() {
- return new Contents() {
- private int i = 11;
- public int value() {
- return i;
- }
- }; // 在这里需要一个分号
- }
- public static void main(String[] args) {
- Parcel6 p = new Parcel6();
- Contents c = p.cont();
- }
- }
这里方法cont()使用匿名内部类直接返回了一个实现了接口Contents的类的对象,看上去的确十分简洁。 在java的事件处理的匿名适配器中,匿名内部类被大量的使用。
有一点需要注意的是,匿名内部类由于没有名字,所以它没有构造函数(但是如果这个匿名内部类继承了一个只含有带参数构造函数的父类,创建它的时候必须带上这些参数,并在实现的过程中使用super关键字调用相应的内容)。如果你想要初始化它的成员变量,有下面几种方法:
1.如果是在一个方法的匿名内部类,可以利用这个方法传进你想要的参数,不过记住,这些参数必须被声明为final。
2.在这个匿名内部类中使用初始化代码块。