内部类与lambda表达式

内部类：

概念：

将一个类定义在另一个类里面或者方法里面，这样的类就被称为内部类。

内部类可以分为四种:成员内部类、局部内部类、匿名内部类、静态内部类

成员内部类前可加上四种访问修饰符。

private：仅外部类可访问。

protected：同包下或继承类可访问。

 default：同包下可访问。

public：所有类可访问。

基础入门：

案例解释：

public class MyCls {
    //外部类，成员变量
    private int age=10;
    private String  name="张三";
    private String  phone="111111111";

    public void  test(){
        MySubCls mySubCls=new MySubCls();
    }

    //内部类
    class MySubCls{
        public  MySubCls(){}

        //成员变量
        //内部类成员变量如果和外部类变量同名，会覆盖外部变量
        int age=20;
        String  name="李四";

        public void show(){
            System.out.println("MySuCls age"+this.age);
            System.out.println("MySubCls name:"+this.name);
            System.out.println("MySubCls phone:"+phone);

            //通过父类的this对象，访问外部变量
            System.out.println("MyCls age"+MyCls.this.age);
            System.out.println("MyCls name: "+MyCls.this.name);
        }
    }

  public static void main(String[] args) {
        //创建外部实例
        MyCls cls=new MyCls();

        //通过外部类实例，创建内部类对象
        MyCls.MySubCls sub=cls.new MySubCls();
        sub.show();
    }

图解：

局部内部类

局部内部类存在于方法中。 他和成员内部类的区别在于局部内部类的访问权限仅限于方法或作用域内。局部内部类就像局部变量一样，前面不能有访问修饰符以及static修饰符

public class MyCls {
    //外部类，成员变量
    private int age=10;
    private String  name="张三";
    private String  phone="12222222";

    //成员变量
    public void  test(String  aaa){
        //局部变量
        class MySuCls{
            public MySuCls(){}

            //成员变量
            //内部类成员变量如何和外部类变量同名，会覆盖外部类变量
            //int age = 30;
            //String name = "李四";

            public  void show(){
                System.out.println("MySubCls age"+age);

                //内部类不能修改方法的局部变量
//                age=50;
                System.out.println("MySubCls name"+name);
                name="aaaa";
                System.out.println("MySubCls phone:"+phone);

                //通过父类的this对象，访问外部类变量
                System.out.println("MyCls age: "+MyCls.this.age);
                System.out.println("MyCls name: "+MyCls.this.name);
            }
        }
        //局部内部类，只能在局部方法内使用
        MySuCls mySubCls = new MySuCls();
        mySubCls.show();
    }

 public static void main(String[] args) {
        MyCls myCls=new MyCls();
        myCls.test("xxx");
    }

匿名内部类：

匿名内部类没有构造方法。也是唯一没有构造方法的内部类。匿名内部类和局部内部类只能访问外部类的final变量。

是局部内部类的一种特殊写法。new的接口或者抽象类。

    public static void main(String[] args) {
        //局部匿名类
        IA a = new IA() {
            @Override
            public void aaa() {
                System.out.println("aaaaaa");
            }
        };

        a.aaa();
    }

静态内部类

静态内部类和成员内部类相比多了一个static修饰符。它与类的静态成员变量一般，是不依赖于外部类的。同时静态内部类也有它的特殊性。因为外部类加载时只会加载静态域，所以静态内部类不能使用外部类的非静态变量与方法。 同时可以知道成员内部类里面是不能含静态属性或方法的。

public class MyCls {
    private int age=10;
    private static int num=100;

    //静态内部类

    //静态内部类
    static class MySubCls {
        static int aaa = 200;

        public void show() {
            //静态内部类，无法访问外部类的实例变量
            //System.out.println("MyCls age:"+age);
            System.out.println("MyCls num:" + num);
            System.out.println("MySubCls aaa:" + aaa);
        }
    }

   public static void main(String[] args) {
        //直接new静态类，不依赖于外部类实例
        MyCls.MySubCls subCls =new  MyCls.MySubCls();
        subCls.show();
    }

 Lambda表达式；

概念

Lambda是一个匿名函数，可以理解为一段可以传递的代码（将代码像数据一样传递）；可以写出更简洁、更灵活的代码；作为一种更紧凑的代码风格，是Java语言表达能力得到提升。

语法

Lambda表达式在Java 语言中引入了一个新的语法元素和操作符。这个操作符为->，该操作符被称为Lambda 操作符或箭头操作符。它将Lambda 分为两个部分：

（）->{}

左侧：指定了Lambda 表达式需要的所有参数

右侧：指定了Lambda 体，即Lambda 表达式    方法要执行的功能。

Lmabda表达式的语法总结： () -> {};

λ表达式有三部分组成：参数列表，箭头（->），以及一个表达式或语句块。

前置	语法
无参数无返回值	() -> System.out.println(“Hello World”)
有一个参数无返回值	(x) -> System.out.println(x)
有且只有一个参数无返回值	x -> System.out.println(x)
有多个参数，有返回值，有多条lambda体语句	(x，y) -> {System.out.println(“xxx”);return xxxx;}；
有多个参数，有返回值，只有一条lambda体语句	(x，y) -> xxxx

从匿名类到lambda的转换1

    public static void main(String[] args) {
        //无参无返回值
        IA ia = ()-> System.out.println("aaaa");
        ia.aaa();

        //有参没返回值
        IB ib = (num)-> System.out.println(num);
        ib.bbb(100);

        //有返回值无参
        IC ic = ()-> {
            return new Random().nextInt(100);
        };
        //IC ic = ()->new Random().nextInt(100);
        System.out.println(ic.ccc());

        //有参有返回值
        ID id = (x,y)-> x+y;
        System.out.println(id.ddd(100,200));



    }

判断排序：

案例：

MyComparator 

public class MyComparator implements Comparator {
    @Override
    public int compare(Object o1, Object o2) {
        Student s1=(Student) o1;
        Student s2=(Student) o2;
        //通过年龄大小，确认比计较关系
        return s1.getAge()-s2.getAge();
    }

test

/*
    首先，定义了一个Comparator接口的实现，其中Lambda表达式用于比较两个Student对象的年龄，从而实现按年龄降序排序。
    然后，创建了一个TreeSet对象tr，并将Comparator对象传入其中，以实现按照年龄降序排序的TreeSet。
    接着，向TreeSet中添加了几个Student对象，并打印输出TreeSet，可以看到Student对象按照年龄降序排列的结果。
     */


    public static void main(String[] args) {
        //TreeSet tr = new TreeSet(new MyComparator());

        Comparator<Student> comparator=(s1,s2)->{
            return s2.getAge()-s1.getAge();
        };
//TreeSet tr = new TreeSet(comparator);


        TreeSet tr=new TreeSet(
                (s1,s2)-> ((Student)s1).getAge()-((Student)s2).getAge()
        );

        //        tr.add(100);
//        tr.add(50);
//        tr.add(60);
//        System.out.println(tr);

        tr.add(new Student("老大",90));
        tr.add(new Student("张三",18));
        tr.add(new Student("李四",15));
        tr.add(new Student("王五",28));

        System.out.println(tr);

Student

 private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

持续更新====================================