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表达式

 在应用匿名内部类的时,无需提供类名。对于只有来一个措施的接口,使用Lambda显然比匿名类的贯彻简单明了。如下所示,定义一个LambdaTest接口,该接口就包含一个opt方法:

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

第5履行就是为Lambda表达式声明,其中(a,b)为艺术的参数,a+b为方法体,->表示将参数传递给方法体。 

  • Lambda表达式的方法体中,可以是一个表达式,也足以是代码块。若为表达式,Java运行期会计算表达式,并返回结果;若为代码块,可以互补加return语句,将结果返回。
  • Lambda表达式其实是一个办法的声明,可以当Lambda表达式是匿名方式
  • Lambda表达式与局部内部类与匿名类相似,可以拜外部类及表面代码块的变量;但跟后两者不同,其莫在变量覆盖的题材,可以看无引入新的代码块,其及外部代码块被之一部分变量同级
  • 是因为第三漫长,所以于表达式的参数中,匪可知宣称与同级作用域相同之变量名,否则会产出重复定义之要命。
  • 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会依据Lambda表达式所处之语境与上下文信息判断目标项目,并实现调用。

比喻如下:

 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),具有同样名称的法,但她们之归来值不同。另声明了3个invoke方法,分别收到3个近乎,即要的靶子项目不同。然后开展测试:

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");

 总结:

  • 静态嵌套类及内类分别
  • 简单类非常的里边类,局部内部类与匿名内部类;
  • 匿名内部类的特殊实现:Lambda表达式,可认为匿名方式的兑现;
  • Lambda表达式会根据上下文环境确定目标项目

参考:

  • Nested
    Classes
  • Lambda
    Expressions