Grundlegende Java-Grammatik sollten Sie zuerst kennen

Einführung

Dieser Artikel soll gelesen werden von:

• Ich habe mich dieses Mal für Java entschieden, aber ich habe Java vergessen, seit ich Student war.
• Ich habe Programmiererfahrung in anderen Sprachen wie C, bin aber neu in Java.
• Ich möchte die grundlegende Grammatik überprüfen und nicht objektorientiert.

Schreiben wir die Hauptmethode und führen sie aus

Nur eine Website oder ein Buch zu lesen, hilft Ihnen nicht zu verstehen. Es ist sehr wichtig, eigenen Code zu schreiben und das Programm auszuführen.

1. Punkt der Hauptmethode

• Die Hauptmethode muss zu einer Klasse gehören (zB Beispiel1).
• Der Zugriffsmodifikator public bedeutet "kann von überall aufgerufen werden".
• Die Hauptfunktion von Java ist öffentlich. --static wird angehängt, um die Hauptmethode aufzurufen, ohne die Klasse zu instanziieren.
• Der Rückgabewert ist ungültig, was bedeutet, dass die Hauptmethode nichts zurückgibt.
• "String [] args" in Klammern von main --String [] bedeutet ein Array von Strings --String ist ein Typ zum Speichern einer Zeichenfolge. Diejenigen, die als Referenztypen klassifiziert sind. --args ist der Argumentname. Der im Befehlszeilenargument übergebene Wert kann im Programm verwendet werden.
• Schließen Sie Klassen und Methoden in {} ein.
• Standardausgabe mit System.out.print ().
• Die Ausführungsanweisung endet mit;.
• // ist die Kommentarzeile. Wird beim Ausführen des Programms ignoriert.

Programmbeispiel

Sample1.java

public class Sample1 {
    public static void main(String[] args){
        //Standardausgabe hier
        System.out.print("hello world");
    }
}

2. Führen Sie das Programm aus

• Machen Sie den Dateinamen (Sample1.java) und den Klassennamen (Sample1) gleich.
• Beachten Sie, dass die Programmausführung nicht "java Sample1 **. Class **" ist.
• Nach dem Ausführen des Programms wird zuerst die Hauptmethode ausgeführt.

Ausführungsbeispiel

> javac Sample1.java  #kompilieren
> java Sample1        #Programmausführung

hello world　　　　  　#Ausführungsergebnis

wörtlich

Punkt

• Literale sind die Werte selbst, wie Buchstaben und Zahlen.

Programmbeispiel

Sample2.java

public class Sample2 {
    public static void main(String[] args){
        // 1.Zeichen wörtlich
    	System.out.println('A');
    	
    	char c1 = 'B';
    	System.out.println(c1);     //Variable

    	//System.out.println('AB');  //Kompilierungsfehler
    	
    	System.out.println('\u0041');//Zeichencode-Spezifikation
    	
    	// 2.String-Literal
    	System.out.println("Hello");
    	
    	String str = "123";
    	System.out.println(str);
    	
    	//Ergänzung:Fluchtabfolge
    	System.out.println("Hello\nWorld!!");
    	
    	// 3.Ganzzahliges Literal(Dezimalzahl)
    	int i = 123;
    	System.out.println(i);
    	System.out.println(i+100);
    	
    	// 4.Gleitkommazahl-Literal
    	double d = 3.14;
    	System.out.println(d);
    	System.out.println(d+1.54);
    	d = 2.712e-4;
    	System.out.println(d);
    	
    	// 5.Logisches Werteliteral
    	boolean b = true;
    	System.out.println(b);
    	b = (10 == 5);
    	System.out.println(b);
    	
    }
}

Operator

Punkt

--Arithmetische Operatoren (+, -, *, / usw.) --Aufgabenverwalter

• Vergleichsoperator
• Logischer Operator
• Bit Operator
• Bedienerpriorität

Programmbeispiel

Sample3.java

import java.util.Arrays;  //Anzeigen des Inhalts des Arrays

public class Sample3 {
    public static void main(String[] args){
    	System.out.println("======= 1.Arithmetischer Operator=======");
    	// 1.1 Inkrement
    	int a = 10;
    	int b = a++;            //Inkrement nach Substitution
    	System.out.println(b);  // int b = a;
    	                        // a = a + 1;
    	                        //Gleich wie
    	
    	int x = 10;
    	int y = ++x;            //Inkrement vor der Substitution
    	System.out.println(y);  // x = x + 1;
    	                        // int y = x;
    	                        //Gleich wie
    	
    	// 1.Verkettung von 2 Strings
    	String str1 = "Hello " + "World";
    	System.out.println(str1);
    	
    	System.out.println("======= 2.Aufgabenverwalter=======");
    	// 2.1 Zuordnung (primitiver Typ)
		int x2 = 10;
		int y2 = x2;
		y2 += 1;
		System.out.println(x2);  //Ergebnis: 10
		System.out.println(y2);  //Ergebnis: 11
    	
    	// 2.2 Substitution (Referenztyp)
		int[] x3 = { 10, 20, 30 };
		int[] y3 = x3;
		y3[0] += 1;
		System.out.println(Arrays.toString(x3)); //Ergebnis:[11, 20, 30]、x[0]Beachten Sie, dass der Wert von!!
		System.out.println(Arrays.toString(y3)); //Ergebnis:[11, 20, 30]
    	
    	System.out.println("======= 3.Vergleichsoperator=======");
    	// 3.1 Numerischer Vergleich(Grundtyp,Referenztyp)
		int[] x4 = { 1, 2, 3 };
		int[] y4 = { 1, 2, 3 };
    	System.out.println(x4[0] == y4[0]);			//Grundlegender Typvergleich (Ergebnis: true)
    	System.out.println(x4 == y4); 				//Referenztypvergleich 1 (Ergebnis: false)
    	System.out.println(Arrays.equals(x4, y4)); 	//Referenztypvergleich 2 (Ergebnis: true)
    	
    	// 3.Vergleich mit zwei Zeichenfolgen
    	String str2 = "abc";
    	String str3 = "ab";
    	str3 += "c";
    	System.out.println(str2==str3); 		//Ergebnis: falsch
    	System.out.println(str2.equals(str3));	//Ergebnis: wahr
    	
    	System.out.println("======= 4.Logischer Operator=======");
    	System.out.println("======= 5.Bitoperator=======");
    }
}

Variable Aussage

Punkt

• Es gibt eine Beschreibung, um die Deklaration und Initialisierung von Variablen separat durchzuführen, und eine Beschreibung, um dies gleichzeitig zu tun.

Beispiel für eine Beschreibung, die separat durchzuführen ist

Sample5.java

public class Sample5 {
    public static void main(String[] args){
    	// 1.Variable Aussage
    	// [Format]Datentypname Variablenname;
    	int idata;
    	String str;
    	
    	// 2.Wertzuweisung
    	// [Format]Variablennamen=Wert;
    	idata = 100;
    	str = "abcdef";
    	
    	//Substitution ist "==Beachten Sie, dass dies nicht der Fall ist!
    	// idata == 100;Führt zu einem Kompilierungsfehler
    	
    }
}

Beispiel für eine Beschreibung, die gleichzeitig durchgeführt werden muss

Sample6.java

public class Sample6 {
    public static void main(String[] args){
    	// 1.Variablendeklaration und Wertzuweisung
    	// [Format]Datentypname Variablenname=Wert;
    	int idata = 100;
    	String str = "abcdef";
    }
}

Primitiver Typ (Basisdatentyp)

Punkt

• Primitive Typen sind die Variablentypen, die die Grundlage von Java bilden. -Es unterscheidet sich von dem später beschriebenen "Referenztyp". --8 Arten primitiver Typen --Ganze Zahl --byte Typ
• 8-Bit-Daten (1 Byte) --- Ganzzahl von -128 bis 127 --kurzer Typ
• 16-Bit-Daten --- Ganzzahl von -32768 bis 32767 --int Typ
• 32-Bit-Daten --- Ganzzahliger Wert von -2147483648 bis 2147483647
• langer Typ
• 64-Bit-Daten --- Ganzzahliger Wert von 9223372036854775808 bis 9223372036854775807
• Schwimmpunktnummer
• Schwimmertyp --32-Bit-Gleitkommazahl mit einfacher Genauigkeit
• Die Anzahl der gültigen Ziffern beträgt 6
• Doppeltyp
• 64-Bit-Gleitkommazahl mit doppelter Genauigkeit
• Die Anzahl der gültigen Ziffern beträgt 15 --Logischer Typ --Boolescher Typ
• Wahrer / falscher Wert (wahr oder falsch)
• Brief --char Typ
• Ein 16-Bit-UNICODE-Zeichen
• Tatsächlich wird eine vorzeichenlose 16-Bit-Ganzzahl (Zeichencode) gespeichert.

Programmbeispiel

Sample4.java

public class Sample4 {
    public static void main(String[] args){
    	System.out.println("======= 1.Bytetyp=======");
    	byte b1 = 127;
    	System.out.println(b1);		
    	b1 += 1;
    	System.out.println(b1);		// -Es wird 128 (Überlauf)
    	
    	System.out.println("======= 2.kurzer Typ=======");
    	short s1 = -32768;
    	System.out.println(s1);		
    	s1 -= 1;
    	System.out.println(s1);		//Es wird 32767 (Überlauf)
    	
    	System.out.println("======= 3.int type=======");
    	int i1 = s1;
    	i1 += 1;
    	System.out.println(i1);		// 32768(richtig)
    	
    	System.out.println("======= 4.langer Typ=======");
    	//long l1 = 9223372036854775807; 	//Kompilierungsfehler
    	long l1 = 9223372036854775807L;		//richtig
    	System.out.println(l1);
    	
    	System.out.println("======= 5.Float-Typ=======");
    	//float f1 = 3.14; 	//Kompilierungsfehler
    	float f1 = 3.14F; 	//richtig
    	System.out.println(f1);
    	
    	System.out.println("======= 6.Doppeltyp=======");
    	double d1 = 3.14; 
    	d1 = d1 + 5.2e3;
    	System.out.println(d1);

    	System.out.println("======= 7.Boolescher Typ=======");
    	boolean bl1 = true;
    	System.out.println(bl1);
    	bl1 = (d1 < 3);				//Da d1 größer als 3 ist, ist das Ergebnis falsch
    	System.out.println(bl1);
    	
    	System.out.println("======= 8.char type=======");
    	char c1 = 'a';
    	char c2 = 'Ah';
    	//char c3 = "ab";		//Kompilierungsfehler:Zeichenfolgen können nicht gespeichert werden
    	System.out.println(c1);
    	System.out.println(c2);
    }
}

Referenztyp

Punkt

• In Java werden andere Variablentypen als primitive Typen als "Referenztypen" klassifiziert.
• Ein typisches Beispiel für einen Referenztyp ist "String"

Programmbeispiel

Sample7.java

public class Sample7 {
    public static void main(String[] args){
    	String str = "Hello";	//Die Zeichenkette ist"(Doppeltes Zitat)Einschließen in
    	
    	str += "World!!";
    	
    	System.out.println(str);// "HelloWorld!!"Angezeigt als
    	
    }
}

Was ist der Unterschied zwischen einem primitiven Typ und einem Referenztyp?

Punkt

――Beide stehen für "Variablentyp".

• Der Unterschied ist der "Wert, der in die Variable eingefügt werden soll".
• Der primitive Typ fügt den "Wert" selbst in die Variable ein.
• 100, 200, 0 usw. für ganze Zahlen
• Für Buchstaben, 'a', 'a' usw.
• Richtig, falsch für logischen Typ
• Für den Referenztyp wird "Speicheradresswert (Speicherort, an dem der Wert gespeichert ist)" in die Variable eingegeben. --Wenn es sich um einen String vom Typ String handelt, ein Adresswert mit dem String "abcdef" (Adresse 1000 usw.)

Programmbeispiel

Sample8.java

public class Sample8 {
    public static void main(String[] args){
    	//Primitiver Typ
		int x = 10;
		int y = x;
    	
    	//Referenztyp
		String s1 = "abc";
		String s2 = s1;
    }
}

Was in der primitiven Typvariablen enthalten ist, ist der "Wert" selbst

Was in der Referenztypvariablen enthalten ist, ist "Speicheradresswert"

Die Zeichenkette "abc" ist an der Adresse 1000 enthalten.

Array

Programmbeispiel 1

Sample9.java

public class Sample9 {
    public static void main(String[] args){
    	// 1.Array-Variablendeklaration
    	// [Format]Datentypname[]Sequenzname;
    	int[] ai;
    	String[] as;
    	
    	// 2.Reservebereich für Array
    	// [Format]Sequenzname=neuer Typname[Elementanzahl];
    	ai = new int[5];
    	as = new String[10];
    	
    	// 3.Array-Initialisierung
    	// [Format]Sequenzname[Elementnummer] =Ursprünglicher Wert;
    	//Hinweis: Elementnummern beginnen mit "0"
    	ai[0] = 1;
    	ai[1] = 2;
    	as[0] = "abc";
    	as[1] = "defg";
    }
}

Programmbeispiel 2

Sample10.java

public class Sample10 {
    public static void main(String[] args){
    	//Methode 1: Kombinieren Sie die Deklaration von Arrayvariablen und die Zuweisung von Bereichen zu einer
    	// [Format]Datentypname[]Sequenzname=neuer Typname[Elementanzahl];
    	int[] ai1 = new int[5];
    	String[] as1 = new String[10];
    	
    	//Methode 2: Deklaration von Array-Variablen,Sicherer Bereich,Kombinieren Sie die Initialisierung zu einer
    	// [Format]Datentypname[]Sequenzname= {Anfangswert 1,Anfangswert 2,・ ・ ・};
    	int[] ai2 = {1, 2, 3};
    	String[] as2 = {"abc", "de", "fghij"};
    }
}

Kennen Sie die drei Hauptelemente der Programmierung?

• Sequentielle Verarbeitung (sequentielle Verarbeitung)
• Bedingter Zweig
• Iterative Verarbeitung (repetitive Verarbeitung)

Dies ist ein wichtiges Konzept, das allen Programmiersprachen gemeinsam ist, nicht nur Java.

1. Sequentielle Verarbeitung (sequentielle Verarbeitung)

Die Verarbeitung wird in der Reihenfolge von oben (oben) bis unten (Ende) des Programms ausgeführt.

Programmbeispiel 1

Sample12.java

public class Sample12 {
    public static void main(String[] args){
    	//Das Ausführungsergebnis ist "1", egal wie oft Sie es tun., 2, 3, 4,Wird in der Reihenfolge "5" angezeigt.
    	System.out.println("1"); 
    	System.out.println("2"); 
    	System.out.println("3"); 
    	System.out.println("4"); 
    	System.out.println("5"); 
    }
}

Programmbeispiel 2

Sample13.java

public class Sample13 {
    public static void main(String[] args){
    	//Dies ist auch dann der Fall, wenn Sie die Methode aufrufen.
    	//Das Ausführungsergebnis ist "1", egal wie oft Sie es tun., 2, 3, 4,Es wird in der Reihenfolge "5" angezeigt.
    	System.out.println("1"); 
    	sub();
    	System.out.println("5"); 
    }
	
	public static void sub(){
    	System.out.println("2"); 
    	System.out.println("3"); 
    	System.out.println("4"); 
	}
}

2. Bedingter Zweig

Sogenannte if-Anweisung oder switch-Anweisung. Es wird verwendet, wenn Sie den Programmablauf ändern, z. B. wenn eine bestimmte Bedingung erfüllt ist und wenn sie nicht erfüllt ist und wenn Sie eine separate Verarbeitung durchführen möchten.

Programmbeispiel

Sample14.java

//Ausführungsergebnis
//Ich bin gerade.
//j ist eine ungerade Zahl.
//k ist gerade und 10 oder weniger.
//D.
public class Sample14 {
    public static void main(String[] args){
    	int i = 10;
    	int j = 9;
    	int k = 8;
    	int l = 2;
    	
    	// 1.1 if-Anweisung
    	if(i % 2 == 0){
    		System.out.println("Ich bin gerade."); 
    	}
    	
    	// 1.2 if-sonst Aussage
    	if(j % 2 == 0){
    		System.out.println("j ist eine gerade Zahl."); 
    	}else{
    		System.out.println("j ist eine ungerade Zahl."); 
    	}
    	
    	// 1.3 if-sonst wenn Anweisung
    	if(k % 2 == 0 && k > 10){
    		System.out.println("k ist gerade und größer als 10."); 
    	}else if(k % 2 == 0 && k <= 10){
    		System.out.println("k ist gerade und 10 oder weniger."); 
    	}else{
    		System.out.println("k ist eine ungerade Zahl."); 
    	}
    	
    	//2 switch-Anweisung
    	switch (l){
    	case 0:
    		System.out.println("Null"); 
    		break;
    	case 1:
    		System.out.println("Ichi"); 
    		break;
    	case 2:
    		System.out.println("D."); 
    		break;
    	default:
    		System.out.println("Andere"); 
    		break;
    	}
    }
}

3. Iterative Verarbeitung (repetitive Verarbeitung)

Sogenannte for-Anweisung und while-Anweisung. Wird verwendet, wenn ein bestimmter Vorgang wiederholt wird.

Programmbeispiel

Sample15.java

//Ausführungsergebnis
//  [100, 100, 100, 100, 100, 100, 100, 100, 100, 100]
//  [200, 200, 200, 200, 200, 200, 200, 200, 200, 200]
//  [300, 300, 300, 300, 300, 300, 300, 300, 300, 300]
import java.util.Arrays;

public class Sample15 {
    public static void main(String[] args){
    	int[] ai = new int[10];
    	
    	// 1.for-Anweisung: Setzen Sie 100 für alle Elemente des Arrays
    	for(int i = 0; i < ai.length; i++){
    		ai[i] = 100;
    	}
    	System.out.println(Arrays.toString(ai)); 
    	
    	// 2.while-Anweisung: Setzen Sie alle Elemente des Arrays auf 200
    	int j = 0;
    	while(j < ai.length){
    		ai[j] = 200;
    		j += 1;
    	}
    	System.out.println(Arrays.toString(ai)); 
    	
    	//Extra Edition Natürlich.Es gibt eine Methode, die keine iterative Verarbeitung verwendet, aber ineffizient ist.
    	ai[0] = 300;
    	ai[1] = 300;
    	ai[2] = 300;
    	ai[3] = 300;
    	ai[4] = 300;
    	ai[5] = 300;
    	ai[6] = 300;
    	ai[7] = 300;
    	ai[8] = 300;
    	ai[9] = 300;
    	System.out.println(Arrays.toString(ai)); 
    }
}

Mach eine Methode

Punkt

• Eine Methode (Funktion) ist eine Sammlung von Prozessen.
• Definieren Sie den Prozess mit einer Methode, z. B. wenn Sie denselben Prozess an mehreren Stellen ausführen.
• Es gibt zwei Methoden, "Klassenmethode" und "Instanzmethode". Beginnen wir mit der Klassenmethode.
• Zugriffsmodifikatoren: öffentlich, privat usw. --static: erforderlich --Return value: Werttyp, der an den Aufrufer der Methode zurückgegeben werden soll (ungültig, wenn nichts zurückgegeben wird)
• Normales Argument: Wert, der an die Methode übergeben werden soll (wird weggelassen, wenn nichts übergeben wird)

Deklaration der Klassenmethode

Name der statischen Rückgabewertmethode des Zugriffsqualifizierers(Formelles Argument) {
Methodenverarbeitung;
　　　：
}

Programmbeispiel

Sample11.java

import java.util.Arrays;  //Erforderlich, um den Inhalt des Arrays anzuzeigen
public class Sample11 {
    public static void main(String[] args){
    	int[] ai = new int[5];
    	
    	//Übergeben Sie beim Aufrufen einer Methode einen Wert (tatsächliches Argument)
    	//Im folgenden Fall sind die tatsächlichen Argumente "ai" und "0".
    	setArray(ai, 0);
    	System.out.println(Arrays.toString(ai)); //Ergebnis:[0, 0, 0, 0, 0]

    	setArray(ai, 100);
    	System.out.println(Arrays.toString(ai)); //Ergebnis:[100, 100, 100, 100, 100]
    }
	
	//Methode zum Festlegen des angegebenen Werts im Array
	//Streit(Formelles Argument)     int[]Array Ein Array, das den Wert festlegt
	//int val value
	//Rückgabewert(Rückgabewert)Keiner
	public static void setArray(int[] array, int val){
		for(int i = 0; i < array.length; i++){
			array[i] = val;
		}
	}
}

Referenz

• Eine ausführliche Erläuterung der für die Java-Ausführung unverzichtbaren Hauptmethode und ihres Mechanismus https://engineer-club.jp/java-main