[JAVA] Interne Studiennotizen im Klassen- und Lambda-Stil

Es ist ein Lernprotokoll der internen Klasse und des Lambda-Stils, in dem ich nicht gut bin. ..

Innere Klasse

Sie können eine Klasse in der Klasse erstellen

//Externe Klasse
class Outer{
    //Innere Klasse
    class Inner{
        //
    }
}

Sie können eine Klasse in der Methode der Klasse erstellen

Die in der Methode definierte innere Klasse kann nur in dieser Methode generiert werden.

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

Die innere Klasse kann auf die privaten Instanzvariablen der äußeren Klasse zugreifen.

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

Ein Begleiter der inneren Klasse. Eine Klasse ohne Klassennamen wird als anonyme Klasse bezeichnet.

Vorbereitung:

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

Allgemeines Beispiel:

class Person implements Hello{
    @Override
    public void hello() {
        //TODO automatisch generierter Methodenstub
        System.out.println("Hayo");
    }
}
public class SampleProgram{
    public static void main(String[] args)  {
        Person p = new Person();
        Greeting.greet(p);

    }
}

Beispiel der inneren Klasse:

//Wie schreibe ich eine innere Klasse
public class SampleProgram{
    public static void main(String[] args) {
        class Person implements Hello{

            @Override
            public void hello() {
                //TODO automatisch generierter Methodenstub
                System.out.println("Hani");
            }
        }
        Person p = new Person();
        Greeting.greet(p);
        //So schreiben Sie die beiden oben genannten Zeilen in eine Zeile
        Greeting.greet(new Person());
    }
}

Beispiel für eine anonyme Klasse: Wenn Sie eine Klasse an der Stelle deklarieren, an der Sie das Argument der Methode angeben, müssen Sie den Klassennamen nicht angeben. Hmm ... ich bin nicht daran gewöhnt. .. ..

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

            @Override
            public void hello() {
                //TODO automatisch generierter Methodenstub
                System.out.println("Schläfrig");

            }
        });
    }
}

Lambda-Stil

Regeln im Lambda-Stil zum Deklarieren von Klassen, die funktionale Schnittstellen implementieren? Gemäß Wie schreibe ich ohne Code (?)

(Argumentzeichenfolge) -> {Inhalte verarbeiten}

Was ist eine funktionale Schnittstelle?

Eine Schnittstelle mit nur einer abstrakten Methode. Es scheint nutzlos zu sein, wenn es zwei oder mehr Methoden gibt.

Als Test nach dem Hinzufügen einer Methode

The target type of this expression must be a functional interface
//Der Zieltyp dieses Ausdrucks muss eine Funktionsschnittstelle sein
Art des Typs Begrüßung(Hello)Ist das Argument(() -> {})Gilt nicht für

Wurde mit einem Kompilierungsfehler angezeigt.

Wenn Sie den von der anonymen Klasse erstellten Prozess in einen Lambda-Ausdruck umschreiben

public class SampleProgram{
    public static void main(String[] args) {
        Greeting.greet( () -> { System.out.println("ich habe Hunger"); } );
    }
}

Regel

• Der Typ der Argumentzeichenfolge kann weggelassen werden
• Wenn es nur ein Argument gibt, kann das (), das das Argument umgibt, weggelassen werden. --Wenn der Prozess nur eine Anweisung enthält, können Sie das Schlüsselwort {}, das Schlüsselwort returen und das Semikolon (;), das den Prozess umgibt, weglassen.

//Vor der Korrektur:
Greeting.greet( () -> { System.out.println("ich habe Hunger"); } );

//Überarbeitet:
Greeting.greet( () -> System.out.println("ich habe Hunger"));

Lassen Sie uns eine Schleifenanweisung mit einem Lambda-Ausdruck machen

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("Katze","Marmor"));
        list.add(new Animal("Inco", "Peaco"));
        list.add(new Animal("Inu","Pochi"));

        //Lambda-Stil
        list.forEach((Animal a) ->{ a.showAnimal();});
        //Lambda-Abkürzung
        list.forEach(a -> a.showAnimal());
    }
}