lambda expressions

In this case , From ordinary class -> Static inner class -> Local inner classes -> Anonymous inner class ->lambda expression , The overall complexity of the code is from complex to simple .

Functional interface ： Any interface , If there is only one abstract method , So it's a functional interface .

For functional interfaces , We can go through lambda Expression to create the object of the interface

• lambda An expression can only be reduced to one line if it has only one line of code , If there are many lines , Then wrap it in code blocks
• The premise is that the interface is functional
• Multiple parameters can also be removed from the parameter type , If you want to get rid of everything , It has to be bracketed （ Parentheses can be omitted for a single parameter ）

package creatthread;

public class TestLambda {
    
    //2、 Static inner class 
    static class DrinkSpirit implements Drink {
    
        @Override
        public void haveADrink(String name, String drinkType) {
    
            System.out.println(name + " Drinking " + drinkType);
        }
    }

    public static void main(String[] args) {
    
        //3、 Local inner classes 
        class DrinkFanta implements Drink {
    
            @Override
            public void haveADrink(String name, String drinkType) {
    
                System.out.println(name + " Drinking " + drinkType);
            }
        }

        System.out.println("============ Common classes implement interfaces ===============");
        Drink drink1 = new DrinkCola();
        drink1.haveADrink(" Zhang Yi ", " coke ");
        System.out.println();


        System.out.println("============ Static inner class ==============");
        Drink drink2 = new DrinkSpirit();
        drink2.haveADrink(" Li Er ", " Sprite ");
        System.out.println();


        System.out.println("============ Local inner classes ==============");
        Drink drink3 = new DrinkFanta();
        drink3.haveADrink(" The king of the three ", " Fanta ");
        System.out.println();


        System.out.println("============ Anonymous inner class ==============");
        Drink drink4 = new Drink() {
    //4、 Anonymous inner class 
            @Override
            public void haveADrink(String name, String drinkType) {
    
                System.out.println(name + " Drinking " + drinkType);
            }
        };
        drink4.haveADrink(" Zhao si ", " coffee ");
        System.out.println();

        System.out.println("============lambda expression ==============");
        //5、lambda expression 
        //lambda The expression returns an interface 
        Drink drink5 = (name, drinkType) -> System.out.println(name + " Drinking " + drinkType);
        drink5.haveADrink(" Qian Wu ", " milk ");
    }
}

interface Drink {
    
    public void haveADrink(String name, String drinkType);
}

//1、 The interface is implemented through ordinary classes 
class DrinkCola implements Drink {
    
    @Override
    public void haveADrink(String name, String drinkType) {
    
        System.out.println(name + " Drinking " + drinkType);
    }
}

result ：