Grundlegende Java-Grammatik

Art

In Bezug auf den Typ

Typen wie int und long werden als Basistyp, Werttyp und Primitivtyp bezeichnet
Typen wie String und Integer werden als Referenztypen, Objekttypen und Wrapper-Klassen bezeichnet.
Referenztypen werden weiter in unveränderliche und veränderbare unterteilt.
Die meisten von ihnen sind veränderbar, und String, LocalDate und LocalDateTime werden als unveränderlich erkannt.
Unveränderlich kann den Wert nicht direkt ändern und muss neu zugewiesen werden.

Bezüglich Typumwandlung

graph LR
    byte-->short
    short-->int
    char-->int
    int-->long
    long-->float
    float-->double

Typecast ist erforderlich, um von rechts nach links zu konvertieren. Beispiel: int a = (Typname) b
Implizite Typkonvertierung von links nach rechts
Die Typkonvertierung vom primitiven Typ in die Wrapper-Klasse wird als Autoboxing bezeichnet und umgekehrt als Unboxing → Link.

Variablen und Konstanten

Erklärung


/*Variable Aussage*/
boolean varA; //Nur Erklärung
varA = true; //Nur Substitution
Class varI //Nur Erklärung(Referenztyp)
varI = new Class() //Nur Substitution(Referenztyp) 

/*Ständige Erklärung*/
static final data_type varJ = valA; // (static + )letzter Modifikator

Array

Array mit fester Länge

/*Erklärung*/
data_typeA[] arrayA = new data_typeA[index_max_value];
data_typeB[] arrayB = {valA, valB, valC, valD, valE};
data_typeC[] arrayC = new data_typeC[] {valF, valG, valH};
data_typeD arrayD[]; //Im Variablennamen[]Kann angebracht werden
// X arrayD = {valI, valJ, varl}
arrayD = new data_typeD[]{valI, valJ, varl}
data_type[][] arrayE; //2D-Array → Datum_type[] arrayE[]Es kann sein.
arrayE = new date_typeE[i][]; //Der zweite Index kann weggelassen werden. Das erste ist nicht möglich.

/*Arrays Klasse*/
Arrays.toString(arrayD); // "[valI, valJ, vall]"
Arrays.sort(arrayD);     // {vall, valJ, valI}

Array variabler Länge (Sammlung)

/* List(Schnittstelle) */
// X List<data_typeA> listA = new List<>();
List<data_typeA> listA =  new ArrayList<>();
List<data_typeB> listB =  new LinkedList<>();
List<data_typeC> listC =  new CopyOnWriteArrayList<>();
List<data_typeD> listD = Arrays.asList(valA, valB); //Nur lesen
listD.add(valD);         //Zum Ende hinzufügen
listD.add(indexA, valE); //In die Mitte einfügen
listD.set(indexA, valF); //Ersatz
listD.get(indexA);       //Wert erhalten
listD.indexOf(valF);     //Position bekommen
listD.size();            //Holen Sie sich die Anzahl der Elemente
listD.contains(valF);    //Bestätigung der Existenz
listD.remove(valF);      //Löschen

/* ---Unten finden Sie die Implementierungsklasse von List------------------------------- */
/* ArrayList ..Stark in der Suche*/
//Wenn Sie eine Methode verwenden möchten, die nur in ArrayList vorhanden ist, deklarieren Sie sie unten.(Gleiches gilt weiter unten)
ArrayList<data_typeE> listE =  new ArrayList<>();
ArrayList listF = (ArrayList<data_typeE>)listE.clone(); //Kopieren

/* LinkedList ..hinzufügen/Stark gegen Löschung*/
LinkedList<data_typeG> listG =  new LinkedList<>();
listG.push(); //Zum Anfang hinzufügen
listG.pop();  //Von Anfang an löschen

/* CopyOnWriteArrayList ..Keine Synchronisation erforderlich/Stark gegen Multithreading*/
CopyOnWriteArrayList<data_typeH> listH =  new CopyOnWriteArrayList<>();

Assoziatives Array (Sammlung)

/* Map(Schnittstelle) */
// X Map<Integer, data_typeA> mapA = new Map<>();
Map<Integer, data_typeA> mapA = new HashMap<>();
Map<Integer, data_typeB> mapB = new LinkedHashMap<>();
Map<Integer, data_typeC> mapC = new ConcurrentHashMap<>();
Map<Integer, data_typeD> mapD = new TreeMap<>();

mapA.put(keyA, valA);     //Zum Ende hinzufügen
mapA.put(keyA, valB);     //Ersatz
mapA.get(keyA);           //Wert erhalten
mapA.size();              //Holen Sie sich die Anzahl der Elemente
mapA.containsKey(keyA);   //Schlüsselsuche
mapA.containsValue(valB); //Suche nach Wert
mapA.remove(keyA);        //Löschen

/* ---Ordnen Sie die Implementierungsklasse unten zu------------------------------- */
/* HashMap ...Stark in der Suche*/
HashMap<Integer, data_typeE> mapE = new HashMap<>();

/* LinkedHashMap ..Halten Sie die Einfügereihenfolge ein*/
LinkedHashMap<Integer, data_typeF> mapF = new LinkedHashMap<>();

/* ConcurrentHashMap ..Keine Synchronisation erforderlich/Stark gegen Multithreading*/
ConcurrentHashMap<Integer, data_typeG> mapG = new ConcurrentHashMap<>();

/* TreeMap ..Teilmenge, die sich der Größe des Schlüssels bewusst ist*/
TreeMap<Integer, data_typeH> mapH = new TreeMap<>();

Set (Sammlung)

// X Set<data_typeA> setA =  new Set<>();
Set<data_typeA> setA =  new HashSet<>();
Set<data_typeB> setB =  new LinkedHashSet<>();
Set<data_typeC> setC =  new TreeSet<>();
Set<data_typeD> setD =  new HashSet<>(ListA); // List->Set

setD.add(valA);      //Mehrwert/Überschreiben
setD.remove(valB);   //Wert löschen
setD.size();         //Holen Sie sich die Anzahl der Elemente
setD.contains(valC); //Suche nach Wert

/* ---Die folgende Set-Implementierungsklasse------------------------------- */
/* HashSet ..Stark in der Suche*/
HashSet<data_typeA> setA =  new HashSet<>();

/* LinkedHashSet ..hinzufügen/Stark gegen Löschung*/
LinkedHashSet<data_typeB> setB =  new LinkedHashSet<>();

/* TreeSet ..Teilmenge, die sich der Größe des Schlüssels bewusst ist*/
TreeSet<data_typeC> setC =  new TreeSet<>();

Andere

Warteschlange und ihre Implementierung ... FIFO

Queue<data_typeA> queueA = new ArrayBlockingQueue<>(intA);
queueA.offer(valA); //hinzufügen
queueA.peek();      //Ausgabe
queueA.poll();      //Ausgabe/Löschen

Deque und seine Implementierung ... Eine Erweiterung von Queue. Kann an beiden Enden hinzugefügt oder gelöscht werden.

//LinkedList ist eine Implementierung von List und Deque
Deque<data_typeA> dequeA = new LinkedList<>();
dequeA.offerFirst(valA); //Mehrwert am Anfang
dequeA.offerLast(valB);  //Mehrwert am Ende
dequeA.peekFirst(valC);  //Ausgabe des ersten Wertes
dequeA.peekLast(valD);   //Ausgabe des nachgestellten Wertes
dequeA.pollFirst(valE);  //Ausgabe des ersten Wertes/Löschen
dequeA.pollLast(valF);   //Ausgabe des nachgestellten Wertes/Löschen

Referenz: [Java] Stack Queue Memo

Ast

If-Anweisung


if (conditionA){ 
    statementA //Aussage, Verarbeitung
} else if (conditionB) {
    statementB //Aussage, Verarbeitung
} else if (!conditionC) {
    statementC //Aussage, Verarbeitung
} else {
    statementD //Aussage, Verarbeitung
}

/* {}Kürzung...Es kann nur eine Zeile in das Nest geschrieben werden*/
if (conditionA)
    statementA //Aussage, Verarbeitung
else
    statementB //Aussage, Verarbeitung

switch-Anweisung


switch (varA) {
    case valA:     // varA =Für valA
        statementA //Aussage, Verarbeitung
        //break-Anweisung...Ende der Ausführung des Codeblocks
        break;
    case valB:
    case valC:     // varA = valB,Für valC
        statementB //Aussage, Verarbeitung
        break;
    case default   // varA = valA,valB,Andere als valC
        statementC //Aussage, Verarbeitung
        break;
	/*Die Reihenfolge der Fälle ist unbegrenzt. Standard kann am Anfang sein(nicht empfohlen) */
}

Iterativ

Zur Aussage

/*Wiederholen Sie den Satz eine bestimmte Anzahl von Malen*/
for (data_type varA = valA; varA <= valB; valC++) {
    statementA //Aussage, Verarbeitung
}
/* for(int a, int b, a < 3, a++, method()){mögen
Es können mehrere Anfangswerte und Aktualisierungswerte definiert werden. Der aktualisierte Wert kann auch als Methode bezeichnet werden) */

/*Wiederholen Sie dies aus der Array-Sammlung*/
for (data_type varB : collectionA) {
    statementB //Aussage, Verarbeitung
}

/*Kombination von for Each- und Lambda-Expression(Geben Sie die Elemente von collectionB aus) */
collectionB.forEach(varC -> System.out.println(varC));

While-Anweisung (Do-While-Anweisung)

/*Wiederholen, während der bedingte Ausdruck True ist*/
while (conditionA) {
    statementA //Aussage, Verarbeitung
} 

do { 
    statementB //Aussage, Verarbeitung
} while (conditionB);

/*Beim Wiederholen, bis der bedingte Ausdruck wahr wird*/
while (!conditionC){
    statementC //Aussage, Verarbeitung
}

do { 
    statementD //Aussage, Verarbeitung
} while (conditionD);

Anweisungen brechen und fortsetzen

X: //Etikette
while (conditionA) {
    switch(varA){
        case valA: // statementA,Gehe durch B.
            statementA //Aussage, Verarbeitung
        case valB: //Nur Aussage B besteht
            statementB //Aussage, Verarbeitung
            /*break-Anweisung...Ende der Ausführung des Codeblocks*/
            break;
		case valC:
		    break X; //1. Zeile "X.:Springen zu(Beenden Sie während)
        default:
            statementC //Aussage, Verarbeitung
            /*Aussage fortsetzen...Verschieben Sie die Ausführungssteuerung zur nächsten Iteration*/
            continue;
    } 
}

Ausnahmebehandlung ... Auf Fehler prüfen

/* try ...Zielverarbeitung*/
try{
	statementA
/* catch ...Ausnahmebehandlung*/
} catch (xxxException e){
	e.printStackTrace();    //Ausnahmemeldung(Grundlegend dies)
	e.getClass().getName(); //Nur Name der Ausnahmeklasse
	e.getMessage();         //Nur Ausnahme-Detailmeldung
	StackTraceElement[] ste = e.getStackTrace(); //Liste der Ausnahmen
/* finally ... try/Nach dem Fang(try/Auch wenn es eine Rückkehr im Fang gibt)Ein Prozess, der ausgeführt werden muss.*/
} finally{
	statementB //Aussage, Verarbeitung
}
// try-catch-Die Reihenfolge von schließlich kann nicht geändert werden. Versuchen-catch, try-Optional wie endlich.

/*Throw-Klausel...Erzwungene Erzeugung von Ausnahmen*/
throw new ExceptionClassA();

/*wirft Klausel...Übergeben Sie den Fehler an den Anrufer*/
public class Main throws Exception { //Wenn Sie es an main anhängen, gibt es einige Ausnahmen

Ausnahmetyp

Klasse	Überblick	Zeitpunkt des Auftretens
Error	Fehler, die vom Programm nicht behoben werden können, z. B. Probleme in der Ausführungsumgebung	Laufzeit(Nicht inspizierter Artikel)
Exception - RuntimeException	Ausnahme, die verhindert werden kann, wenn das Programm korrekt geschrieben ist	Laufzeit(Nicht inspizierter Artikel)
Exception -Andere als die oben genannten	Ausnahme, die auch bei korrekter Schreibweise des Programms nicht verhindert werden kann. Würfe erforderlich	Zur Kompilierungszeit(Inspektionsgegenstand)

Klasse

Grundlagen der Klasse

package	scope1.packageA;   //Paketdeklaration
import scopeB.libC;        //Importieren Sie libC eines anderen Pakets B.
import static scopeC.libD.methodA; //Statischer Import von methodA Methode von libD eines anderen Pakets C.

public class ClassA{
    /*Methode am Anfang aufgerufen*/
	//Andere Argumentationsmuster für main(String... args), (String args[])
	public static void main(String[] args){
		ClassB instanceA = new ClassB("naiyo");
		System.out.println(instanceA.getMethodA());
	}
}

private class ClassB{
	private data_type _fieldA;
    
	/*statischer Initialisierer...Statischer Zugriff, Instanziierung usw.
Erster Lauf, wenn die Klasse zum ersten Mal geladen wird*/
	static {
        //Initialisierungsprozess usw.
	}

	/*Initialisierungsblock...Führen Sie es jedes Mal aus, wenn eine Instanz erstellt wird*/
	{
		//Initialisierungsprozess usw.
	}

	/*Konstrukteur...Führen Sie es jedes Mal aus, wenn eine Instanz erstellt wird*/
	Class2(){
        this._fieldA = "";
    }

    /*Die Reihenfolge ist statischer Initialisierer->Initialisierungsblock->Konstrukteur*/

    /*Setter*/
	data_type setMethodA(data_type varB){
		this._fieldA = varB; //Argument und Feldname sind identisch
	}

    /*Getter*/
	data_type getMethodA(){
		return this._fieldA;
	}
}

Modifikator

/*Zugriffsmodifikator*/
private class1{}         //Nur von derselben Klasse zugänglich
protected class class1{} //Nur aus derselben Klasse und Unterklasse
class class1{}           //Nur aus dem gleichen Paket
public class class1{}    //Aus allen Klassen

/*Andere Modifikatoren*/
abstract      //Abstrakte Klasse, abstrakte Methode
static        //Name der Klasse.Kann von einem Mitglied angerufen werden,Nicht statisch für nicht statische Mitglieder
final         //Wird nicht überschrieben(Konstante)
synchronized  //Exklusive Kontrolle für mehrere Prozesse
native        //Native Klasse, native Methode
strictfp      //Berechnen Sie Gleitkommazahlen gemäß IEEE754
transient     //Von der Serialisierung ausgeschlossen
volatile      //Unterdrücken Sie das Zwischenspeichern von Feldwerten
const         //Mehrsprachiger Konstantenmodifikator, der in Java nicht verwendet wird

/*Anmerkung*/
@Deprecated       //Als veraltet geklärt
@Override         //Stellen Sie klar, dass Sie überschreiben
@SuppressWarning  //Warnanzeige unterdrücken

/*Auftrag*/
@Annotation 
public protected private
abstract static final synchronized native strictfp

Vererbung (Polymorphismus)

Grundlagen der Vererbung

/*Übergeordnete Klasse*/
protected class ClassA{
	protected data_type fieldA;
	protected Class1(data_type varA){　//Übergeordneter Klassenkonstruktor
        this.fieldA = varA;
    }  
	protected void methodA(data_type varB){　//Übergeordnete Klassenmethode
        statementA
    } 
}

/*Kinderklasse*/
public class ClassB extends ClassA{
	public ClassB(data_type varC){ //Untergeordneter Klassenkonstruktor
		super(varC); //Rufen Sie den Konstruktor der übergeordneten Klasse auf
	}
	@Override //Modifikator überschreiben(Wie oben erwähnt)
	public void methodA(data_type var2){
    	statementB //Aussage, Verarbeitung
	}
}

Abstrakte Klasse ... Ich möchte eine Vorlage und eine gemeinsame Verarbeitung implementieren

/*Abstrakte Klasse*/
protected abstract class ClassA{
	protected data_type fieldA;
	public Class1(data_type varA){
		this.fieldA = varA
	}
	//Vorausgesetzte Methode, die überschrieben werden soll(Abstrakte Methode)
	public abstract void methodA(data_type varB); 
}
/*Kinderklasse*/
protected abstract class ClassB{
	@Override
	public abstract void methodA(data_type varB){
    	statementA //Aussage, Verarbeitung
	}
}

Schnittstelle ... Es können nur abstrakte Methoden und Konstanten definiert werden (Prinzip)

/*Schnittstelle*/
public interface InterfaceA{
	/*Grundsätzlich sind die Typen wie folgt aufgeführt.*/
	data_type CONST_A = "CONST_A"; //Das öffentliche statische Finale ist optional
	data_type methodA(data_type varA);

	/* ----Hinzugefügt von Java 8 unten. Persönlich veraltet(Weil es kompliziert ist) ---- */
	//Standardmethode...So etwas wie eine reguläre Methode einer abstrakten Klasse
	default void methodB(data_type varB){
    	statementA //Aussage, Verarbeitung
	}
	//statische Methode...Kann ohne Instanz aufgerufen werden
	public static methodC(data_type varC){
    	statementB //Aussage, Verarbeitung
	}
}

/*Kinderklasse*/
public class ClassB extends InterfaceA{
	public static void main(String[] args){		
		@Override
		public static methodB(data_type varB){
			// Ｘ ClassB.methodC
			// Ｘ @Override methodC
			InterfaceA.methodC(Interface1.CONST_A);
		}
}

Verschiedene Klassen

Generics-Klasse (Vorlage)

public class GenericClassA<TYPE>{
	private TYPE _fieldA;
	GenericClassA(TYPE varA){
		this._fieldA = varA;
	}
	TYPE setMethodA(TYPE varB){
		this._fieldA = varB;
	}
	TYPE getMethodA(){
		return this._fieldA;
	}
}

/*Generische Methode*/
public class ClassA{
	public static <TYPE> ArrayList<TYPE> GenericMethodA(TYPE val1){
	}
}

Innere Klasse

public class ClassA{
	/*statische Mitgliedsklasse... */
	static class MemberClassA{}

	/*Nicht statische Mitgliedsklasse... */
	class MemberClassB{}

	public static void main(String[] args) {
		/*Lokale Klasse... */
		class LocalClassC{
			public void localMethod(){}
		}
		LocalClassC localClassC = new LocalClassC();
		localClassC.localMethod();

		/*Anonyme Klasse...Kann gleichzeitig definiert und instanziiert werden*/
		//Anonyme Klasse, die den ArrayList-Typ erbt
		List<data_typeC> list = new ArrayList<data_typeC>() {
			public data_typeC method3() {
				statements //Aussage, Verarbeitung
			}
		};
	}
}

public class ClassB{
	public static void main(String[] args){
		//statischer Member-Klassenaufruf
		ClassA.MemberClassA cAcA = new ClassA.MemberClassA();
		//Nicht statischer Aufruf der Mitgliedsklasse
		ClassA cA = new ClassA();
		ClassA.MemberClassB cAcB = cA.new MemberClassB();
	}
}

Modul (Java 9)

`module-info.java`


module moduleA{ // module-info.Beschrieben in einer Datei namens Java.
    export moduleA.lib; //Veröffentlichen Sie die Bibliothek in diesem Modul
    requires moduleB;   //Beschreiben Sie die für dieses Modul erforderlichen Module
}

Referenz: Lernen Sie das Modulsystem kennen / Java-Module

Aufzählung (Aufzählungstyp)

public enum EnumA{
	/*Basic*/
	elmA, elmB;
	/*Anwendung-Fügen Sie Mitglieder, Variablen und Methoden hinzu*/
	elmC(0), elmD(1);
	private final int fieldA;
	private setElmA(int varA){
        this.fieldA = varA;
    }
	public int getVal(){
        return fieldA;
    }
	public void outVal(){ // values() ..Liste aller Enum-Elemente
		for (Enum2 enums : values()) { 
			System.out.println(enums.getVal()); // 0, 1
		}
	}
}

Lambda-Ausdruck (Java 8)

Wie schreibt man

/* (args) -> { statements //Aussage, Verarbeitung} */
//In einem Fall argumentiert-> statements
Collections.sort(listA, (a,b) -> {return b - a;});

Methodenreferenz

/*Statische Methode(class::method)*/
// list.forEach(i -> String.toString(i)));
list.forEach(String::toString);

/*Mitgliedsmethode(this::method) */
// list.forEach(i -> this.toString(i)));
list.forEach(this::toString);

/*Generische Methode(class::<type> method) */
// list.forEach(i -> ClassA<typeA> methodA(i);));
list.forEach(ClassA::<typeA> methodA);

/*Instanzmethode(object::method) */
// list.forEach(i -> System.out.print(i));
list.forEach(System.out::print);

/*Konstrukteur(class::new) */
ClassA instanceA = classA::new;

Funktionstyp-Schnittstelle
... Wenn nur eine abstrakte Methode usw. definiert ist, kann sie einem Lambda-Ausdruck oder einer Methodenreferenz zugewiesen werden.

@FunctionalInterface
public interface FuncInterfaceA {
	public data_typeA method(data_typeA varA);
}

/*Hauptstandard-Funktionsschnittstelle*/
// Function.apply()Wert konvertieren
Function<String, Integer> func = x -> x.length();
System.out.println(func.apply("mojisu")); // 6

// Predicate.test()Machen Sie ein Urteil
Predicate<Integer> condA = i -> i != 0 ;
Predicate<Integer> condB = i -> i % 2 == 0 ;
condA.test(2);            // true
condA.negate().test(1);   // false (negate..Verweigerung)
condA.or(condB).test(1);  // true  (oder Urteil)
condA.and(condB).test(1); // false (und Urteil)

// Supplier.get()Gibt einen Wert ohne Argumente zurück
Supplier nowTime = () ->  LocalDateTime.now();
System.out.println(nowTime.get()); // 2020-01-22 12:34:56

// Consumer.accept()Prozess basierend auf Argumenten
Consumer<String> printA = str -> {
	System.out.println("printA: " + str);
}
Consumer<String> printA = str -> {
	System.out.println("printB: " + str);
}
Consumer<String> printAll = printA.andThen(printB); //Beitreten
printAll.accept("" + System.currentTimeMillis());

Referenz: Grundlegendes zu Java 8-Lambda-Ausdrücken / [Java-Funktionsschnittstelle](http://www.ne.jp/asahi/hishidama/home/ tech / java / functioninterface.html)

Stream API (Java 8)

//Stream generieren
Stream<data_typeA> streamA = listA.stream(); // stream()Anziehen
IntStream intStreamA = IntStream.range(1,5); //Stream aus Zahlen erstellen
//Zwischenbetrieb
streamA.filter(p -> p.length() > 5); //Eingrenzen
streamA.map(p -> "[" + p + "]"); //ersetzen
//Kündigungsoperation
List<data_typeB> listB = streamA.collect(Collectors.toList()); //Umwandlung
//Ausgabe
listB.forEach(System.out::println);

/*Einzeiler*/
listA.stream()
	.filter(p -> p.length() > 5)
	.map(p -> "[" + p + "]")
	.collect(Collectors.toList())
	.forEach(System.out::println);

Zwischenbetriebsmethode

Methode	Inhalte verarbeiten	Beispiel
map	Ersetzen Sie das Element durch einen anderen Wert	.map(s-> s.getMethod())
flatmap	Kombinieren Sie Ströme von Elementen	.flatmap(s -> s2.stream())
filter	Eingrenzende Elemente eingrenzen	.filter(s -> s.equals(1)
limit	Eingrenzen auf die angegebene Anzahl	.limit(2)
distinct	Eingrenzen auf einzigartige Elemente	.distinct()
sorted	Elemente sortieren	.sorted((s1,s2) -> s2-s1)
range	Erstellen Sie eine Zahlenspalte ohne den letzten Wert	IntStream.range(1,5)
rangeClosed	Machen Sie eine Zahlenfolge mit dem letzten Wert	IntStream.rangeClosed(1,5)

Kündigungsverfahren

Methode	Inhalte verarbeiten	Beispiel
forEach	Iterieren	.forEach(System.out::println);
collect	Ergebnisse erstellen	.collect(Collectors.toList());
toArray	In ein Array konvertieren	.toArray(String[]::new);
reduce	Aggregierte Werte	.reduce((val1,val2) -> val1.add(val2));
toList	Als Liste zurückgeben	.collect(Collectors.toList());
toSet	Zurück als Set	.collect(Collectors.toSet());
joining	Mit Trennzeichen kombinieren	.collect(Collectors.joining(","));
groupingBy	Gruppenelemente	.collect(Collectors.groupingBy(s -> s.length()));

Dies ist nur ein Memo. Bitte haben Sie Verständnis dafür, dass möglicherweise Fehler vorliegen.

Grundlegende Java-Grammatik

** Art **

In Bezug auf den Typ

Bezüglich Typumwandlung

Variablen und Konstanten

** Erklärung **

Array

** Array mit fester Länge **

** Array variabler Länge (Sammlung) **

** Assoziatives Array (Sammlung) **

** Set (Sammlung) **

Andere

Warteschlange und ihre Implementierung ... FIFO

Deque und seine Implementierung ... Eine Erweiterung von Queue. Kann an beiden Enden hinzugefügt oder gelöscht werden.

Ast

** If-Anweisung **

** switch-Anweisung **

Iterativ

** Zur Aussage **

** While-Anweisung (Do-While-Anweisung) **

** Anweisungen brechen und fortsetzen **

Ausnahmebehandlung ... Auf Fehler prüfen

Ausnahmetyp

Klasse

** Grundlagen der Klasse **

** Modifikator **

** Vererbung (Polymorphismus) **

** Grundlagen der Vererbung **

Abstrakte Klasse ... Ich möchte eine Vorlage und eine gemeinsame Verarbeitung implementieren

Schnittstelle ... Es können nur abstrakte Methoden und Konstanten definiert werden (Prinzip)

** Verschiedene Klassen **

** Generics-Klasse (Vorlage) **

** Innere Klasse **

** Modul (Java 9) **

module-info.java

Aufzählung (Aufzählungstyp)

** Lambda-Ausdruck (Java 8) **

Wie schreibt man

Methodenreferenz

Funktionstyp-Schnittstelle ... Wenn nur eine abstrakte Methode usw. definiert ist, kann sie einem Lambda-Ausdruck oder einer Methodenreferenz zugewiesen werden.

** Stream API (Java 8) **

Zwischenbetriebsmethode

Kündigungsverfahren

Art

Erklärung

Array mit fester Länge

Array variabler Länge (Sammlung)

Assoziatives Array (Sammlung)

Set (Sammlung)

If-Anweisung

switch-Anweisung

Zur Aussage

While-Anweisung (Do-While-Anweisung)

Anweisungen brechen und fortsetzen

Grundlagen der Klasse

Modifikator

Vererbung (Polymorphismus)

Grundlagen der Vererbung

Verschiedene Klassen

Generics-Klasse (Vorlage)

Innere Klasse

Modul (Java 9)

`module-info.java`

Lambda-Ausdruck (Java 8)

Funktionstyp-Schnittstelle
... Wenn nur eine abstrakte Methode usw. definiert ist, kann sie einem Lambda-Ausdruck oder einer Methodenreferenz zugewiesen werden.

Stream API (Java 8)