Lambda expression

Experience lambda expression

//  Anonymous inner class mode 
        new Thread (new Runnable(){
    
            @Override
            public void run() {
    
                System.out.println(" The multithreaded program started ");
            }
        }).start();

// lambda expression 
        new Thread( 
        	() -> {
     System.out.println(" The multithreaded program started "); }
        ).start();

--------------------------------------------------------------

() -> {
     System.out.println(" The multithreaded program started "); }

//  The function here is actually to replace this part :

new Runnable(){
    
	@Override
	public void run() {
    
		System.out.println(" The multithreaded program started ");
	}
}

In fact, the function is to replace the anonymous inner class , It's just to implement an interface , Does not inherit a class .
Lambda The premise of expression ：
1. There's an interface .
2. There is and only one abstract method in the interface .

Omit

The type of parameter can be omitted .
If there's only one parameter , Parentheses can be omitted .
If the code block has only one statement , You can omit braces and semicolons of statements . If this statement is return sentence , When omitted , To put return Also omit .

        useFlyable(
        	s -> {
     System.out.println(s); }
        );
//  Equivalent 
        useFlyable(
        	s -> System.out.println(s)
        );

matters needing attention

1. Use Lambda There has to be an interface , And there is only one abstract method in the interface .
2.lambda The expression actually acts as An object of the implementation class of an interface Role , Parameter is Abstract method Parameters of , The code block is Abstract method Method body of .

3. There must be a context , Can be derived Lambda Corresponding interface

    public static void main(String[] args) {
    

//  According to the assignment of local variables  Lambda  Corresponding interface 
        Runnable r = () -> System.out.println("Lambda expression ");
//  According to the parameters of the calling method  Lambda  Corresponding interface 
        new Thread(() -> System.out.println("Lambda expression ")).start();
	//  The method parameter must be an interface ,  Cannot be an abstract class   perhaps   concrete class .
	
    }

And anonymous inner classes

Anonymous inner class , It can be （ Implement an interface , Inherit an abstract class / concrete class ） Object of class .
Lambda expression , Must be （ Implement an interface ） Object of class .
There is more than one method in the interface , Only use Anonymous inner class .