Expansión relacionada de subprocesos múltiples de Java (proxy estático y evolución de expresiones Lamda)

1. Proxy estático

1. Concepto

Tanto el objeto real como el objeto proxy deben implementar la misma interfaz
y el objeto proxy debe representar la función real.

2. Ventajas

Los objetos proxy pueden hacer muchas cosas que los objetos reales no pueden hacer.
Los objetos reales se centran en hacer sus propias cosas.

3. muestra

package com.example.multithreading.demo3;

public class StaticProxy {
    
    

    public static void main(String[] args) {
    
    

        You you = new You();
//        1、没加多线程的操作
//        WeddingCompany weddingCompany = new WeddingCompany(you);
//        weddingCompany.HappyMarray();

        // 2、使用多线程的操作
        new Thread(() ->System.out.println("开始")).start();
        new WeddingCompany(new You()).HappyMarray();
    }
}

interface Marray{
    
    
    void HappyMarray();
}

// 真实角色
class You implements Marray{
    
    
    @Override
    public void HappyMarray(){
    
    
        System.out.println("主体操作");
    }
}

// 代理角色
class WeddingCompany implements Marray{
    
    

    //代理真实目标角色
    private Marray target;

    public WeddingCompany(Marray target) {
    
    
        this.target = target;
    }

    @Override
    public void HappyMarray(){
    
    
        before();
        // 这就是真实对象
        this.target.HappyMarray();
        after();
    }

    private void before(){
    
    
       System.out.println("代理之前的操作");
    }

    private void after(){
    
    
       System.out.println("代理之后的操作");
    }
}

resultado

2. Expresión Lamda (visualización del proceso de evolución)

1. Definir una interfaz funcional e implementar la clase (estado inicial)

El comienzo es definir una interfaz. Luego el programa principal se llama exitosamente.

package com.example.multithreading.demo4;

/**
 * 推导lambda表达式
 */
public class lamda {
    
    

    public static void main(String[] args) {
    
    
        Ilike like = new Like();
        like.lambda(1);
    }
}


// 1、定义一个函数式接口
interface Ilike{
    
    
    void lambda(int a);
}

// 2、实现类
class Like implements Ilike {
    
    
    @Override
    public void lambda(int a) {
    
    
        System.out.println("lambda:" + a);
    }
}

resultado

2. Clase interna estática (evolución del estado 2)

Evolucionó a una clase interna estática y luego se llamó con éxito

package com.example.multithreading.demo4;

/**
 * 推导lambda表达式
 */
public class lamda {
    
    

    // 3、静态内部类
    static class Like2 implements Ilike{
    
    
        @Override
        public void lambda(int a){
    
    
            System.out.println("lambda2:" + a);
        }
    }

    public static void main(String[] args) {
    
    
        Ilike like = new Like2();
        like.lambda(2);
    }
}

// 1、定义一个函数式接口
interface Ilike{
    
    
    void lambda(int a);
}

resultado

3. Clase interna local (evolución estatal 3)

Evolucionó a una clase interna local y descubrió que la llamada sigue siendo normal

package com.example.multithreading.demo4;

/**
 * 推导lambda表达式
 */
public class lamda {
    
    

    public static void main(String[] args) {
    
    

        // 4、局部内部类
        class Like3 implements Ilike{
    
    
            @Override
            public void lambda(int a) {
    
    
                System.out.println("lambda3:" + a);
            }
        }

        Ilike like = new Like3();
        like.lambda(3);
    }
}

// 1、定义一个函数式接口
interface Ilike{
    
    
    void lambda(int a);
}

resultado

4. Clase interna anónima (evolución del estado 4)

Después de simplificarlo en una clase interna anónima, la llamada sigue siendo exitosa

package com.example.multithreading.demo4;

/**
 * 推导lambda表达式
 */
public class lamda {
    
    
    
    public static void main(String[] args) {
    
    
        // 5、匿名内部类，没有类的名称，必须借助接口或者父类
        Ilike like = new Ilike() {
    
    
            @Override
            public void lambda(int a) {
    
    
                System.out.println("lambda4:" + a);
            }
        };
        like.lambda(4);

    }
}

// 1、定义一个函数式接口
interface Ilike{
    
    
    void lambda(int a);
}

resultado

5. Simplifica con lambda (evolución del estado 5)

package com.example.multithreading.demo4;

/**
 * 推导lambda表达式
 */
public class lamda {
    
    

    public static void main(String[] args) {
    
    
        // 6、用lambda简化
        Ilike like = (int a) -> {
    
    
            System.out.println("lambda5:" + a);
        };
        like.lambda(5);

    }
}

// 1、定义一个函数式接口
interface Ilike{
    
    
    void lambda(int a);
}

resultado

6. Utilice lambda para simplificar uno (elimine el tipo de parámetro)

package com.example.multithreading.demo4;

/**
 * 推导lambda表达式
 */
public class lamda {
    
    

    public static void main(String[] args) {
    
    
        // 7、用lambda简化二
        Ilike like = (a) -> {
    
    
            System.out.println("lambda5:" + a);
        };
        like.lambda(6);

    }
}

// 1、定义一个函数式接口
interface Ilike{
    
    
    void lambda(int a);
}

resultado

7. Simplifica dos con lambda (simplifica paréntesis)

package com.example.multithreading.demo4;

/**
 * 推导lambda表达式
 */
public class lamda {
    
    

    public static void main(String[] args) {
    
    
        // 8、用lambda简化三
        Ilike like = a -> {
    
    
            System.out.println("lambda5:" + a);
        };
        like.lambda(7);

    }
}

// 1、定义一个函数式接口
interface Ilike{
    
    
    void lambda(int a);
}

resultado

8. Utilice lambda para simplificar tres (elimine las llaves)

package com.example.multithreading.demo4;

/**
 * 推导lambda表达式
 */
public class lamda {
    
    

    public static void main(String[] args) {
    
    
        // 9、用lambda简化四
        Ilike like = a -> System.out.println("lambda5:" + a);
        like.lambda(8);
    }
}

// 1、定义一个函数式接口
interface Ilike{
    
    
    void lambda(int a);
}

resultado

9. Presta atención

Una expresión lambda solo se puede reducir a una línea si tiene una línea de código. Si hay varias líneas, se debe envolver con un bloque de código.
La premisa es que la interfaz es una interfaz funcional.
Varios parámetros también pueden eliminar el tipo de parámetro; si desea eliminarlo, debe eliminarlo y debe agregar paréntesis.