Apprentissage Java : syntaxe de base Java

2. Grammaire de base Java

2.1 Mots clés

• Définition et caractéristiques des mots clés

Définition : Une chaîne (mot) dotée d'une signification particulière par le langage Java et utilisée à des fins particulières
Caractéristiques : Toutes les lettres des mots-clés sont en minuscules
Adresse officielle : https://docs.oracle.com/javase/tutorial/java/nutsandbolts /_keywords.html

2.2 Identifiants

• Identifiant
  Java pour diversvariables, méthodes et classesLa séquence de caractères utilisée pour nommer des entités telles que , s'appelle un identificateur.
  Conseil : Tout ce que vous pouvez nommer vous-même s'appelle un identifiant.
• Définissez les règles d'identification légale :

1. Il se compose de 26 lettres anglaises, majuscules et minuscules, 0-9, _ ou $
2. Les chiffres ne peuvent pas commencer par.
3. Les mots-clés et les mots réservés ne peuvent pas être utilisés, mais les mots-clés et les mots réservés peuvent être inclus.
4. Java est strictement sensible à la casse et la longueur est illimitée.
5. Les identifiants ne peuvent pas contenir d'espaces

• Conventions de nommage en Java

Nom du package : lorsqu'il est composé de plusieurs mots, toutes les lettres sont en minuscules : xxxyyyzzz
Nom de la classe, nom de l'interface : lorsqu'il est composé de plusieurs mots, la première lettre de tous les mots est en majuscule : XxxYyyZzz
Nom de la variable, nom de la méthode : lorsqu'il est composé de plusieurs mots, le la première lettre du premier mot est en minuscule , la première lettre de chaque
mot est en majuscule au début du second mot : xxxYyyZzz
Nom de la constante : toutes les lettres sont en majuscule. Lorsqu'il y a plusieurs mots, chaque mot est relié par un trait de soulignement : XXX_YYY_ZZZ

2.3 Variables

• Concept :
  Une zone de stockage en mémoire, les données de cette zone peuvent être modifiées en continu dans une même plage de type. Une variable est l'unité de stockage la plus élémentaire d'un programme. Contient le type de variable, le nom de la variable et la valeur stockée.

• Fonction :
  permet de sauvegarder des données en mémoire.

• Remarque sur l'utilisation des variables :
  1. Chaque variable en Java doitDéclarez d'abord, utilisez ensuite
  2. Utilisez le nom de la variable pour accéder aux données de cette zone
  3. La portée de la variable : dans le couple de { } où elle est définie
  4. La variable n'est valide que dans sa portée
  5. Dans la même portée, le même nom ne peut pas être défini variable

• Déclarer des variables
  Syntaxe : <type de données> <nom de variable>
  Par exemple : int var;

• Affectation de variable
  Syntaxe : <nom de variable> = <valeur>
  Exemple : var = 10;

• Déclaration et affectation de variables
  Syntaxe : <type de données> <nom de variable> = <valeur d'initialisation>
  Par exemple : int var = 10;

2.3.1 Classement des variables

①Selon le type de données
Pour chaque type de données, un type de données spécifique clair (langage fortement typé) est défini, et différentes tailles d'espace mémoire sont allouées en mémoire.

②Selon la position de la déclaration,
hors du corps de la méthode, la variable déclarée dans le corps de la classe est appeléeVariables membres.
Les variables déclarées dans le corps d'une méthode sont appeléesvariable locale.

Pareil : les deux ont un cycle de vie Différence : En plus des paramètres formels, les variables locales doivent être explicitement initialisées.

2.3.2 Types de données de base

① Type entier : byte, short, int, long

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

②Type à virgule flottante : flotteur, double

Semblable au type entier, le type à virgule flottante Java a également une plage de numéros de table et une longueur de champ fixes, qui ne sont pas affectées par le système d'exploitation spécifique.

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

flottant : simple précision, la mantisse peut être précise à 7 chiffres significatifs. Dans de nombreux cas, la précision est difficile à répondre à la demande.
double : Double précision, deux fois la précision du flotteur. Ce type est généralement utilisé.
La constante à virgule flottante de Java est par défaut double type , et pour déclarer une constante flottante , ajoutez 'f' ou 'F' après.

③Type de caractère : char
Les données char sont utilisées pour représenter un "caractère" (2 octets) au sens habituel.
Tous les caractères de Java utilisent le codage Unicode, de sorte qu'un caractère peut stocker une lettre, un caractère chinois ou un caractère d'autres langues écrites.

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

caractère d'échappement	illustrer
\b	retour arrière
\n	saut de ligne
\r	retour chariot
\t	Onglets
"	Double citation
'	apostrophe
\	barre oblique inverse

Le type char est utilisable. Car tout correspond à un code Unicode .

④ Type booléen : booléen
Le type booléen est utilisé pour juger des conditions logiques et est généralement utilisé pour le contrôle du déroulement du programme :

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

Les données de type booléen n'autorisent que les valeurs true et false, pas de null.
La valeur booléenne opérée par l'expression du langage Java est remplacée par le type de données int dans la machine virtuelle Java après compilation : true est représenté par 1 et false est représenté par 0.

⑤Type de chaîne : chaîne
La chaîne n'est pas un type de données de base, mais un type de données de référence.
L'utilisation est cohérente avec le type de données de base. Par exemple : String str = "abcd" ;
Une chaîne peut être concaténée avec une autre chaîne, ou directement concaténée avec d'autres types de données. Par exemple:

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

2.3.3 Conversion de type de données de base

①Conversion de type automatique :
le type à petite capacité est automatiquement converti en type de données à grande capacité. Les types de données sont triés par capacité comme suit :

• Lorsqu'il existe plusieurs types d'opérations mixtes de données, le système convertit d'abord automatiquement toutes les données dans le type de données ayant la plus grande capacité , puis effectue les calculs.
• byte, short et char ne sont pas convertis les uns aux autres, et les trois sont d'abord convertis en type int lors du calcul .
• Le type booléen ne peut pas être utilisé avec d'autres types de données.
• Lorsque la valeur d'un type de données de base est connectée à une chaîne (String) (+), la valeur du type de données de base sera automatiquement convertie en un type de chaîne (String) .

pratique

Chaîne str1 = 4;//jugement vrai ou faux : faux
Chaîne str2 = 3.5f + "";//jugement vrai ou faux : vrai
System.out.println(str2);//sortie : "3.5"
System.out. println( 3+4+"Bonjour !");//Sortie : 7Bonjour !
System.out.println("Bonjour !"+3+4);//Sortie H : bonjour ! 34
System.out.println('a '+ 1+"Bonjour!");//Sortie : 98Bonjour!
System.out.println("Bonjour!"+'a'+1);//Sortie : Bonjour!a1

② Conversion de type obligatoire

• Le processus inverse de la conversion automatique de type convertit un type de données de grande capacité en un type de données de petite capacité. Lors de son utilisation, vous devez ajouter un caractère de conversion obligatoire : (), mais cela peut entraînerPerte de précision ou débordement, faites très attention.
• Habituellement, une chaîne ne peut pas être directement convertie en un type de base, mais la conversion d'une chaîne en un type de base peut être réalisée via la classe wrapper correspondant au type de base.
  Tels que : String a = "43" ; int i = Integer.parseInt(a) ;
• Le type booléen ne peut pas être converti en d'autres types de données.

pratique

Juger s'il peut être compilé
1)
court s = 5 ;
s = s-2 ; //jugement : non
2)
octet b = 3 ;
b = b + 4 ; //jugement : non
b = (octet)(b+ 4) ; //jugement : oui
3)
char c = 'a' ;
int i = 5 ;
float d = .314F ;
double résultat = c+i+d ; //jugement : oui
4)
byte b = 5 ;
court s = 3 ;
court t = s + b ; //jugement : non

2.4 Opérateurs

Un opérateur est un symbole spécial utilisé pour représenter les opérations de données, les affectations et les comparaisons.
Opérateurs arithmétiques, opérateurs d'affectation, opérateurs de comparaison (opérateurs relationnels), opérateurs logiques, opérateurs au niveau du bit, opérateurs ternaires

Opérateur arithmétique :

Opérateur d'affectation :
Symbole : =
Lorsque les types de données des deux côtés de "=" sont incohérents, vous pouvez utiliser la conversion de type automatique ou utiliser le principe de la conversion de type obligatoire pour le traitement.
L'affectation continue est prise en charge.
Opérateurs d'affectation répartis : +=, -=, *=, /=, %= .

Opérateurs de comparaison :

les résultats des opérateurs de comparaison sont booléens , c'est-à-dire vrais ou faux.

Opérateurs logiques :

Exemples :

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

Opérateurs au niveau du bit :

Les opérations au niveau du bit sont des opérations effectuées directement sur les valeurs binaires des entiers.

Opérateur ternaire :

2.5 Contrôle du déroulement du programme

L'instruction de contrôle de flux est une instruction utilisée pour contrôler la séquence d'exécution de chaque instruction du programme, et l'instruction peut être combinée dans un petit module logique qui peut remplir une certaine fonction. Sa méthode de contrôle de processus adopte trois structures de processus de base stipulées dans la conception du programme structuré, à savoir :

• Structure de la séquence
  Le programme est exécuté ligne par ligne de haut en bas sans jugement ni saut au milieu.
• Structure de branche
  Exécutez sélectivement une section de code en fonction de conditions.
  Il existe deux types d'instructions de branche, if...else et switch-case.
• Structure de la boucle
  Exécute de manière répétée un certain morceau de code en fonction de la condition de la boucle.
  Il existe trois instructions de boucle : while, do...while et for.
  Remarque : JDK1.5 fournit une boucle foreach, pratique pour parcourir les éléments de collection et de tableau.

2.5.1 structure if-else

Mode d'emploi:

• L'expression conditionnelle doit être une expression booléenne (expression relationnelle ou expression logique), une variable booléenne
• Lorsque le bloc d'instructions n'a qu'une seule instruction d'exécution, une paire de {} peut être omise, mais il est recommandé de conserver
• La structure de l'instruction if-else peut être imbriquée selon les besoins
• Lorsque la structure if-else est "choix multiple", le dernier else est facultatif et peut être omis si nécessaire
• Lorsque plusieurs conditions sont dans une relation "mutuellement exclusive", l'ordre entre l'instruction de jugement conditionnel et l'instruction d'exécution n'a pas d'importance.
  Lorsque plusieurs conditions sont dans une relation "inclusive", "petit haut grand bas / enfant haut parent bas"

exemple:

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 structure du boîtier de commutation

Règles pertinentes :

• La valeur de l'expression dans switch(expression) doit être l'un des types suivants :byte，short，char，int，枚举 (jdk 5.0)，String (jdk 7.0)；
• La valeur dans la clause case doit êtreconstant, ne peut pas être un nom de variable ou une valeur d'expression indéterminée ;
• Dans la même instruction switch, les valeurs constantes de toutes les clauses case sont différentes les unes des autres ;
• L'instruction break est utilisée pour faire sauter le programme hors du bloc d'instruction switch après l'exécution d'une branche case ; s'il n'y a pas d'interruption, le programme s'exécutera séquentiellement jusqu'à la fin de l'interrupteur
• La clause par défaut estfacultatif. Dans le même temps, l'emplacement est également flexible. Lorsqu'il n'y a pas de cas correspondant, exécutez default

exemple:

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 Structure de la boucle

① pour la boucle

• Format de grammaire :
  for (①partie d'initialisation ; ②partie de condition de boucle ; ④partie d'itération){
  ③partie de corps de boucle ;
  }
• Processus d'exécution :
  ①-②-③-④-②-③-④-②-③-④-…-②
• Explication :
  ②La partie condition de la boucle est une expression de type booléen, lorsque la valeur est fausse, quittez la boucle
  ①La partie initialisation peut déclarer plusieurs variables, mais elles doivent être du même type, séparées par des virgules
  ④Plusieurs variables peuvent être mises à jour, séparées par des virgules
  
  exemple:

/*
输出所有的水仙花数，所谓水仙花数是指一个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);
            }
        }
    }
}

② boucle while

• Format de grammaire :
  ①Partie d'initialisation
  while (②Partie de condition de boucle){
  ③Partie de corps de boucle ;
  ④Partie d'itération ;
  }
• Processus d'exécution :
  ①-②-③-④-②-③-④-②-③-④-…-②
• Remarque :
  Attention à ne pas oublier de déclarer la partie itération ④. Sinon, la boucle ne peut pas se terminer et devient une boucle sans fin.
  Les boucles for et while peuvent être converties entre elles.

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);
		}
}

③faire en boucle

• Format de la grammaire
  ①Partie d'initialisation ;
  do{ ③Partie du corps de la boucle ④Partie de l'itération }while(②Partie de la condition de la boucle );
  
  
  
• Processus d'exécution :
  ①-③-④-②-③-④-②-③-④-…②
• Explication :
  La boucle do-while exécute le corps de la boucle au moins une fois.

exemple:

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);
		}
}

Exemple complet de structure de boucle :

/*
从键盘输入个数不确定的整数，并判断读入的正数和负数的个数，输入为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);
		
	}
}

④ boucle imbriquée

• Les boucles imbriquées sont formées en plaçant une boucle à l'intérieur d'une autre boucle. Parmi eux, for, while, do...while peuvent être utilisés comme boucle externe ou boucle interne.
• Essentiellement, une boucle imbriquée est un corps de boucle qui traite la boucle interne comme la boucle externe. Ce n'est que lorsque la condition de boucle de la boucle interne est fausse que la boucle interne sera complètement sautée, la boucle actuelle de la boucle externe peut être terminée et la boucle suivante peut être démarrée.
• En supposant que le nombre de boucles dans la couche externe est m fois et que le nombre de boucles dans la couche interne est n fois, le corps de la boucle interne doit en fait être exécuté m*n fois.

Utilisation de mots-clés spéciaux : pause, continuer

• break ne peut être utilisé que dans les instructions switch et loop . continue ne peut être utilisé que dans des instructions de boucle .
• Les fonctions des deux sont similaires, mais continuer est de terminer le cycle en cours, et pause est de terminer le cycle de couche en cours.
• Il ne peut pas y avoir d'autres instructions après break et continue, car le programme n'exécutera jamais les instructions suivantes.
• Une instruction étiquetée doit apparaître immédiatement en tête de boucle. Les instructions étiquetées ne peuvent pas précéder les instructions sans boucle.
• De nombreux langages ont des instructions goto, qui peuvent transférer le contrôle à n'importe quelle instruction du programme à volonté, puis l'exécuter. Mais rend le programme sujet aux erreurs. Break et continue en Java sont différents
  de goto