Java学习笔记10-内部类与Lambda表达式

1.内部类

（1）匿名内部类（重要）

匿名对象：没有引用指向这个对象

匿名内部类：没有名字的一个内部类

        作用：简化一些没有类本身作用，只为了重写一些抽象方法，匿名内部类就可以简化这种实现类。

        上层：子类->接口|抽象父类

//实例代码-匿名内部类
public class Class007_Outer {
    public static void main(String[] args) {
        //创建 实现类对象调用重写后的抽象方法(简化前的写法)
        Demo demo = new Demo();
        demo..smoking();
        //匿名内部类（三种方式）
        //1. 匿名内部类对象 : 没有引用指向的匿名对象 :只能在当前行使用一次
        //创建一个Smoke接口的一个没有名字的实现类（匿名内部类）的对象
        new Smoke() {//匿名内部类的类体
            @Override
            public void smoking() {
                System.out.println("一边哈哈笑一边吸烟...");
            }
        }.smoking();

        //2. 引用指向的匿名内部类对象 : 通过引用后续使用多次（引用接收：接口多态）
        Smoke s =  new Smoke(){
            @Override
            public void smoking() {
                System.out.println("一边吸气一边吸烟");
            }
        };
        //引用接收可以多次使用
        s.smoking();
        s.smoking();

        //3.匿名内部类对象作为实参传递
 //创建一个Smoke接口的一个没有名字的实现类（匿名内部类）的对象
        test( new Smoke(){
            @Override
            public void smoking() {
                System.out.println("一边吸气一边吸烟");
            }
        });
        //通过匿名 内部类简化子类
         //创建一个抽象类Car类的一个没有名字的实现类（匿名内部类）的对象
        Car car = new Car(){
            @Override
            void run() {
                System.out.println("run....");
            }
        };
        car.run();
    }
    static void test(Smoke smoke){
        smoke.smoking();
    }
}
//抽象类
abstract class Car{
    abstract void run();
}
//接口
interface Smoke{
    void smoking();
}
//实现类 ,重写抽象方法
class Demo implements Smoke{
    @Override
    public void smoking() {
        System.out.println("一边呲着牙一边吸烟...");
    }
}

（2）成员内部类（了解）

        一个类定义在外部类的成员位置就为成员内部类，成员内部类具有类的特点，继承，实现，同时作为一个类的成员也具有成员的特点，被成员修饰符修饰。

注：

        在成员内部中不能定义静态内容，除了静态常量。

        在成员内部类中可以使用外部类中的成员，包括私有的，静态的。

        在外部类中可以跟随成员内部类的对象使用成员内部类的成员。

        成员内部类的对象需要通过外部类对象构建。

         格式：外部类名.内部类类名 引用=new 外部类（）.new 内部类（）；

        跟随内部类的对象使用内部类的成员,注意访问权限

//实例代码-成员内部类
public class Class001_Outer {
    //成员: 类中方法外
    private int i = 1;
    private static int j = 5;
    //成员内部类
    class Inner{
        private int a = 10;
        //内部类成员方法
        public void testInner(){
            System.out.println("成员内部类中的成员方法");
            System.out.println(i);
            System.out.println(j);
            //outer();
        }
    }
    //外部类成员方法
    public void outer(){
        System.out.println("成员方法");
        Inner in = new Inner();
        System.out.println(in.a);
        in.testInner();
    }
}

（3）静态内部类（了解）

静态内部类:

        可以定义静态内容(成员),成员内部类中不可以直接定义静态内容除了静态常量以外

         静态内部类中可以直接使用外部类中静态内容,需要通过外部类对象使用外部类中的成员(因为内部类本身是静态的)

         外部类中可以直接通过内部类对象使用内部类成员,可以通过内部类的类名使用内部类静态内容

         其他类中使用静态内部类中内容:

                 静态内部类中的静态内容 : 外部类类名.内部类类名.

                静态内容 静态内部类中的成员内容: new 外部类类名.内部类类名(); 通过内部类对象调用它成员

//实例代码-静态内部类
public class Class004_Outer {
    //成员: 类中方法外
    private int i = 1;
    private static int j = 5;
    //静态内部类
    static class Inner{
        //成员变量
        int a = 1;
        //静态变量
        static int b = 10;
        //成员方法
        public void test(){
            System.out.println(j);
            System.out.println(new Class004_Outer().i);
        }
        //静态方法
        public static void testStatic(){
            System.out.println(j);
            System.out.println(new Class004_Outer().i);
        }
    }
    void outer(){
        //静态内部类对象
        Inner in = new Inner();
        System.out.println(in.a);
        System.out.println(in.b);
        System.out.println(Inner.b);
        Inner.testStatic();
        in.test();
    }

}

（4）私有内部类

只能在当前外部类中通过内部类对象使用

//实例代码-私有内部类
public class Class005_Outer {
    private int i = 1;
    private static int j = 2;
    //私有的内部类
    private class Inner{
        int a = 2;
        static final int B = 10;
        void test(){
            System.out.println("私有内部类中的成员方法");
            System.out.println(i);
            System.out.println(j);
        }
    }
    void outer(){
        System.out.println("外部类中的成员方法");
        Inner in = new Inner();
        System.out.println(in.a);
        System.out.println(in.B);
        System.out.println(Inner.B);
    }
}

（5）局部内部类

（1）不能被成员修饰符等修饰(public,private,protected,static)

（2）局部内部类中不能定义静态内容,除了静态常量

（3）局部内部类中可以直接使用外部类成员,可以使用所在方法中的局部变量

（4）局部内部类指能在当前所在的方法中通过内部类对象使用,其他位置无法使用

（5）在局部内部类中使用了所在方法中的局部变量|形参,这个局部变量会默认被final修饰

        jdk8开始默认被final修饰  jdk7及之前需要显示被final修饰

//实例代码-局部内部类
public class Class006_Outer {
    //成员位置
    private int i = 1;
    private static int j = 2;
    public void test(){
        //局部位置
        int c  = 1;
        //局部内部类
        class Inner{
            static final int a = 1;
            int b = 2;
            void inner(){
                System.out.println("局部内部类中的成员方法");
                System.out.println(c);
                System.out.println(i);
                System.out.println(j);
            }
        }
        //1.测试所在方法中能够使用局部内部类中的内容
        Inner in = new Inner();
        System.out.println(in.b);
        in.inner();
    }
}

2.Lambda表达式（重要）

Lambda表达式是jdk8新增的表达式，它的作用是为了简化匿名内部类对象结构。

前提:函数式接口

函数式接口：只有一个必须被重写的抽象方法的接口        

（强制检测是否为函数式接口的方法：在接口位置-@FunctionalInterface）

语法格式：

                （）->{}

():匹配要重写的抽象方法的参数列表

->:箭头函数 箭头符号lambda符号，具有上下文推导的作用

{}：要重写的抽象方法的方法体

//实例代码-Lambda表达式的应用
public class Class001_Lambda {
    public static void main(String[] args) {
        //匿名内部类对象
       /* Run r =  new Run(){
            @Override
            public void run() {
                System.out.println("run....");
            }
        };*/

        //lambda写法1 : ()->{}
      /*  Run r = ()->{
            System.out.println("run....");
        };
        r.run();*/

        //lambda写法2: 当方法体只有一句 ,前后的{}可以省略
        /*Run r = ()->System.out.println("跑....");
        r.run();*/

        //lambda写法3: 当方法具有参数,参数的类型可以省略
        /*Run r = (a,b)->System.out.println("跑...."+(a+b));
        r.run(1,2);*/

        //lambda写法4: 当方法的参数只有一个 ,前后的()可以省略
        /*Run r = a -> System.out.println("跑...."+(a));
        r.run(1);*/

        //lambda写法5: 当方法存放返回值,并且{}中的语句体只有一句,就是return语句,前后的{}与return关键字可以一起省略
        Run r = a -> a>0;
        r.run(1);
        test(new Run() {
            @Override
            public boolean run(int x) {
                return false;
            }
        });

        //注意: 当方法的形参为一个函数式接口,实参可以为lambda表达式
        test((i)->{return i>18;});
        test(i->i>18);
    }

    static void test(Run run){
        run.run(1);
    }
}
//接口
@FunctionalInterface
interface Run{
    boolean run(int x);
    static void test(){}
}