[学习笔记]Java内部类

来源：互联网发布：linux terminal 编辑：程序博客网时间：2024/05/23 01:18

成员内部类

概述

内部类定义在外部类的成员位置上时，称之为成员内部类

特点

1. 内部类可以直接访问外部类中的成员，包括私有。因为内部类中有一个外部类的引用：外部类名.this。

2. 外部类要访问内部类，必须建立内部类对象。

3. 接口的内部接口必须定义静态（编译器强制定义）。

访问格式

1. 当内部类非私有非静态时，可以在外部其他类中直接建立内部类对象，格式：

外部类名.内部类名 变量名 = 外部类对象.内部类对象;

Outer.Inner in = new Outer().new Inner();

2. 当内部类在成员位置上，就可以被成员修饰符修饰，如：

private：将内部类在外部类中进行封装。

static：内部类具备静态特性，只能直接访问外部类中的静态成员。

    外部其他类，直接访问static内部类的非静态成员：

    new Outer.Inner().func();

    外部其他类，直接访问static内部类的静态成员：

    Outer.Inner.func();

注意

当内部类中定义了静态成员，该内部类必须是静态的。也就是说，非静态内部类中不可以定义静态成员，但是静态常量可以，前提是必须初始化为一个常量表达式。
原因：
每一个非静态内部类，必须维持一个对其外部类实例的应用，这就表明了非静态内部类的作用域是实例级别；而static关键字显式指定某个属性、方法或内部类的作用域是属于类级别。既然二者在语言层面要求的作用域不同，自然无法编译通过。而常量的作用域自然不再是实例级别了，而是全局级别了，只是java语言里面没有全局级别的作用域这个概念，类级别作用域其实就只是加了一个访问权限修饰的全局作用域而已。所以编译自然通过。

比如：
public class Outer {
  class Inner {
    static Inner a = new Inner();
  }
}
假设这段代码是可以编译通过的，那么就可以通过 Outer.Inner.a 来拿到Inner类的实例，而内部类的实例是一定要绑定到一个外部类的实例的，所以产生矛盾。但是java里试图用final来为上述限制松绑，可以在内部类中定义常量， 以提供更多的灵活性。

当外部类中的静态方法访问内部类时，内部类也必须是静态的。
原因：
外部类的静态方法的调用，是不需要外部类的实例的，也就是说此时无外部类的实例，而非静态内部类要使用就必须创建内部类实例，而内部类实例是绑定在外部类实例上的，所以不可行。

准确的说，静态内部类不属于内部类，因为内部类和外部类是共享的一种特殊关系，更确切地说是对实例的共享关系。而静态内部类则没有上述关系。它只是位置在另一个类的内部，因此也被称为顶级/静态嵌套类。

示例

class Outer {
  private int var = 1;
  private static int staticVar = 2;
 
  class Inner // 内部类，可以用private，static修饰。
  {
    // 非静态内部类可以定义静态常量，但是不可以定义静态变量
    static final int staticVar = 12;
 
    void func() {
      System.out.println("func @ Inner Class: " + Outer.this.var);
    }
  }
 
  static class staticInner {
    void func() {
      // 静态内部类只能访问外部类的静态成员
      System.out.println("func @ staticInner Class: " + Outer.staticVar);
    }
 
    static void staticfunc() {
      System.out.println("staticfunc @ staticInner Class: " + Outer.staticVar);
    }
  }
 
  void func() {
    Inner in = new Inner();
    System.out.println("func @ Outer Class:");
    in.func();
  }
 
  static void staticfunc() {
    // 外部类的静态方法只能访问静态内部类
    new staticInner().func();
  }
}
public class InnerClass {
  public static void main(String[] args) {
    new Outer().func();
    System.out.println("-------------------");
    new Outer().new Inner().func();
    System.out.println("-------------------");
    new Outer.staticInner().func();
    Outer.staticInner.staticfunc();
  }
}

运行结果

func @ Outer Class:

func @ Inner Class: 1

-------------------

func @ Inner Class: 1

-------------------

func @ staticInner Class: 2

staticfunc @ staticInner Class: 2

局部内部类

内部类定义在外部类的方法中时，称之为局部内部类

注意

1. 不可以被权限修饰符修饰，成员修饰符只能使用final和abstract。

2. 可以直接访问外部类中的成员，但是不可以访问它所在局部中的变量，只能访问被final修饰的局部变量（或事实上不变化的局部变量）。

3. 不可定义静态成员。

示例

import java.util.Date;
 
class Outer {
  int x = 1;
 
  void func(final int z) {
    final int y = 2;
    Date d = new Date();
 
    class Inner {
      void func() {
        System.out.println("Outer.x = " + /* Outer.this. */x);
        System.out.println("y (final int) = " + y);
        System.out.println("z (parameter final int) = " + z);
        System.out.println("d (Date) = " + d); // 这里d变量无变化，可以访问
      }
    }
    new Inner().func();
  }
}
 
 
public class InnerClass {
  public static void main(String[] args) {
    new Outer().func(5);
  }
}

运行结果

Outer.x = 1

y (final int) = 2

z (parameter final int) = 5

d (Date) = Wed Dec 10 02:54:12 CST 2014

匿名内部类

特点

1. 局部内部类的简写格式。

2. 定义匿名内部类的前提是必须继承一个类或者实现接口。（别忘记还有Object上帝）

3. 格式：

new 父类或接口() {

定义子类成员;

}

4. 其实匿名内部类就是一个匿名子类对象。

5. 匿名内部类中定义的方法最好不要超过2个。

示例

interface Father {
  public abstract void func();
}
class Outer {
  int x = 1;
 
  public void func() {
    new Father() {
      public void func() {
        System.out.println("Anonymous Class: x = " + x);
      }
    }.func(); // 匿名内部类一次只能调用一个成员函数
    Father f = new Father() {
      // 可以用 多态 实现对象名调用
      public void func() {
        System.out.println("Anonymous Class (Poly): x = " + x);
      }
    };
    f.func();
  }
}
public class InnerClass {
  public static void main(String[] args) {
    new Outer().func();
  }
}

运行结果

Anonymous Class: x = 1

Anonymous Class (Poly): x = 1

练习

如何实现如下合法的方法调用？

a.b().c()

new a.b().c()

示例

interface Father {
  void method();
}
class Test {
  static Father function() {
    return new Father() {
      public void method() {
        System.out.println("Test1");
      }
    };
  }
}
 
class Outer {
  static class Inner {
    void function() {
      System.out.println("Test2");
    }
  }
}
 
class InnerClass {
  public static void main(String[] args) {
    Test.function().method();
    /*
     *  这里由于Test无new关键字，且无括号，则function()为静态方法，而后面又接了一个方法method()，
     *  所以function()一定是返回一个类（匿名内部类），而method()就是该类中的方法。
     */
    
    new Outer.Inner().function();
    /*
     * 这里使用了new，但是Outer无括号，而Inner()有括号，所以这里Inner一定是个类，并且new的一定是Inner的对象，
     * 而Outer无括号，说明Inner一定是静态内部类，而function()就一定是Inner中的方法了。
     */
  }
}

运行结果

Test1

Test2

0 0