内部类和lambda表达式-CSDN博客

public class InnerClassFormat {

    /**
     * 内部类 定义格式
     */
    private int age = 10;

    public void showTime() {
        //外部类使用内部类属性，需要new
        InnerClass inner = new InnerClass();
        inner.show();
        // 调用内部类的私有属性
        System.out.println(inner.name);

    }
    class InnerClass {
        private String name = "小明";

        //访问 外部类的私有属性
        public void show() {
            System.out.println(age);
        }
    }
}

1.2、匿名内部类

本质：是继承了该类（子类）或者实现了该接口的（实现类）匿名对象；

使用匿名内部类，是可以直接不需要写实现类。

public class NoneNameClass {
    public static void main(String[] args) {
        /**
         * 定义匿名内部类
         */
        NoneNameFace face = new NoneNameFace() {
            @Override
            public void show() {
                System.out.println("接口，匿名内部类");
            }
        };
        face.show();

        //抽象类
        NoneAbstractClass noc = new NoneAbstractClass() {
            @Override
            public void getAbstract() {
                System.out.println("抽象类，匿名内部类");
            }
        };
        noc.getAbstract();

    }
}

1.3、局部内部类（方法内部类）

在方法里面定义的内部类，就是局部内部类（方法内部类）。

局部内部类只能够在方法里面访问，不能够在外界（方法外）访问，需要在方法内创建对象，并使用该类可以直接访问外部类的成员，也可以访问方法内的局部变量。

public class LocalityClassFormat {
    /**
     * 局部内部类
     */
    public void getLocality() {
        class LocalityClass {
            public void localMethod() {
                System.out.println("我是局部内部类！");
            }
        }
        // 外部类调用方式
        LocalityClass locality = new LocalityClass();
        locality.localMethod();
    }
}

1.4、静态内部类

有static关键字修饰的内部类为静态内部类；

静态内部类访问外部类的静态成员变量或方法必须是静态的。

public class StaticClassFormat {
    /**
     * 静态内部类
     */
    private static int a = 10;

    public static void out() {
        // 静态内部类只能调用外部类的静态属性、方法
        System.out.println("外部类静态方法");
    }

    public static class StaticClass {
        public void staticMethod() {
            System.out.println(a);
            out();
            System.out.println("静态内部类！");
        }
    }
}

----------------------------------------------------------------------------------------
  public static void main(String[] args) {
        // 静态内部调用方式
        StaticClassFormat.StaticClass stc = new StaticClassFormat.StaticClass();
        stc.staticMethod();
    }

1.5、为什么使用内部类？

（1）可以实现多重继承

（2）内部类可以对同一个包中的其他类隐藏起来，非内部类是不允许有private和protected权限的

内部类定义规则

class Test001{
        //内部类不允许定义静态变量(除静态内部类)
        //1、这样编译器会在编译的时候将这种语句变成常量值
        static final int A = 10;
        //2、 这样不可以，虽然也为static final 但是说到底还是变量对象，所以不可以这样
        static final String str = new String("");
        //3、与上相同
        static Test01 test01 = new Test01();
    }

2、lambda表达式

2.1 lambda的表达式语法

(参数列表) ->{ 方法体 }

说明：（）用来描述参数列表；

{ } ：用来描述方法体；

-> ：lambda运算符，可以叫做箭头符号

（int a,int b）->{return a+b};

public class Main {
    public static void main(String[] args) {

        System.out.println("==== lambda表达式 ====");
        NotAll notAll = () -> {
            System.out.println("\n无参数无返回值");
        };
        notAll.show();

        OneNotReturn oneNotReturn = (int a) -> {
            System.out.println("\n单个参数无返回值 a=" + a);
        };
        oneNotReturn.show(12);

        TwoNotReturn twoNotReturn = (int a, int b) -> {
            System.out.println("\n两个参数无返回值 a + b = " + (a + b));
        };
        twoNotReturn.show(12, 13);

        YesReturnNot yesReturnNot = () -> {
            return 5;
        };
        System.out.println("\n有返回值无参数：" + yesReturnNot.show());

        YesReturnYes yesReturnYes = (int a) -> {
            return a;
        };
        System.out.println("\n有返回值有参数的：" + yesReturnYes.show(7));

        MultiParameter multiParameter = (int a, int b) -> {
            return a + b;
        };
        System.out.println("\n多参数有返回值：" + multiParameter.show(1, 3));
    }
}

2.2 lambda表达式精简语句

/**
 * lambda表达式精简语句
 */
public class Grammar {
    public static void main(String[] args) {
        // 1、参数类型可以省略
        OneNotReturn oneNotReturn1 =
                (a) -> {
                    System.out.println("单个参数无返回值 a=" + a);
                };
        oneNotReturn1.show(1);

        // 2、如果参数只有一个，()可以省略
        OneNotReturn oneNotReturn2 =
                a -> {
                    System.out.println("单个参数无返回值 a=" + a);
                };
        oneNotReturn2.show(2);

        // 3、如果方法只有一条语句，{} 可省略
        OneNotReturn oneNotReturn3 =
                a ->
                        System.out.println("单个参数无返回值 a=" + a); //（4）
        //多条语句 执行顺序 （）
        System.out.println(1); // （1）
        System.out.println(2); // （2）
        System.out.println(4); // （3）
        oneNotReturn3.show(3);

        /** 4、如果方法中唯一的语句是 return 返回语句，
         * 那省略大括号的同时return 也要省略
         * 两个参数的括号是不能省略的
         */
        MultiParameter multiParameter = (a, b) -> a + b;
        System.out.println("多参数有返回值：" + multiParameter.show(1, 4));
    }
}