Java-Lernen: Grundlegende Java-Syntax

2. Java-Grundgrammatik

2.1 Schlüsselwörter

• Definition und Eigenschaften von Schlüsselwörtern

Definition: Eine Zeichenfolge (Wort), die von der Java-Sprache mit einer besonderen Bedeutung ausgestattet wird und für spezielle Zwecke verwendet wird.
Funktionen: Alle Buchstaben in Schlüsselwörtern sind Kleinbuchstaben.
Offizielle Adresse: https://docs.oracle.com/javase/tutorial/java/nutsandbolts /_keywords.html

2.2 Identifikatoren

• Bezeichner
  Java für verschiedeneVariablen, Methoden und KlassenDie Zeichenfolge, die bei der Benennung von Merkmalen wie , verwendet wird, wird als Bezeichner bezeichnet.
  Tipp: Alles, was Sie selbst benennen können, wird als Identifikator bezeichnet.
• Definieren Sie Regeln für rechtliche Identifikatoren:

1. Es besteht aus 26 englischen Buchstaben, Groß- und Kleinbuchstaben, 0-9, _ oder $
2. Zahlen können nicht mit beginnen.
3. Schlüsselwörter und reservierte Wörter können nicht verwendet werden, Schlüsselwörter und reservierte Wörter können jedoch einbezogen werden.
4. Java unterscheidet strikt zwischen Groß- und Kleinschreibung und die Länge ist unbegrenzt.
5. Bezeichner dürfen keine Leerzeichen enthalten

• Namenskonventionen in Java

Paketname: Wenn es aus mehreren Wörtern besteht, sind alle Buchstaben Kleinbuchstaben: xxxyyyzzz
Klassenname, Schnittstellenname: Wenn es aus mehreren Wörtern besteht, wird der erste Buchstabe aller Wörter groß geschrieben: XxxYyyZzz
Variablenname, Methodenname: Wenn es aus mehreren Wörtern besteht, wird der Der erste Buchstabe des ersten Wortes ist kleingeschrieben, der erste Buchstabe jedes
Wortes wird am Anfang des zweiten Wortes großgeschrieben: xxxYyyZzz
Konstantenname: Alle Buchstaben werden großgeschrieben. Bei mehreren Wörtern wird jedes Wort mit einem Unterstrich verbunden: XXX_YYY_ZZZ

2.3 Variablen

• Konzept:
  Ein Speicherbereich im Speicher. Die Daten in diesem Bereich können innerhalb desselben Typbereichs kontinuierlich geändert werden. Eine Variable ist die grundlegendste Speichereinheit in einem Programm. Enthält den Variablentyp, den Variablennamen und den gespeicherten Wert.

• Funktion:
  Wird zum Speichern von Daten im Speicher verwendet.

• Hinweis zur Verwendung von Variablen:
  1. Jede Variable in Java mussZuerst deklarieren, später verwenden
  2. Verwenden Sie den Variablennamen, um auf die Daten in diesem Bereich zuzugreifen.
  3. Der Gültigkeitsbereich der Variablen: innerhalb des {}-Paares, in dem sie definiert ist.
  4. Die Variable ist nur innerhalb ihres Gültigkeitsbereichs gültig
  . 5. Im gleichen Gültigkeitsbereich, das Gleiche Name kann nicht als Variable definiert werden

• Variablen deklarieren
  Syntax: <Datentyp> <Variablenname>
  Zum Beispiel: int var;

• Variablenzuweisung
  Syntax: <Variablenname> = <Wert>
  Beispiel: var = 10;

• Variablen deklarieren und zuweisen
  Syntax: <Datentyp> <Variablenname> = <Initialisierungswert>
  Zum Beispiel: int var = 10;

2.3.1 Klassifizierung von Variablen

①Je nach Datentyp
Für jeden Datentyp wird ein klarer spezifischer Datentyp (stark typisierte Sprache) definiert und unterschiedliche Größen an Speicherplatz im Speicher zugewiesen.

②Je nach Position der Deklaration
außerhalb des Methodenkörpers wird die im Klassenkörper deklarierte Variable aufgerufenMitgliedsvariablen.
Innerhalb eines Methodenkörpers deklarierte Variablen werden aufgerufenlokale Variable.

Dasselbe: Beide haben einen Lebenszyklus. Unterschied: Zusätzlich zu den formalen Parametern müssen lokale Variablen explizit initialisiert werden.

2.3.2 Grundlegende Datentypen

① Ganzzahltyp: Byte, kurz, int, lang

Java各整数类型有固定的表数范围和字段长度，不受具体OS的影响，以保证java程序的可移植性。
Java的整型常量默认为 int 型，声明long型常量须后加‘l’或‘L。
Java程序中变量通常声明为int型，除非不足以表示较大的数，才使用long。

②Gleitkommatyp: Float, Double

Ähnlich wie der Integer-Typ verfügt auch der Java-Gleitkommatyp über einen festen Tabellennummernbereich und eine feste Feldlänge, die nicht vom jeweiligen Betriebssystem beeinflusst werden.

浮点型常量有两种表示形式：
·十进制数形式：如：5.12 512.0f .512 (必须有小数点）
·科学计数法形式:如：5.12e2 512E2 100E-2

float: einfache Genauigkeit, die Mantisse kann auf 7 signifikante Stellen genau sein. In vielen Fällen ist es schwierig, die Anforderungen an die Genauigkeit zu erfüllen.
double: Doppelte Präzision, doppelte Präzision von float. Dieser Typ wird normalerweise verwendet.
Die Gleitkommakonstante von Java ist standardmäßig auf den Typ double eingestellt . Um eine Gleitkommakonstante zu deklarieren , fügen Sie danach „f“ oder „F“ hinzu.

③Zeichentyp: char
char-Daten werden verwendet, um „Zeichen“ (2 Bytes) im üblichen Sinne darzustellen.
Alle Zeichen in Java verwenden die Unicode-Kodierung, sodass ein Zeichen einen Buchstaben, ein chinesisches Zeichen oder ein Zeichen anderer geschriebener Sprachen speichern kann.

字符型变量的三种表现形式：
1.字符常量是用单引号(‘ ’)括起来的单个字符。
例如：char c1 = 'a'; char c2 = '中'; char c3 = '9';
2.Java中还允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量。
例如：char c3 = ‘\n’; // '\n'表示换行符
3.直接使用 Unicode 值来表示字符型常量：‘\uXXXX’。其中，XXXX代表一个十六进制整数。
如：\u000a 表示 \n。

Escape-Zeichen	veranschaulichen
\B	Rücktaste
\N	Zeilenumbruch
\R	Wagenrücklauf
\T	Tabs
"	Anführungszeichen
'	Apostroph
\	Backslash

Der char-Typ ist betriebsbereit. Denn es entspricht alles einem Unicode-Code .

④ Boolescher Typ: boolean
Der boolesche Typ wird zur Beurteilung logischer Bedingungen und im Allgemeinen zur Programmflusssteuerung verwendet:

if条件控制语句；
while循环控制语句；
do-while循环控制语句；
for循环控制语句；

Daten vom booleschen Typ erlauben nur die Werte wahr und falsch, keine Null.
Der vom Java-Sprachausdruck betriebene boolesche Wert wird nach der Kompilierung durch den int-Datentyp in der Java Virtual Machine ersetzt: true wird durch 1 dargestellt und false wird durch 0 dargestellt.

⑤String-Typ: String
String ist kein Basisdatentyp, sondern ein Referenzdatentyp.
Die Verwendung entspricht den grundlegenden Datentypen. Zum Beispiel: String str = "abcd";
Eine Zeichenfolge kann mit einer anderen Zeichenfolge oder direkt mit anderen Datentypen verkettet werden. Zum Beispiel:

str = str + “xyz” ; 
int n = 100;
str = str + n;

2.3.3 Grundlegende Datentypkonvertierung

①Automatische Typkonvertierung:
Der Typ mit geringer Kapazität wird automatisch in den Datentyp mit großer Kapazität konvertiert. Die Datentypen sind nach Kapazität wie folgt sortiert:

• Wenn es mehrere Arten von Datenmischoperationen gibt, konvertiert das System zunächst automatisch alle Daten in den Datentyp mit der größten Kapazität und führt dann Berechnungen durch.
• Byte, Short und Char werden nicht ineinander konvertiert, und die drei werden während der Berechnung zuerst in den Typ int konvertiert .
• Der boolesche Typ kann nicht mit anderen Datentypen betrieben werden.
• Wenn der Wert eines Basisdatentyps mit einer Zeichenfolge (String) (+) verbunden wird, wird der Wert des Basisdatentyps automatisch in einen Zeichenfolgentyp (String) konvertiert .

üben

String str1 = 4;//Urteil wahr oder falsch: falsch
String str2 = 3.5f + "";//Urteil wahr oder falsch: wahr
System.out.println(str2);//Ausgabe: "3.5"
System.out. println( 3+4+"Hallo!");//Ausgabe: 7Hallo!
System.out.println("Hallo!"+3+4);//H Ausgabe: hello! 34
System.out.println('a '+ 1+"Hallo!");//Ausgabe: 98Hallo!
System.out.println("Hallo!"+'a'+1);//Ausgabe: Hallo!a1

② Obligatorische Typkonvertierung

• Der umgekehrte Prozess der automatischen Typkonvertierung wandelt einen Datentyp mit großer Kapazität in einen Datentyp mit kleiner Kapazität um. Wenn Sie es verwenden, müssen Sie ein obligatorisches Konvertierungszeichen hinzufügen: (), dies kann jedoch zu Problemen führenPräzisionsverlust oder Überlauf, achten Sie besonders darauf.
• Normalerweise kann eine Zeichenfolge nicht direkt in einen Basistyp konvertiert werden, aber die Konvertierung einer Zeichenfolge in einen Basistyp kann über die dem Basistyp entsprechende Wrapper-Klasse realisiert werden.
  Zum Beispiel: String a = "43"; int i = Integer.parseInt(a);
• Der boolesche Typ kann nicht in andere Datentypen konvertiert werden.

üben

Beurteilen, ob es kompiliert werden kann
1)
short s = 5;
s = s-2; //Urteil: nein
2)
byte b = 3;
b = b + 4; //Urteil: nein
b = (byte)(b+ 4) ; //Urteil: ja
3)
char c = 'a';
int i = 5;
float d = .314F;
double result = c+i+d; //Urteil: ja
4)
byte b = 5;
short s = 3;
kurzes t = s + b; //Urteil: nein

2.4 Betreiber

Ein Operator ist ein spezielles Symbol, das zur Darstellung von Datenoperationen, Zuweisungen und Vergleichen verwendet wird.
Arithmetische Operatoren, Zuweisungsoperatoren, Vergleichsoperatoren (Relationsoperatoren), logische Operatoren, bitweise Operatoren, ternäre Operatoren

Arithmetischer Operator:

Zuweisungsoperator:
Symbol: =
Wenn die Datentypen auf beiden Seiten von „=" inkonsistent sind, können Sie für die Verarbeitung die automatische Typkonvertierung oder das Prinzip der obligatorischen Typkonvertierung verwenden.
Kontinuierliche Zuordnung wird unterstützt.
Spread-Zuweisungsoperatoren: +=, -=, *=, /=, %= .

Vergleichsoperatoren:

Die Ergebnisse von Vergleichsoperatoren sind boolesch , also entweder wahr oder falsch.

Logische Operatoren:

Beispiele:

class Test {
    
    
public static void main (String [] args) {
    
    
boolean x=true;
boolean y=false;
short z=42;
//if(y == true)
if((z++==42)&&(y=true))z++;
if((x=false) || (++z==45)) z++;
System. out.println(“z=”+z);
}
}
---> z=46

Bitweise Operatoren:

Bitweise Operationen sind Operationen, die direkt an den Binärwerten von Ganzzahlen ausgeführt werden.

Ternärer Operator:

2.5 Programmflusskontrolle

Die Flusskontrollanweisung ist eine Anweisung, mit der die Ausführungssequenz jeder Anweisung im Programm gesteuert wird. Die Anweisung kann zu einem kleinen Logikmodul zusammengefasst werden, das eine bestimmte Funktion ausführen kann. Seine Prozesssteuerungsmethode übernimmt drei grundlegende Prozessstrukturen, die im strukturierten Programmdesign festgelegt sind, nämlich:

• Sequenzstruktur
  Das Programm wird Zeile für Zeile von oben nach unten ausgeführt, ohne dass es zu einer Wertung oder einem Sprung in der Mitte kommt.
• Zweigstruktur
  Führen Sie einen Codeabschnitt basierend auf Bedingungen selektiv aus.
  Es gibt zwei Arten von Verzweigungsanweisungen: if...else und switch-case.
• Schleifenstruktur:
  Führen Sie einen bestimmten Codeabschnitt entsprechend der Schleifenbedingung wiederholt aus.
  Es gibt drei Schleifenanweisungen: while, do...while und for.
  Hinweis: JDK1.5 bietet eine foreach-Schleife, die zum Durchlaufen von Sammlungs- und Array-Elementen praktisch ist.

2.5.1 if-else-Struktur

Gebrauchsanweisung:

• Der bedingte Ausdruck muss ein boolescher Ausdruck (relationaler Ausdruck oder logischer Ausdruck) oder eine boolesche Variable sein
• Wenn der Anweisungsblock nur eine Ausführungsanweisung enthält, kann ein {}-Paar weggelassen werden, es wird jedoch empfohlen, es beizubehalten
• Die if-else-Anweisungsstruktur kann nach Bedarf verschachtelt werden
• Wenn die if-else-Struktur „Multiple Choice“ ist, ist das letzte else optional und kann bei Bedarf weggelassen werden
• Wenn mehrere Bedingungen in einer „sich gegenseitig ausschließenden“ Beziehung stehen, spielt die Reihenfolge zwischen der bedingten Beurteilungsanweisung und der Ausführungsanweisung keine Rolle.
  Wenn mehrere Bedingungen in einer „inklusiven“ Beziehung stehen, „klein nach oben, groß nach unten/Kind nach oben, Eltern nach unten“

Beispiel:

import java.util.Scanner;
public class Hello {
    
    

	public static void main(String[] args) {
    
    
		// TODO Auto-generated method stub
		Scanner scanner = new Scanner(System.in);
		int grade = scanner.nextInt();
		if(grade == 100){
    
    
			System.out.println("小田的成绩为100分，奖励一辆BWM");
		}else if(grade>80&&grade<=99){
    
    
			System.out.println("小田的成绩为"+grade+"分，奖励一台iPhone 14");
		}else if(grade>60&&grade<=80){
    
    
			System.out.println("小田的成绩为"+grade+"分，奖励一个ipad");
		}else{
    
    
			System.out.println("小田的成绩为"+grade+"分，什么都不奖励");
		}

	}

}

2.5.2 Schalter-Gehäuse-Struktur

Relevante Regeln:

• Der Wert des Ausdrucks in switch(expression) muss einer der folgenden Typen sein:byte，short，char，int，枚举 (jdk 5.0)，String (jdk 7.0)；
• Der Wert in der case-Klausel muss seinKonstante, darf weder ein Variablenname noch ein unbestimmter Ausdruckswert sein;
• In derselben Switch-Anweisung unterscheiden sich die konstanten Werte in allen Case-Klauseln voneinander;
• Die Break-Anweisung wird verwendet, um das Programm nach der Ausführung einer Case-Verzweigung aus dem Switch-Anweisungsblock springen zu lassen. Wenn keine Pause vorhanden ist, wird das Programm sequentiell bis zum Ende des Switch ausgeführt
• Die Standardklausel lautetOptional. Gleichzeitig ist auch der Standort flexibel. Wenn kein passender Fall vorhanden ist, führen Sie die Standardausführung aus

Beispiel:

import java.util.Scanner;

/*
从键盘分别输入年、月、日，判断这一天是当年的第几天

	注：判断一年是否是闰年的标准：
		1）可以被4整除，但不可被100整除
	  或
		2）可以被400整除

*/
public class DayJudge {
    
    
	public static void main(String[] args) {
    
    

		Scanner scan = new Scanner(System.in);
		System.out.println("请输入year：");
		int year = scan.nextInt();
		System.out.println("请输入month：");
		int month = scan.nextInt();
		System.out.println("请输入day：");
		int day = scan.nextInt();

		int sumDays = 0; // 定义一个变量来保存总天数

		switch (month) {
    
    
		case 12:
			sumDays += 30;
		case 11:
			sumDays += 31;
		case 10:
			sumDays += 30;
		case 9:
			sumDays += 31;
		case 8:
			sumDays += 31;
		case 7:
			sumDays += 30;
		case 6:
			sumDays += 31;
		case 5:
			sumDays += 30;
		case 4:
			sumDays += 31;
		case 3:
			// sumDays += 28;
			// 判断year是否是闰年
			if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
    
    
				sumDays += 29;
			} else {
    
    
				sumDays += 28;
			}
		case 2:
			sumDays += 31;
		case 1:
			sumDays += day;
		}
		System.out.println(year + "年" + month + "月" + day + "日是当年的第" + sumDays + "天");
	}
}

2.5.3 Schleifenstruktur

① for-Schleife

• Grammatikformat:
  for (①Initialisierungsteil; ②Schleifenbedingungsteil; ④Iterationsteil){
  ③Schleifenkörperteil;
  }
• Ausführungsprozess:
  ①-②-③-④-②-③-④-②-③-④-…-②
• Erläuterung:
  ②Der Schleifenbedingungsteil ist ein boolescher Ausdruck. Wenn der Wert falsch ist, verlassen Sie die Schleife.
  ①Der Initialisierungsteil kann mehrere Variablen deklarieren, diese müssen jedoch vom gleichen Typ sein und durch Kommas getrennt sein.
  ④Mehrere Variablen können durch Kommas getrennt aktualisiert werden
  
  Beispiel:

/*
输出所有的水仙花数，所谓水仙花数是指一个3位数，其各个位上数字立方和等于其本身。
*/
class shuixian 
{
    
    
    public static void main(String[] args) 
    {
    
    
        for(int i=100;i<1000;i++){
    
    
            int b=i/100;//百位
            int s=i/10%10;//十位
            int g=i%10;//个位
            if(i==b*b*b+s*s*s+g*g*g){
    
    
                System.out.println(i);
            }
        }
    }
}

② while-Schleife

• Grammatikformat:
  ①Initialisierungsteil
  while(②Loop-Bedingungsteil){
  ③Loop-Körperteil;
  ④Iterationsteil;
  }
• Ausführungsprozess:
  ①-②-③-④-②-③-④-②-③-④-…-②
• Hinweis:
  Vergessen Sie nicht, den Iterationsteil ④ zu deklarieren. Andernfalls kann die Schleife nicht beendet werden und wird zu einer Endlosschleife.
  For-Schleifen und while-Schleifen können ineinander umgewandelt werden.

public class WhileLoop {
    
    
	public static void main(String args[]) {
    
    
		int result = 0;
		int i = 1;
		while (i <= 100) {
    
    
			result += i;
			i++;
			}
		System.out.println("result=" + result);
		}
}

③do-while-Schleife

• Grammatikformat
  ①Initialisierungsteil;
  do{ ③Loop-Körperteil ④Iterationsteil }while(②Loop-Bedingungsteil);
  
  
  
• Ausführungsprozess:
  ①-③-④-②-③-④-②-③-④-…②
• Erläuterung:
  Die do-while-Schleife führt den Schleifenkörper mindestens einmal aus.

Beispiel:

public class DoWhileLoop {
    
    
	public static void main(String args[]) {
    
    
		int result = 0, i = 1;
		do {
    
    
			result += i;
			i++;
			} while (i <= 100);
		System.out.println("result=" + result);
		}
}

Ausführliches Beispiel für eine Schleifenstruktur:

/*
从键盘输入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序
*/
import java.util.Scanner;
class TestExer 
{
    
    
	public static void main(String[] args) 
	{
    
    
		Scanner s=new Scanner(System.in);
		int a=0;//记录正数的个数
		int b=0;//记录负数的个数
		for(;;){
    
    //for死循环
			System.out.println("请输入一个整数:");
			int num=s.nextInt();
			if(num>0){
    
    
				a++;
			}else if(num<0){
    
    
			  b++;	
			}
			else{
    
    
				break;//死循环中必须要有退出循环语句，否则会一直陷入死循环
			}

			}
		System.out.println("正数个数:"+a);
		System.out.println("负数个数:"+b);
		
	}
}

④ verschachtelte Schleife

• Verschachtelte Schleifen werden gebildet, indem eine Schleife innerhalb einer anderen Schleife platziert wird. Unter ihnen können for, while, do...while als äußere Schleife oder innere Schleife verwendet werden.
• Im Wesentlichen ist eine verschachtelte Schleife ein Schleifenkörper, der die innere Schleife als äußere Schleife behandelt. Erst wenn die Schleifenbedingung der inneren Schleife falsch ist, wird die innere Schleife vollständig herausgesprungen, die aktuelle Schleife der äußeren Schleife kann beendet und die nächste Schleife gestartet werden.
• Unter der Annahme, dass die Anzahl der Schleifen in der äußeren Schicht m-mal und die Anzahl der Schleifen in der inneren Schicht n-mal beträgt, muss der Hauptteil der inneren Schleife tatsächlich m*n- mal ausgeführt werden.

Verwendung spezieller Schlüsselwörter: Pause, Fortfahren

• break kann nur in Switch-Anweisungen und Schleifenanweisungen verwendet werden . continue kann nur in Schleifenanweisungen verwendet werden .
• Die Funktionen der beiden sind ähnlich, aber continue bedeutet, den aktuellen Zyklus zu beenden, und break bedeutet, den aktuellen Schichtzyklus zu beenden .
• Nach break und continue können keine weiteren Anweisungen stehen, da das Programm die nachfolgenden Anweisungen nie ausführt.
• Eine beschriftete Anweisung muss sofort am Kopf der Schleife erscheinen. Beschriftete Anweisungen dürfen nicht vor Nicht-Schleifen-Anweisungen stehen.
• Viele Sprachen verfügen über goto-Anweisungen, mit denen die Steuerung nach Belieben an jede Anweisung im Programm übertragen und dann ausgeführt werden kann. Macht das Programm aber fehleranfällig. Break und Continue unterscheiden sich in Java
  von goto