JAVA SE Lambda pour une programmation orientée objet

Je ne sais pas comment on se sent si grand, et c’est comme ça (facile à programmer).

En bref, Lambda s'exécute à l'aide d'un code concis pour créer des instances d' interfaces avec une seule méthode abstraite (les interfaces qui répondent à cette exigence, nous les appelons des interfaces fonctionnelles, JAVA8 fournit certaines interfaces fonctionnelles qui peuvent se référer à https: //www.cnblogs .com / sxrtb / p / 12685052.html )

Exemples d'utilisation simples pour illustrer

 classe publique ConsumerTest {
     public  static  void main (String [] args) { 
        ProcessArr processArr = new   ProcessArr ();
        int [] intarr = new  int [] {1,2,3,4,6,5 }; 
        processArr.process (intarr, ( int [] t) -> {
                     for ( int ti: t) { 
                        System.out.println (ti); 
                    } 
                } 
        ); 

    } 
} 
classe ProcessArr {
     public   voidprocessus ( int [] cible, ConsumerInterface consumerInterface) { 
        consumerInterFact.accpet (target); 
    } 
} 

interface ConsumerInterface {
     void accpet ( int [] cible); 
}

Dans cet exemple, Lambda est utilisé à la place de la classe interne anonyme

 

Lambda utilise:

　　Liste des paramètres, entre crochets (), s'il n'y a qu'un seul paramètre, vous pouvez omettre les crochets

　　->

　　Corps de la méthode, entouré d'accolades {}, une seule instruction, vous pouvez omettre {} et vous pouvez omettre le champ de retour

 

Lorsqu'il n'y a qu'une seule instruction dans le corps de la méthode, vous pouvez utiliser des références de méthode et des références de constructeur (c'est-à-dire certaines méthodes de programmation de code abrégé)

 

1. Méthodes de classe de référence

 classe publique ClassMethodRefTest {
     public  static  void main (String [] args) { 
        Converter classMethodRef = Integer :: valueOf;
        // Convertisseur classMethodRef = t -> Integer.valueOf (t); 相当于 上面 的 编程
        int a = classMethodRef.Convert ("123" ); 
        System.out.println (a); 
    } 
} 
Convertisseur d' interface {
     int Convert (String s); 
}

2. Méthode d'instance de référence d'objet

 classe publique InstanceMethodRefTest {
     public  static  void main (String [] args) { 
        Converter converter = "abcd" :: indexOf;
        // Convertisseur converter = t -> "abcd" .indexOf (t); 相当于 上面 的 编程
        int s = converter.Convert ("b" ); 
        System.out.println (s); 

    } 
} 

Convertisseur d' interface {
     int Convert (String s); 
}

3. Méthode d'instance de référence de classe

 classe publique ClassInstanceMethodRefTest {
     public  static  void main (String [] args) { 
        ConverterT converter = String :: substring;
        // ConverterT converter = (a, b, c) -> a.substring (b, c); 相当于 上面 的 编程 
        String s = converter.sub ("abcdef", 1,3 ); 
        System.out.println (s); 
    } 
} 

interface ConverterT { 
    String sub (String a, int b, int c); 
}

4. Constructeur d'application

　　Pour le dire simplement, si la méthode abstraite de l'interface fonctionnelle renvoie un objet et que les paramètres de la méthode et du constructeur définis dans la classe de l'objet ont la même liste de paramètres formelle, alors le nom de l'objet retourné :: new est utilisé.

 

Je viens de commencer à le regarder, ou cela peut sembler difficile à comprendre. Permettez-moi d'expliquer brièvement comment je le comprends.

　　1. Regardez d'abord les paramètres de retour. Si la valeur de retour de l'interface fonctionnelle est la même que la valeur de retour de n'importe quelle méthode que nous connaissons , tout d'abord, nous pouvons envisager d'utiliser les méthodes que nous connaissons pour terminer l'implémentation de nos méthodes abstraites.

 　　2. Remplissez les paramètres, remplissez les paramètres de la méthode dans l'interface fonctionnelle de l' objet de la méthode que nous connaissons , la liste des méthodes , si elle peut être insérée, félicitations, vous pouvez utiliser la méthode de référence pour compléter la Lambda

 

En fait, si vous regardez attentivement (ou si vous l'avez écrit vous-même), vous constaterez que l'exemple 2 et l'exemple 3 sont un peu similaires. Modifions l'exemple 2 ici pour le rendre identique à l'exemple 3.

 classe publique InstanceMethodRefTest {
     public  static  void main (String [] args) { 
        Converter converter = String :: indexOf;
        // Convertisseur convertisseur = (t, tt) -> t.indexOf (tt); 相当于 上面 的 编程
        int s = converter.Convert ("abcd", "b" ); 
        System.out.println (s); 
    } 
} 

Convertisseur d' interface {
     int Convert (String s, String ss); 
}

 

5. La différence entre Lambda et la classe interne anonyme

　　Lambda ne peut pas appeler la méthode par défaut dans l'interface, mais la classe interne anonyme peut (le personnel sait absolument que cela suffit, l'autre est que Lambda est limité par l'interface fonctionnelle)