java内部类

最新推荐文章于 2022-09-06 22:03:21 发布

chr1sgong

最新推荐文章于 2022-09-06 22:03:21 发布

阅读量396

点赞数 1

分类专栏： Java basic

本文链接：https://blog.csdn.net/chr1sgong/article/details/79115218

版权

Java basic 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

可以将一个类的定义放置在另一个类的定义的内部，这就是内部类。

为什么需要内部类

一般来说，内部类继承某个类或实现某个接口，内部类的代码操作创建它的外围类的对象，所以可以认为内部类提供了某种进入其外围类的窗口。

每个内部类都能独立地继承一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。从这个角度看，内部类使得多继承的解决方案变得完整。

使用内部类，可以获得以下一些特性：

内部类可以有多个实例，每个实例都有他自己的状态信息，并且与其外围类对象的信息相互独立；
在单个外围类中，可以让多个内部类以不同的方式实现同一个接口，或继承同一个类；
创建内部类对象的时刻并不依赖于外围对象的创建；
内部类并没有令人迷惑的“is-a”关系：它就是一个独立的实体。

内部类是面向对象的闭包，因为它不仅包含外围类对象（创建内部类的作用域）的信息，还自动拥有一个纸箱外围类的引用，在此作用域内，内部类有权操作所有的成员，包括private成员。

创建内部类

示例代码：

public class Outer {
  //外部类的public 方法
  public void sayHello() {
    System.out.println("Hello");
  }
  //外部类的private方法
  private void sayHi() {
    System.out.println("Hi");
  }
  //外部类的public 实例域(破坏了封装性，只作为示例)
  public int index = 100;
  //外部类的private 实例域
  private int i = 10;


  public class Inner {
    private int i;
    private void showI() {
      System.out.println(i);
    }

    public void invokeOuterMethod() {
      //访问外部类的public方法
      sayHello();
      //访问外部类的private方法
      sayHi();
    }
  }

  public static void main(String[] args) {
    Outer outer = new Outer();
    Outer.Inner inner = outer.new Inner();
    System.out.println(inner.i);    //外部类访问内部类私有变量
    //外部类访问内部类的private方法
    showI();
    //外部类访问内部类的public方法
    invokeOuterMethod();
  }
}

从非静态方法之外的任意位置创建某个内部类对象，必须具体指明这个对象的类型：OuterClassName.InnerClassName———在JDK1.8中好像没这个要求了，可以直接使用内部类类型。

因为编译器进行编译的时候，会将内部类单独编译成一个.class文件，可以说，内部类编译之后是一个普通的类。以上面的代码为例，Inner类会被编译成Outer$Inner.class。

私有成员变量的访问

当有外部类访问内部类的成员变量时，内部类会生成相应的静态方法——static Type access$000(Outer$Inner)，而外部类会持有一个内部类的引用，通过调用这些静态方法，外部类能够访问内部类的各种成员变量，例如：公开或私有的域。反之，当内部类需要访问外部类的成员变量时，外部类编译后会生成相应的静态方法——static Type access$100(Outer)，此时，内部类会持有一个外部类的引用，通过调用这些静态方法，内部类也可以访问外部类的各种成员变量。

私有方法的访问

对于内部类对象而言，编译器在编译内部类代码时会生成一个外部类对象的引用，根据反编译的代码：

final Outer this$0; 可以看出，内部类的实例化必须依赖外部对象，因为需要一个指向外部类对象的引用，不然编译器就会报错。这样，内部类对象可以直接调用外部类对象的方法，如示例中的sayHello。但是当内部类调用外部类的私有方法时，由于内部类编译后是Outer$Inner.class，无法直接访问Outer.class的私有方法，编译器会为外部类生成一个静态方法static void access$000(Outer)供内部类调用，这样内部类也能访问外部类的私有方法。这个私有方法虽然是通过外部类的静态方法调用，但是创建内部类对象时仍然需要先创建外部类对象。

总结

对于外部类和内部类之间私有变量和方法的访问，都是通过编译器生成相应的静态方法实现的，因为jvm对内部类和外部类都是一视同仁的，而对于公开的变量或方法，它们的访问与一般的访问没有区别，编译器不会为此单独生成静态方法。例如：内部类对象调用外部类对象的public实例变量index，实际执行的语法是this$0.index.

局部内部类—在方法和作用域内的内部类

使用理由：

实现了某个类型的接口，可以创建并返回对其的引用；
想创建一个类来辅助复杂的解决方案，但又不希望这个类是公共可用的。

局部内部类包括：

定义在方法中的类；
定义在作用域内的类，此作用域在方法的内部；
实现了接口的匿名内部类；
匿名内部类，扩展了有非默认构造器的类；
匿名内部类，执行字段初始化；
匿名内部类，通过实例初始化实现构造（匿名内部类没有构造器）

示例代码：

public class Outer2 {

    private String test = "test";

    public Destination inner(String s) {
        class Inner implements Destination {
            private String label;
            private Inner(String label) {
                this.label = label;
            }
            public String readLabel() {
                return label;
            }
        }
        return new Inner(s);
    }

    public static void main(String[] args) {
        Outer2 outer2 = new Outer2();
        Destination destination = outer2.inner("hello");
    }
}

interface Destination {
    String readLabel();
}

在方法内定义的内部类，并不意味着当方法执行完毕后，内部类就不可用了。在方法内定义内部类，只限制了内部类的作用域，这个内部类仍然会编译成单独的.class. 同样，在作用域内的内部类，如if语句内定义的内部类，会与外部类一起编译，而不是只有if语句为真的时候才会创建类。除了内部类的作用域之外，它的使用与普通类一样。

匿名内部类

匿名内部类一般用于在创建类的实例的同时定义类，非常适用于回调。

如果定义一个匿名内部类，并且希望它使用一个在其外部定义的对象，那么编译器要求其参数引用是final的。——在JDK1.8中不必为final。？？？

示例代码：

public class Parcel10 {

    public Destination destination(String dest, float price) {
        return new Destination() {

            private int cost;

            {
                cost = Math.round(price);
                if (cost > 100) {
                    System.out.println("over budget!");
                }
            }

            private String label = dest;
            @Override
            public String readLabel() {
                return label;
            }
        };
    }

    public static void main(String[] args) {
        Parcel10 p = new Parcel10();
        Destination destination = p.destination("Beijing", 101.123F);
        System.out.println(destination.readLabel());
    }
}

匿名内部类既可以扩展类，也可以实现接口，但是不能两者兼备，而且只能实现一个接口。

在匿名内部类中不可能有命名构造器（因为匿名内部类没有名字），但是可以通过实例初始化能达到构造器的效果。

静态内部类——嵌套类

嵌套类意味着：

要创建嵌套类的对象，并不需要外围类的对象；
不能从嵌套类的对象中访问非静态的外围类对象。

普通内部类的字段与方法，只能放在类的外部层次上，所以普通的内部类不能有static数据和static字段，也不能包含嵌套类。但是嵌套类可以包含所有这些东西。

示例代码：

public class StaticInnerClass {

    private static String status = "status";

    //静态内部类
    private static class PDestination implements Destination {

        private String label = "PDestination";

        @Override
        public String readLabel() {
            return label;
        }
    }

    protected static class PPDestination implements Destination {

        private String label = "PPDestination";

        @Override
        public String readLabel() {
            return label;
        }
    }

    public static Destination destination() {
        return new PDestination();
    }

    public static void main(String[] args) {
        Destination d1 = new PDestination();
        System.out.println(d1.readLabel());

        Destination d2 = new PPDestination();
        System.out.println(d2.readLabel());
    }
}

其它特性

内部类的继承（继承内部类）

因为内部类的构造器必须连接到指向其外围类对象的引用，所以在继承内部类的时候存在一个问题：那个指向外围类对象的引用必须被初始化，而在导出类中不再存在可连接的默认对象。

示例代码：

public class InheritInnerClass extends WithInner.Inner {

    InheritInnerClass(WithInner withInner) {
        withInner.super();  //???????????????????????why
    }

    public static void main(String[] args) {
        WithInner withInner = new WithInner();
        InheritInnerClass inheritInnerClass = new InheritInnerClass(withInner);
    }

}

class WithInner {
    class Inner {}
}