匿名内部类，Lambda表达式

匿名内部类：

概述：匿名内部类是一种特殊的局部内部类（定义在方法内部）

//直接调用，一次只能调用一个方法
public class adb {
    public static void main(String[] args) {
        
        new abc(){
            @Override
            public void show() {
                System.out.println("匿名内部类被调用");
            }
        }.show();
    }
}

interface abc{
    void show();
}

//创建对象调用
public class adb {
    public static void main(String[] args) {

        abc inter=new abc(){
            @Override
            public void show() {
                System.out.println("匿名内部类show被调用");
            }

            @Override
            public void fun() {
                System.out.println("匿名内部类fun被调用");
            }
        };
        inter.show();
        inter.fun();
    }
}
interface abc{
    void show();
    void fun();
}

匿名内部类最常见的使用场景就是：通常当方法的形式参数是接口或者抽象类时，可以将匿名内部类作 为实际参数进行传递。

public class c {
    public static void main(String[] args) {
        
        //匿名内部类
        goSwiming(new Swiming() {
            @Override
            public void show() {
                System.out.println("我们去游泳");

            }
        });
           
        //Lambda表达式
        goSwiming(()->{ 
            System.out.println("我们去游泳");
        });

    }

    public  static void goSwiming(Swiming swiming){
        swiming.show();
    }
}
interface Swiming{
    void show();
}

Lambda表达式的应用(不带参数)

public class c {

    public static Swiming swiming2=()->{
        System.out.println("swming2");
    };

    public static void main(String[] args) {

        Swiming swiming1=()->{
            System.out.println("swiming1");
        };
        swiming1.show();
        swiming2.show();

    }

    public  static void goSwiming(Swiming swiming){
        swiming.show();
    }
}
interface Swiming{
    void show();
}

Lambda表达式的应用(带参数无返回值)

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

 userfun(new fun() {
            @Override
            public void show(String str) {
                System.out.println("有参数无返回值匿名内部类"+str);
            }
        }
);

 userfun((String str)->{
     System.out.println("Lambda有参数无返回值"+str);
 });

    }
    public static void userfun(fun abc){
        abc.show("str");
    }
}
 interface fun{
    public abstract void show(String str);
}

无参数但是有返回值

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

        usernumber(new number() {
            @Override
            public int getnumber() {
                System.out.println("匿名内部类无参数有返回值");
                return 50;
            }
        });
        usernumber(()->{
            System.out.println("Lambda无参数有返回值");
            return 60;
        });
    }
    public static void usernumber(number num){
        int temp=num.getnumber();
        System.out.println("++++++无参有返回值"+temp);
    }
}

 interface number{

        public abstract int  getnumber();
}

有参数，有返回值

 

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

        usernumber(new number() {
            @Override
            public int number(int a, int b) {
                System.out.println("匿名内部类，有参数有返回值");
                return a+b;

            }
        });

        usernumber((int a,int b)->{
            System.out.println("Lambda有参数有返回值");
            return a-b;

        });
    }

    public  static  int usernumber(number num){
       int temp=num.number(10, 20);
        System.out.println("+++++有参有返回值"+temp);
        return  temp;
    }

}