内部类+Lambda

什么是内部类？
在Java中，可以将一个类的定义放在另外一个类的定义内部，这就是内部类。内部类本身就是类的一个属性，与其他属性定义方式一致。

内部类的分类有哪些？
内部类可以分为四种：成员内部类、局部内部类、匿名内部类和静态内部类。

1、静态内部类
定义在类内部的静态类，就是静态内部类。
public class Outer {
private static int radius = 1;
static class StaticInner {
public void visit() {
System.out.println(“visit outer static variable:” + radius);
}
}
}

静态内部类可以访问外部类所有的静态变量，而不可访问外部类的非静态变量；静态内部类的创建方式，new 外部类.静态内部类()，如下：

Outer.StaticInner inner = new Outer.StaticInner();
inner.visit();

2、成员内部类
定义在类内部，成员位置上的非静态类，就是成员内部类。
public class Outer {
private static int radius = 1;
private int count =2;
class Inner {
public void visit() {
System.out.println(“visit outer static variable:” + radius);
System.out.println(“visit outer variable:” + count);
}
}
}
成员内部类可以访问外部类所有的变量和方法，包括静态和非静态，私有和公有。成员内部类依赖于外部类的实例，它的创建方式外部类实例.new 内部类()，如下：
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
inner.visit();

3、局部内部类
定义在方法中的内部类，就是局部内部类。
public class Outer {
private int out_a = 1;
private static int STATIC_b = 2;
public void testFunctionClass(){
int inner_c =3;
class Inner {
private void fun(){
System.out.println(out_a);
System.out.println(STATIC_b);
System.out.println(inner_c);
}
}
Inner inner = new Inner();
inner.fun();
}
public static void testStaticFunctionClass(){
int d =3;
class Inner {
private void fun(){
// System.out.println(out_a); 编译错误，定义在静态方法中的局部类不可以访问外部类的实例变量
System.out.println(STATIC_b);
System.out.println(d);
}
}
Inner inner = new Inner();
inner.fun();
}
}
定义在实例方法中的局部类可以访问外部类的所有变量和方法，定义在静态方法中的局部类只能访问外部类的静态变量和方法。局部内部类的创建方式，在对应方法内，new 内部类()，如下：
public static void testStaticFunctionClass(){
class Inner {
}
Inner inner = new Inner();
}
4、匿名内部类
匿名内部类就是没有名字的内部类，日常开发中使用的比较多，对应的lambda表达式简化操作
public class Outer {
private void test(final int i) {
new Service() {
public void method() {
for (int j = 0; j < i; j++) {
System.out.println(“匿名内部类” );
}
}
}.method();
}
}
//匿名内部类必须继承或实现一个已有的接口
interface Service{
void method();
}

Lambda：
面向对象思想：通过对象的形式去做事情，怎么做。函数式思想：强调做什么，而不是以什么形式去做，Lambda表达式就是此思想
Lambda表达式相当于对匿名内部类进行了优化（将光标移到上面的匿名内部类，可以将其转化为Lambda表达式），但本质上有区别
格式：(形参)->{代码块}
前提：1、有一个接口 2、接口中有且只有一个抽象方法
new Swimming() {
@Override
public void swim() {
System.out.println(“狗子，洗澡去！”);
}
}---->直接看方法，new Swimming(){}不看。():方法形参为空 ->:箭头指向要做的事 {}：代码块，方法体内容，具体做什么
省略模式：
1、参数类型可以省略，但是有多个参数时，不能只省略一个,可以全部省略
2、如果参数有且只有一个，那么小括号可以省略
3、如果代码语句只有一条，可以省略大括号和分号，甚至retrun

Lambda表达式和匿名内部类的区别
1、所需类型不同：
Lambda表达式：只能是接口
匿名内部类：接口、抽象类、具体类
2、使用限制不同：
Lambda表达式：有且只有一个抽象方法
匿名内部类：一个或多个抽象方法
3、实现原理不同：
Lambda表达式：编译后，没有一个单独的.class字节码文件，而是运行时动态生成
匿名内部类：编译后，产生一个单独的.class字节码文件*/