Extension associée du multithreading Java (évolution du proxy statique et de l'expression Lamda)

1. Proxy statique

1. Concept

L'objet réel et l'objet proxy doivent implémenter la même interface,
et l'objet proxy doit représenter le rôle réel

2. Avantages

Les objets proxy peuvent faire beaucoup de choses que les objets réels ne peuvent pas faire.
Les objets réels se concentrent sur leurs propres choses.

3. Échantillon

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("代理之后的操作");
    }
}

résultat

2. Expression Lamda (affichage du processus d'évolution)

1. Définir une interface fonctionnelle et implémenter la classe (état initial)

Le début consiste à définir une interface. Ensuite, le programme principal est appelé avec succès.

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);
    }
}

résultat

2. Classe interne statique (évolution d'état 2)

Évolué vers une classe interne statique, puis appelé avec succès

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);
}

résultat

3. Classe interne locale (évolution d'état 3)

A évolué vers une classe interne locale, a constaté que l'appel est toujours 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);
}

résultat

4. Classe interne anonyme (état évolution 4)

Après l'avoir simplifié en une classe interne anonyme, l'appel réussit toujours

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);
}

résultat

5. Simplifiez avec lambda (état évolution 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);
}

résultat

6. Utilisez lambda pour en simplifier un (supprimer le type de paramètre)

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);
}

résultat

7. Simplifiez deux avec lambda (simplifiez les parenthèses)

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);
}

résultat

8. Utilisez lambda pour simplifier trois (supprimez les accolades)

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);
}

résultat

9. Faites attention

Une expression lambda ne peut être réduite à une seule ligne que si elle contient une seule ligne de code. S'il y a plusieurs lignes, elle doit être enveloppée dans un bloc de code.
Le principe est que l’interface est une interface fonctionnelle.
Plusieurs paramètres peuvent également supprimer le type de paramètre, si vous souhaitez le supprimer, vous devez le supprimer et vous devez ajouter des parenthèses.