Java内部类

非静态内部类

非静态内部类是一个类中嵌套着另外一个类。 它有访问外部类成员的权限， 通常被称为内部类。

类中定义类
        当一类中的成员,作为另外一种事物的时候,这个成员就可以定义为内部类

        分类:
            成员内部类
            静态内部类
            私有内部类
            局部内部类
            匿名内部类  ***
            Lambda表达式  *****

由于内部类嵌套在外部类中，因此必须首先实例化外部类，然后创建内部类的对象来实现。

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();
    }
}

私有的内部类

内部类可以使用 private 或 protected 来修饰，如果你不希望内部类被外部类访问可以使用 private 修饰符：

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

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

静态内部类

静态内部类可以使用 static 关键字定义，静态内部类我们不需要创建外部类来访问，可以直接访问它：

class OuterClass {
  int x = 10;

  static class InnerClass {
    int y = 5;
  }
}

public class MyMainClass {
  public static void main(String[] args) {
    OuterClass.InnerClass myInner = new OuterClass.InnerClass();
    System.out.println(myInner.y);
  }
}

以上实例执行输出结果为：5

注意：静态内部类无法访问外部类的成员。

 匿名内部类
        作用: 用来简化没有本身自己作用的实现类|子类
            上层 : 接口 | 抽象类

public class Class007_Outer {
    public static void main(String[] args) {
        //匿名对象 : 只能在当前行使用一次
        new String();

        //创建 实现类对象调用重写后的抽象方法
        new Demo().smoking();

        //匿名内部类
        //1) 匿名内部类对象 : 没有引用指向的匿名对象 :只能在当前行使用一次
        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.匿名内部类对象作为实参传递
        test( new Smoke(){
            @Override
            public void smoking() {
                System.out.println("一边吸气一边吸烟");
            }
        });

        //通过匿名 内部类简化子类
        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("一边呲着牙一边吸烟...");
    }
}

匿名内部类可以使你的代码更加简洁，你可以在定义一个类的同时对其进行实例化。它与局部类很相似，不同的是它没有类名，如果某个局部类你只需要用一次，那么你就可以使用匿名内部类

重点 重点

Lambda 表达式  *****
        jdk8新增lambda表达式

        作用: 为了简化匿名内部类对象

        前提: 函数式接口
        函数式接口 : 只有一个必须被重写的抽象方法的接口
        强制检测是否为函数式接口:
                        注解: @FunctionalInterface

        语法:
            ()->{}
            () :  匹配要重写的抽象方法的参数列表
            -> : 箭头函数  箭头符号
            {} : 要重写的抽象方法的方法体