Java学习笔记-嵌套类

嵌套类

嵌套类有两种类别：static and non-static，分别对应为静态嵌套类和内部类。

 class OuterClass {
     ...
     static class StaticNestedClass {
         ...
     }
     class InnerClass {
         ...
     }
 }

其中静态嵌套类只能访问外部类的静态成员，内部类可以访问外部类的任意成员；它们可以被声明为private, public, protected, 或 package private。

• 静态嵌套类实例化方式为： OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();
• 内部类实例化方式：OuterClass.InnerClass innerObject = outerObject.new InnerClass(); 即通过外部类实例才能访问内部类。

有两个比较特殊的内部类，分别为局部内部类和匿名类。

局部内部类

• 局部内部类（Local CLasses）可声明在类中任意块（block）中，如方法、for或if块中
• 局部内部类可以访问外部类的成员，若局部内部类声明在静态块中，则可访问外部类的静态成员；若声明在非静态块中，则可访问外部类所有成员；
• 局部内部类可以访问所在块的局部变量，但该局部变量必须声明为final；在JDK8中进行了改进，局部变量可以声明为final或effectively final；
• 其他特性类似于普通内部类

其中effectively final与final局部变量的区别在于，前者可以不显式声明变量为final，只要在整个过程中，该变量不会被修改（编译器默认该情况为final）。具体为什么局部内部类为什么必须引用final变量，可参考

java为什么匿名内部类的参数引用时final？ 。大致意思是局部内部类引用局部变量，其实是进行的值引用（或者说是值拷贝）。可以认为避免外部代码块在内部类运行结束前结束，导致局部变量回收而出错。

匿名类

匿名类与局部内部类相似，只是没有命名，并且同时进行声明和实例化。如下：

 HelloWorld frenchGreeting = new HelloWorld() {
             String name = "tout le monde";
             public void greet() {
                 greetSomeone("tout le monde");
             }
             public void greetSomeone(String someone) {
                 name = someone;
                 System.out.println("Salut " + name);
             }
         };

匿名内部类适用于只用一次的情况。其他的特性与局部内部类相同。

Lambda表达式

 在使用匿名内部类的时候，无需提供类名。对于只有一个方法的接口，使用Lambda显然比匿名类的实现简单明了。如下所示，定义一个LambdaTest接口，该接口只包含一个opt方法：

 interface LambdaTest {
     int opt(int a , int b);
 }

 LambdaTest sumTest = (a,b) -> a+b；

第5行即为Lambda表达式声明，其中（a,b）为方法的参数，a+b为方法体，->表示将参数传递给方法体。

• Lambda表达式的方法体中，可以是一个表达式，也可以是代码块。若为表达式，Java运行期会计算表达式，并返回结果；若为代码块，可以添加return语句，将结果返回。
• Lambda表达式其实是一个方法的声明，可以认为Lambda表达式是匿名方法。
• Lambda表达式与局部内部类和匿名类相似，可以访问外部类和外部代码块的变量；但与后两者不同，其不存在变量覆盖的问题，可以认为没有引入新的代码块，其与外部代码块中的局部变量同级。
• 由于第三条，所以在表达式的参数中，不能声明与同级作用域相同的变量名，否则会出现重复定义的异常。
• Lambda表达式是匿名内部类实现形式的一种，其访问的外部变量必须是final或effectively final。

举例如下：

 public class Lambda {

     private int var = 100;
     private String x = "hello";

     interface Cal{
         int op(int a, int b);
     }

     interface Print{
         void print(String msg);
     }

     public int operator(int a, int b, Cal cal) {
         return cal.op(a, b);
     }

     public void operator1(String msg, Print print) {
         print.print(msg);
     }

     public void operator2(String x) {

 //        x = "";

         Print print = (msg) -> {
             System.out.println("Lambda访问外部变量：");
             System.out.println(x);
             System.out.println(msg);
             System.out.println(Lambda.this.x);
         };

         print.print(x);
     }

     public static void main(String[] args) {
         Cal add = (a,b) -> {return a+b;};
         Cal mul = (a,b) -> a*b;

         Lambda lambda = new Lambda();
         System.out.println("2+3="+lambda.operator(2, 3, add));
         System.out.println("2*3="+lambda.operator(2, 3, mul));

         lambda.var = 200;
         Print print = (msg) -> {
             System.out.println(msg);
             System.out.println(lambda.var);
         };
         lambda.operator1("Hello World", print);

         lambda.operator2("Hello Lambda");
     }

 }

运行结果：

 2+3=5
 2*3=6
 Hello World
 200
 Lambda访问外部变量：
 Hello Lambda
 Hello Lambda
 hello

其中operator2方法可以验证后三条，如果将24行的注释取消，28行就会报“local variables referenced from a lambda expression must be final or effectively final”的异常。

目标类型（Target Type）

目标类型为外部类方法期望调用的类型，如上例中operator期望调用的目标方法为Cal。Java会根据Lambda表达式所处的语境和上下文信息判断目标类型，并实现调用。

举例如下：

 public class TargetType {

     interface Cal{
         String op();
     }

     interface Cal1{
         int op1();
     }

     interface Cal2{
         void op1();
     }

     public static String invoke(Cal cal) {
         return cal.op();
     }

     public static void invoke(Cal1 cal1) {
         cal1.op1();
     }

     public static void invoke(Cal2 cal2) {
         cal2.op1();
     }

     public static void main(String[] args) {
         invoke(() -> "done");
         invoke(() -> 100);
         invoke(() -> {return;});
     }
 }

声明三个接口（Cal Cal1 Cal2），具有相同名称的方法，但他们的返回值不同。另声明了3个invoke方法，分别接收3个类，即期望的目标类型不同。然后进行测试：

main方法中的三个语句都通过编译，并且eclipse提示28行调用目标类型为Cal的invoke，29行调用目标类型为Cal1的invoke，30行调用目标类型为Cal2的invoke，目标类型如下图所示：

（1）如果再添加一句如：invoke(() -> 100.0);  则编译器会报错，Type mismatch: cannot convert from double to String；

（2）如果将Cal接口方法的返回值改为int，则除了28行报错，29行也报错：The method invoke(TargetType.Cal) is ambiguous for the type TargetType，即编译器无法确定调用哪个目标类型。

 官网文档中举的例子为Runnable和Callable，原理一样，如下：

 public interface Runnable {
     void run();
 }

 public interface Callable<V> {
     V call();
 }

方法声明：

 void invoke(Runnable r) {
     r.run();
 }

 <T> T invoke(Callable<T> c) {
     return c.call();
 }

 根据上下文确定目标类型，由于有返回值，所以会调用参数为Callable的invoke方法：

 String s = invoke(() -> "done");

总结：

• 静态嵌套类与内部类区别
• 两类特殊的内部类，局部内部类和匿名内部类；
• 匿名内部类的特殊实现：Lambda表达式，可认为匿名方法的实现；
• Lambda表达式会根据上下文环境确定目标类型

参考：

• Nested Classes
• Lambda Expressions