[JAVA] Notes d'étude de classe interne et de style lambda

C'est un mémo d'étude de la classe interne et du style lambda dans lequel je ne suis pas doué. ..

Classe intérieure

Vous pouvez créer une classe dans la classe

//Classe externe
class Outer{
    //Classe intérieure
    class Inner{
        //
    }
}

Vous pouvez créer une classe dans la méthode de la classe

La classe interne définie dans la méthode ne peut être générée que dans cette méthode.

class Outer{
    void test() {
        class Inner{
        }
        Inner in = new Inner();
    }
}

La classe interne peut accéder aux variables d'instance privée de la classe externe.

class Outer{
    private String msg = "hoge";

    void test() {
        class Inner{
            void test() {
                System.out.println(msg);
            }
        }
        Inner in = new Inner();
        in.test();
    }
}

public class MultiThreadEx {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.test();
    }
}

AnonymousClass

Un compagnon de classe intérieure. Une classe sans nom de classe est appelée une classe anonyme.

Préparation:

interface Hello{
    public void hello();
}
class Greeting {
    static void greet(Hello s) {
        s.hello();
    }
}

Exemple général:

class Person implements Hello{
    @Override
    public void hello() {
        //TODO talon de méthode généré automatiquement
        System.out.println("Hayo");
    }
}
public class SampleProgram{
    public static void main(String[] args)  {
        Person p = new Person();
        Greeting.greet(p);

    }
}

Exemple de classe intérieure:

//Comment écrire une classe interne
public class SampleProgram{
    public static void main(String[] args) {
        class Person implements Hello{

            @Override
            public void hello() {
                //TODO talon de méthode généré automatiquement
                System.out.println("Hani");
            }
        }
        Person p = new Person();
        Greeting.greet(p);
        //Comment écrire les deux lignes ci-dessus sur une seule ligne
        Greeting.greet(new Person());
    }
}

Exemple de classe anonyme: Si vous déclarez une classe à l'endroit où vous spécifiez l'argument de la méthode, vous n'avez pas besoin de donner le nom de la classe. Eh bien ... je n'y suis pas habitué. .. ..

public class SampleProgram{
    public static void main(String[] args) {
        Greeting.greet(new Hello() {

            @Override
            public void hello() {
                //TODO talon de méthode généré automatiquement
                System.out.println("Somnolent");

            }
        });
    }
}

Style Lambda

Des règles de style Lambda pour déclarer des classes qui implémentent des interfaces fonctionnelles? Selon Comment écrire sans code (?)

(Argument string) -> {Traitement du contenu}

Qu'est-ce qu'une interface fonctionnelle?

Une interface qui n'a qu'une seule méthode abstraite. Cela semble inutile s'il existe deux méthodes ou plus.

En tant que test, après avoir ajouté une méthode

The target type of this expression must be a functional interface
//Le type cible de cette expression doit être une interface de fonction
Méthode de type Message d'accueil(Hello)Est l'argument(() -> {})Non applicable à

A été affiché avec une erreur de compilation.

Si vous réécrivez le processus créé par la classe anonyme en une expression lambda

public class SampleProgram{
    public static void main(String[] args) {
        Greeting.greet( () -> { System.out.println("j'ai faim"); } );
    }
}

règle

--Le type de chaîne d'argument peut être omis --S'il n'y a qu'un seul argument, le () entourant l'argument peut être omis. --S'il n'y a qu'une seule instruction dans le processus, vous pouvez omettre le mot-clé {}, returen et le point-virgule (;) qui entourent le processus.

//Avant correction:
Greeting.greet( () -> { System.out.println("j'ai faim"); } );

//Modifié:
Greeting.greet( () -> System.out.println("j'ai faim"));

Faisons une instruction de boucle en utilisant une expression lambda

import java.util.ArrayList;
import java.util.List;

class Animal{
    private String type ;
    private String name;

    Animal(String t, String n){
        this.type = t;
        this.name = n;
    }

    public void showAnimal() {
        System.out.println(this.type+":"+this.name);;
    }
}

public class SampleProgram{
    public static void main(String[] args) {
        List<Animal> list = new ArrayList<Animal>();

        list.add(new Animal("Chat","Marbre"));
        list.add(new Animal("Inco", "Peaco"));
        list.add(new Animal("Inu","Pochi"));

        //Style Lambda
        list.forEach((Animal a) ->{ a.showAnimal();});
        //Abréviation Lambda
        list.forEach(a -> a.showAnimal());
    }
}