Java学习笔记-嵌套类

嵌套类

嵌套类有三种档次:static and non-static,分别对应为静态嵌套类和其中类。

1 class OuterClass {
2     ...
3     static class StaticNestedClass {
4         ...
5     }
6     class InnerClass {
7         ...
8     }
9 }

 

里面静态嵌套类只好访问外部类的静态成员,内部类可以访问外部类的随机成员;它们得以被声称为privatepublicprotected,
或 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? 。大约意思是有的内部类引用局地变量,其实是展开的值引用(或者说是值拷贝)。可以认为防止外部代码块在里面类运营截至前得了,导致部分变量回收而失误。

匿名类

匿名类与部分内部类一般,只是没有命名,并且还要开展宣示和实例化。如下:

 1 HelloWorld frenchGreeting = new HelloWorld() {
 2             String name = "tout le monde";
 3             public void greet() {
 4                 greetSomeone("tout le monde");
 5             }
 6             public void greetSomeone(String someone) {
 7                 name = someone;
 8                 System.out.println("Salut " + name);
 9             }
10         };

 匿名内部类适用于只用五回的境况。其余的特点与局地内部类相同。

Lambda表达式

 在利用匿名内部类的时候,无需提供类名。对于只有3个艺术的接口,使用Lambda明显比匿名类的兑现不难明了。如下所示,定义二个LambdaTest接口,该接口只包罗三个opt方法:

1 interface LambdaTest {
2     int opt(int a , int b);
3 }
4 
5 LambdaTest sumTest = (a,b) -> a+b;

第④行即为拉姆da表明式注脚,其中(a,b)为艺术的参数,a+b为方法体,->表示将参数传递给方法体。 

  • 拉姆da表明式的方法体中,可以是三个表明式,也可以是代码块。若为表达式,Java运维期会计算说明式,并回到结果;若为代码块,可以添加return语句,将结果重临。
  • Lambda表明式其实是2个办法的扬言,可以认为拉姆da表明式是匿名形式
  • 拉姆da表明式与局地内部类和匿名类相似,能够访问外部类和表面代码块的变量;但与后两者差距,其不存在变量覆盖的标题,可以认为尚未引入新的代码块,其与外部代码块中的局部变量同级
  • 鉴于第壹条,所以在表明式的参数中,无法声称与同级功用域相同的变量名,否则会现出重复定义的那些。
  • Lambda表达式是匿名内部类已毕格局的一种,其访问的表面变量必须是final或effectively
    final。

举例如下:

 1 public class Lambda {
 2     
 3     private int var = 100;
 4     private String x = "hello";
 5     
 6     interface Cal{
 7         int op(int a, int b);
 8     }
 9     
10     interface Print{
11         void print(String msg);
12     }
13     
14     public int operator(int a, int b, Cal cal) {
15         return cal.op(a, b);
16     }
17 
18     public void operator1(String msg, Print print) {
19         print.print(msg);
20     }
21     
22     public void operator2(String x) {
23         
24 //        x = "";
25         
26         Print print = (msg) -> {
27             System.out.println("Lambda访问外部变量:");
28             System.out.println(x);
29             System.out.println(msg);
30             System.out.println(Lambda.this.x);
31         };
32         
33         print.print(x);
34     }
35     
36     public static void main(String[] args) {
37         Cal add = (a,b) -> {return a+b;};
38         Cal mul = (a,b) -> a*b;
39         
40         Lambda lambda = new Lambda();
41         System.out.println("2+3="+lambda.operator(2, 3, add));
42         System.out.println("2*3="+lambda.operator(2, 3, mul));
43         
44         lambda.var = 200;
45         Print print = (msg) -> {
46             System.out.println(msg);
47             System.out.println(lambda.var);
48         };
49         lambda.operator1("Hello World", print);
50 
51         lambda.operator2("Hello Lambda");
52     }
53 
54 }

运营结果:

1 2+3=5
2 2*3=6
3 Hello World
4 200
5 Lambda访问外部变量:
6 Hello Lambda
7 Hello Lambda
8 hello

 其中operator2方法能够印证后三条,若是将24行的注释取消,28行就会报“local
variables referenced from a lambda expression must be final or
effectively final”的那多少个。

目标项目(Target Type)

目的项目为外部类形式期望调用的项目,如上例中operator期望调用的对象措施为Cal。Java会按照拉姆da表明式所处的语境和上下文新闻判断目标项目,并促成调用。

举例如下:

 1 public class TargetType {
 2     
 3     interface Cal{
 4         String op();
 5     }
 6     
 7     interface Cal1{
 8         int op1();
 9     }
10     
11     interface Cal2{
12         void op1();
13     }
14     
15     public static String invoke(Cal cal) {
16         return cal.op();
17     }
18     
19     public static void invoke(Cal1 cal1) {
20         cal1.op1();
21     }
22     
23     public static void invoke(Cal2 cal2) {
24         cal2.op1();
25     }
26 
27     public static void main(String[] args) {
28         invoke(() -> "done");
29         invoke(() -> 100);
30         invoke(() -> {return;});
31     }
32 }

声称几个接口(Cal Cal1
Cal2),具有相同名称的点子,但她俩的再次来到值不一样。另表明了贰个invoke方法,分别接收一个类,即希望的对象项目差距。然后举行测试:

main方法中的多少个语句都通过编译,并且eclipse提醒28行调用目的项目为Cal的invoke,29行调用目标项目为Cal1的invoke,30行调用目的项目为Cal2的invoke,目的项目如下图所示:

图片 1

(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,原理一样,如下:

1 public interface Runnable {
2     void run();
3 }
4 
5 public interface Callable<V> {
6     V call();
7 }

 方法申明:

1 void invoke(Runnable r) {
2     r.run();
3 }
4 
5 <T> T invoke(Callable<T> c) {
6     return c.call();
7 }

 

 依据上下文明确目标项目,由于有再次来到值,所以会调用参数为Callable的invoke方法:

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

 总结:

  • 静态嵌套类与其间类分别
  • 两类分外的里边类,局地内部类和匿名内部类;
  • 匿名内部类的特殊完成:拉姆da表明式,可认为匿超格局的落到实处;
  • 拉姆da表明式会基于上下文环境显然目标项目

参考: