内部类

可以将一个类的定义放在另一个类的定义内部。

  • 外部类声明的属性可以被内部类所访问。内部类能透明地访问所有它所嵌入的外部类的所有成员。
  • 外部类需实例化内部类才能访问内部类的属性或方法
  • 用static声明的内部类则变成外部类，其不能访问非static的外部类属性
  • 内部类对象创建不依赖于外部类对象创建

    内部类的作用

  1. 内部类提供了更好的封装。只能让外部类直接访问，不允许同一个包中的其他类直接访问。
  2. 内部类可以直接访问外部类的私有属性，内部类被当成其外部类的成员。 但外部类不能访问内部类的内部属性。
  3. 接口只是解决了多重继承的部分问题，而内部类使得多重继承的解决方案变得更加完整。
  4. 内部类可以有多个实例，每个实例都有自己的状态信息，并且与其外部类对象信息相互独立。
  5. 在单个外部类中，可以让多个内部类以不同的方式实现同一个接口，或者继承同一个类

**

内部类的使用场合

  1. 由于内部类提供了更好的封装特性，并且可以很方便的访问外部类的属性。所以，在只为外部类提供服务的情况下可以优先考虑使用内部类。
  2. 使用内部类间接实现多继承：每个内部类都能独立地继承一个类或者实现某些接口，所以无论外部类是否已经继承了某个类或者实现了某些接口，对于内部类没有任何影响。


内部类的分类

在Java中内部类主要分为

  • 成员内部类

可以使用private、default、protected、public任意进行修饰。 类文件：外部类$内部类.class

  • 非静态内部类
  • 静态内部类
    • 匿名内部类
    • 局部内部类


非静态内部类

外部类里使用非静态内部类和平时使用其他类没什么不同

  1. 非静态内部类必须寄存在一个外部类对象里。因此，如果有一个非静态内部类对象那么一定存在对应的外部类对象。非静态内部类对象单独属于外部类的某个对象。
  2. 非静态内部类可以直接访问外部类的成员，但是外部类不能直接访问非静态内部类成员。
  3. 非静态内部类不能有静态方法、静态属性和静态初始化块。
  4. 外部类的静态方法、静态代码块不能访问非静态内部类，包括不能使用非静态内部类定义变量、创建实例。

  5. 成员变量访问要点

    1.  5.1 内部类里方法的局部变量：变量名。<br />        5.2 内部类属性：this.变量名。<br />        5.3 外部类属性：外部类名.this.变量名。
    1. class Outer {
    2.  private int age = 10;
    3.  class Inner {
    4.      int age = 20;
    5.      public void show() {
    6.          int age = 30;
    7.          System.out.println("内部类方法里的局部变量age:" + age);// 30
    8.          System.out.println("内部类的成员变量age:" + this.age);// 20
    9.          System.out.println("外部类的成员变量age:" + Outer.this.age);// 10
    10.      }
    11.  }
    12. }

  6. 内部类的访问

    1.  6.1 外部类中定义内部类
    1. new Inner()
    1.  6.2 外部类以外的地方使用非静态内部类，需使用**.new**
    1. // 外部类.内部类 name = 外部类.new 内部类（）;
    2. Outer.Inner  varname = new Outer().new Inner()。
    1. public class TestInnerClass {
    2.  public static void main(String[] args) {
    3.      //先创建外部类实例，然后使用该外部类实例创建内部类实例
    4.      Outer.Inner inner = new Outer().new Inner();
    5.      inner.show();
    6.      Outer outer = new Outer();
    7.      Outer.Inner inn = outer.new Inner();
    8.      inn.show();
    9.  }
    10. }

  7. 生成对外部类对象的引用

生成对外部类对象的引用，可以使用外部类的名字后面紧跟.this。这样产生的引用自动地具有正确的类型，这一点在编译期就被知晓并受到检查，因此没有任何运行时开销。

  1. public class DotThis{
  2.     void f(){System.out.println("DotThis.f()");}
  3.     public class Inner{
  4.         public DotThis outer(){
  5.             return DotThis.this;
  6.             // A plain "this" would be Inner's "this"
  7.         }
  8.     }
  9.     public Inner inner(){return new Inner();}
  10.     public static void main(String[] args){
  11.         DotThis dt = new DotThis();
  12.         DotThis.Inner dti = dt.inner();
  13.         dti.outer().f();
  14.     }
  15. } /* Output:
  16. DotThis.f()
  17. */

静态内部类

  1. 定义方式

    1. static  class   ClassName {
    2. //类体
    3. }

  2. 使用要点

    1. 当一个静态内部类对象存在，并不一定存在对应的外部类对象。 因此，静态内部类的实例方法不能直接访问外部类的实例方法。
    2. 静态内部类看做外部类的一个静态成员。 因此，外部类的方法中可以通过：“静态内部类.名字”的方式访问静态内部类的静态成员，通过 new 静态内部类()访问静态内部类的实例。
  3. 静态内部类的访问

外部类以外的地方使用静态内部类

  1. // 外部类.内部类 name = 外部类.内部类（）;
  2. Outer.Inner  varname = new Outer().Inner()。

匿名内部类

适合那种只需要使用一次的类。比如：键盘监听操作等等。

  1. new  父类构造器(实参类表) {
  2.            //匿名内部类类体！
  3. }

注意

  1. 匿名内部类没有访问修饰符。
  2. 匿名内部类没有构造方法。因为它连名字都没有那又何来构造方法呢。

局部内部类

  1.   **在方法和作用域内的内部类**称为局部内部类。
  • 在方法中定义的内部类可以访问外部类的属性
  • 在方法中定义内部类只能访问方法中的final类型的局部变量，因为用final定义的局部变量相当于常量，他的生命周期超出方法运行的生命周期
    1. public class Test2 {
    2.   public void show() {
    3.       //作用域仅限于该方法
    4.       class Inner {
    5.           public void fun() {
    6.               System.out.println("helloworld");
    7.           }
    8.       }
    9.       new Inner().fun();
    10.   }
    11.   public static void main(String[] args) {
    12.       new Test2().show();
    13.   }
    14. }