Java匿名内部类和Lambda表达式

一、Java匿名内部类

我们在使用匿名内部类时，需要记住以下几个重要的知识点：
　①匿名内部类不能有构造方法。 （因为匿名内部类是没有类名的）
　②匿名内部类不能定义任何静态成员、方法和类。
　③匿名内部类不能是抽象类。（因为在创建匿名内部类的时候，会立即创建匿名内部类的对象。从而也可知匿名内部类必须实现它的抽象父类或者接口里包含的所有抽象方法）
　④匿名内部类不能是public,protected,private,static。
　⑤只能创建匿名内部类的一个实例。
 ⑥ 一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。
　⑦因匿名内部类为局部内部类，所以局部内部类的所有限制都对其生效。
 ⑧内部类只能访问外部类的静态变量或静态方法。
 ⑨匿名内部类访问局部变量时，该变量使用final修饰(JDK1.7以后编译器自动添加)
匿名类和内部类中的中的this :
  当我们会要用到一些内部类和匿名类。当在匿名类中用this时，
这个this则指的是匿名类或内部类本身。这时如果我们要使用外部类的方法和变量的话，则应该加上外部类的类名。

接口：
①用来定义标准(规范)
②常量，不能有普通变量
③没有构造方法
④没有普通方法
⑤成员方法：
1、抽象方法
2、static静态方法
3、使用default修饰的普通方法
接口多继承
类是单继承

二、JavaLambda表达式

  Lambda 表达式是 JDK8 的一个新特性，可以取代大部分的匿名内部类，写出更优雅的 Java 代码，尤其在集合的遍历和其他集合操作中，可以极大地优化代码结构。
  JDK 也提供了大量的内置函数式接口供我们使用，使得 Lambda 表达式的运用更加方便、高效。
  语法形式为 () -> {}，其中 () 用来描述参数列表，{} 用来描述方法体，-> 为 lambda运算符 ，读作(goes to)。

在主函数里面：

全部代码：

package homework09.homework0910;
/**
 * 匿名内部类
 * Java Lambda表达式
 */
public class Demo {
    public static void main(String[] args) {

        final int x=120;
        Zoo z=new Zoo() {//这属于匿名内部类
            @Override
            public void test() {
                System.out.println("这是重写后的test方法！");
                System.out.println(x);
            }
            public void run(){
                System.out.println("这是匿名内部类中自己的方法！");
            }
        };
        z.test();//调用重写后的方法
       /* z.run();*///直接报错，如果匿名内部类中只有自己的run方法的话，可以调用，反之


        //这里是如何创建内部类的对象，通过先new主类，然后再创建内部类的对象
        Student.Student2 student = new Student().new Student2();
        student.test9();
        Student.Student1 s = new Student().new Student1();
        s.test3();

        //重写接口Animal中的抽象方法，匿名类实现Animal接口
        //()->{} 该匿名方法是重写Animal中的抽象方法test
        Animal i=()->{//Java Lambda 表达式
            System.out.println("这是重写了类Animal中的抽象(abstract)方法");
        };//注意：分号不要漏掉
        i.test();//调用重写后的test方法

       /* Dog d = ()->{
        //抽象类不能使用Lambda表达式	直接报错
        };*/

        //1.多个参数无返回
        Animal1 a1 = (int a,int b)->{
            System.out.println(a+b);
        };
        a1.sum(4, 5);

        //2.多个参数有返回
        Animal2 a2=(a,b)->{
            return a+b;
        };
        int a2sum=a2.sum(4, 9);
        System.out.println(a2sum);

        //3.当方法体中只有一行代码时，大括号可以省略
        Animal3 a3 = k->System.out.println(k);
        a3.sum(6);

        //4.当方法体中只有一行代码，并且带返回值时，return关键字可以省略
        Animal4 a4 = k->k;
        int a4sum=a4.sum(9);
        System.out.println(a4sum);

        //5.当方法没有参数时，小括号不能省
        Animal5 a5 = ()->11;
        int a5sum=a5.sum();
        System.out.println(a5sum);
    }
}
interface Animal5{
    public int sum();
}
interface Animal4{
    public int sum(int a);
}
interface Animal3{
    public void sum(int a);
}
interface Animal2{
    public int sum(int a,int b);
}
interface Animal1{
    public void sum(int a,int b);
}
abstract class Dog{
    public abstract void test();
}
interface Animal{
    //抽象方法
    public abstract void test();
    //JDK1.8以后才有的
    public default void test3(){
        System.out.println("test3");
    }
}
abstract class Zoo{//定义了一个抽象类
    public abstract void test();//定义了一个抽象方法
}
class Student{//类中的成员-->成员变量-->成员方法-->成员类
    public static final int A=100;//public static final
    int a=20;
    int b=50;//编译器自动为变量b添加final关键字，供内部类里面能够输出成员变量b的值
    public static void test(){
    }
    public class Student1{
        //成员内部类所有访问修饰符都可以使用
        public void test3(){
            System.out.println(b);
        }
    }
    class Student2{
        int a=10;
        public void test9(){
            System.out.println("内部类中的成员变量值为："+a);
            System.out.println(A);
            //内部类调用外部类的成员变量时，使用外部类的类名.this.成员变量名进行区分
            System.out.println("主类中的成员变量的值为："+Student.this.a);
        }
    }
}

代码运行结果：