Grammaire Java de base à connaître en premier

introduction

Cet article est destiné à être lu par:

• J'ai décidé d'utiliser Java en pratique cette fois, mais j'ai oublié Java depuis que je suis étudiant.
• J'ai de l'expérience en programmation dans d'autres langages tels que C, mais je suis nouveau sur Java.
• Je veux revoir la grammaire de base plutôt que celle orientée objet.

Écrivons la méthode principale et exécutons-la

La simple lecture d'un site ou d'un livre ne vous aide pas à comprendre. Il est très important d'écrire votre propre code et d'exécuter le programme.

1. Point de la méthode principale

• La méthode principale doit appartenir à une classe (par exemple Sample1).
• Le modificateur d'accès public signifie "peut être appelé de n'importe où".
• La fonction principale de Java est décidée pour être publique. --static est attaché pour appeler la méthode main sans instancier la classe.
• La valeur de retour est void, ce qui signifie que la méthode principale ne renvoie rien.
• "String [] args" écrit entre parenthèses de main --String [] signifie un tableau de chaînes --String est un type pour stocker une chaîne de caractères. Ceux classés comme types de référence. --args est le nom de l'argument. La valeur passée dans l'argument de ligne de commande peut être utilisée dans le programme. --Enclenchez les classes et les méthodes dans {}.
• Sortie standard avec System.out.print ().
• L'instruction d'exécution se termine par ;.
• // est la ligne de commentaire. Ignoré lors de l'exécution du programme.

Exemple de programme

Sample1.java

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

2. Exécutez le programme

• Faites en sorte que le nom de fichier (Sample1.java) et le nom de classe (Sample1) soient identiques.
• Notez que l'exécution du programme n'est pas "java Sample1 **. Class **".
• Après l'exécution du programme, la méthode principale est exécutée en premier.

Exemple d'exécution

> javac Sample1.java  #compiler
> java Sample1        #Exécution du programme

hello world　　　　  　#Résultat d'exécution

littéral

point

—— Les littéraux sont les valeurs elles-mêmes, telles que les lettres et les chiffres.

Exemple de programme

Sample2.java

public class Sample2 {
    public static void main(String[] args){
        // 1.Caractère littéral
    	System.out.println('A');
    	
    	char c1 = 'B';
    	System.out.println(c1);     //variable

    	//System.out.println('AB');  //Erreur de compilation
    	
    	System.out.println('\u0041');//Spécification du code de caractère
    	
    	// 2.Chaîne littérale
    	System.out.println("Hello");
    	
    	String str = "123";
    	System.out.println(str);
    	
    	//Supplément:Séquence d'échappement
    	System.out.println("Hello\nWorld!!");
    	
    	// 3.Entier littéral(Nombre décimal)
    	int i = 123;
    	System.out.println(i);
    	System.out.println(i+100);
    	
    	// 4.Nombre à virgule flottante littéral
    	double d = 3.14;
    	System.out.println(d);
    	System.out.println(d+1.54);
    	d = 2.712e-4;
    	System.out.println(d);
    	
    	// 5.Valeur logique littérale
    	boolean b = true;
    	System.out.println(b);
    	b = (10 == 5);
    	System.out.println(b);
    	
    }
}

opérateur

point

--Opérateurs arithmétiques (+, -, *, /, etc.) --Opérateur d'assignation --Opérateur de comparaison --Opérateur logique

• Opérateur de bits
• Priorité de l'opérateur

Exemple de programme

Sample3.java

import java.util.Arrays;  //Pour afficher le contenu du tableau

public class Sample3 {
    public static void main(String[] args){
    	System.out.println("======= 1.Opérateur arithmétique=======");
    	// 1.1 incrément
    	int a = 10;
    	int b = a++;            //Incrément après substitution
    	System.out.println(b);  // int b = a;
    	                        // a = a + 1;
    	                        //Pareil que
    	
    	int x = 10;
    	int y = ++x;            //Incrémenter avant substitution
    	System.out.println(y);  // x = x + 1;
    	                        // int y = x;
    	                        //Pareil que
    	
    	// 1.Concaténation de 2 chaînes
    	String str1 = "Hello " + "World";
    	System.out.println(str1);
    	
    	System.out.println("======= 2.Opérateur d'assignation=======");
    	// 2.1 Affectation (type primitif)
		int x2 = 10;
		int y2 = x2;
		y2 += 1;
		System.out.println(x2);  //Résultat: 10
		System.out.println(y2);  //Résultat: 11
    	
    	// 2.2 Substitution (type de référence)
		int[] x3 = { 10, 20, 30 };
		int[] y3 = x3;
		y3[0] += 1;
		System.out.println(Arrays.toString(x3)); //résultat:[11, 20, 30]、x[0]Notez que la valeur de!!
		System.out.println(Arrays.toString(y3)); //résultat:[11, 20, 30]
    	
    	System.out.println("======= 3.Opérateur de comparaison=======");
    	// 3.1 Comparaison numérique(Type de base,Type de référence)
		int[] x4 = { 1, 2, 3 };
		int[] y4 = { 1, 2, 3 };
    	System.out.println(x4[0] == y4[0]);			//Comparaison de type de base (résultat: vrai)
    	System.out.println(x4 == y4); 				//Comparaison du type de référence 1 (résultat: faux)
    	System.out.println(Arrays.equals(x4, y4)); 	//Comparaison du type de référence 2 (résultat: vrai)
    	
    	// 3.Comparaison de deux chaînes
    	String str2 = "abc";
    	String str3 = "ab";
    	str3 += "c";
    	System.out.println(str2==str3); 		//Résultat: faux
    	System.out.println(str2.equals(str3));	//Résultat: vrai
    	
    	System.out.println("======= 4.Opérateur logique=======");
    	System.out.println("======= 5.Opérateur de bits=======");
    }
}

Déclaration de variable

point

--Il y a une description pour faire la déclaration de variable et l'initialisation séparément, et une description pour le faire en même temps.

Exemple de description à faire séparément

Sample5.java

public class Sample5 {
    public static void main(String[] args){
    	// 1.Déclaration de variable
    	// [Format]Nom du type de données Nom de la variable;
    	int idata;
    	String str;
    	
    	// 2.Attribution de valeur
    	// [Format]Nom de variable=valeur;
    	idata = 100;
    	str = "abcdef";
    	
    	//La substitution est "==Notez que ce n'est pas le cas!
    	// idata == 100;Entraînera une erreur de compilation
    	
    }
}

Exemple de description à faire en même temps

Sample6.java

public class Sample6 {
    public static void main(String[] args){
    	// 1.Déclaration de variable et affectation de valeur
    	// [Format]Nom du type de données Nom de la variable=valeur;
    	int idata = 100;
    	String str = "abcdef";
    }
}

Type primitif (type de données de base)

point

• Les types primitifs sont les types de variables qui sont à la base de Java. -Il se distingue du "type de référence" décrit plus loin. --8 types de types primitifs --Entier
• type d'octet
• Données 8 bits (1 octet) --- Entier de -128 à 127
• type court
• données 16 bits --- Entier de -32768 à 32767 --type d'intensité
• données 32 bits --- Valeur entière de -2147483648 à 2147483647
• type long
• données 64 bits --- Valeur entière de 9223372036854775808 à 9223372036854775807 --Numéro de point flottant
• type de flotteur
• Nombre à virgule flottante simple précision 32 bits
• Le nombre de chiffres valides est de 6 --Double type
• Nombre à virgule flottante double précision 64 bits --Le nombre de chiffres valides est de 15 --Type logique --Type booléen --Vrai / faux valeur (vrai ou faux)
• lettre --char type --Un caractère UNICODE 16 bits
• En fait, il stocke un entier non signé de 16 bits (code de caractère)

Exemple de programme

Sample4.java

public class Sample4 {
    public static void main(String[] args){
    	System.out.println("======= 1.type d'octet=======");
    	byte b1 = 127;
    	System.out.println(b1);		
    	b1 += 1;
    	System.out.println(b1);		// -Il devient 128 (débordement)
    	
    	System.out.println("======= 2.type court=======");
    	short s1 = -32768;
    	System.out.println(s1);		
    	s1 -= 1;
    	System.out.println(s1);		//Il devient 32767 (débordement)
    	
    	System.out.println("======= 3.type int=======");
    	int i1 = s1;
    	i1 += 1;
    	System.out.println(i1);		// 32768(correct)
    	
    	System.out.println("======= 4.type long=======");
    	//long l1 = 9223372036854775807; 	//Erreur de compilation
    	long l1 = 9223372036854775807L;		//correct
    	System.out.println(l1);
    	
    	System.out.println("======= 5.type de flotteur=======");
    	//float f1 = 3.14; 	//Erreur de compilation
    	float f1 = 3.14F; 	//correct
    	System.out.println(f1);
    	
    	System.out.println("======= 6.type double=======");
    	double d1 = 3.14; 
    	d1 = d1 + 5.2e3;
    	System.out.println(d1);

    	System.out.println("======= 7.type booléen=======");
    	boolean bl1 = true;
    	System.out.println(bl1);
    	bl1 = (d1 < 3);				//Puisque d1 est supérieur à 3, le résultat est faux
    	System.out.println(bl1);
    	
    	System.out.println("======= 8.type de caractère=======");
    	char c1 = 'a';
    	char c2 = 'Ah';
    	//char c3 = "ab";		//Erreur de compilation:Impossible de stocker les chaînes
    	System.out.println(c1);
    	System.out.println(c2);
    }
}

Type de référence

point

--En Java, les types de variables autres que les types primitifs sont classés comme "types de référence". --Un exemple typique d'un type de référence est "String"

Exemple de programme

Sample7.java

public class Sample7 {
    public static void main(String[] args){
    	String str = "Hello";	//La chaîne de caractères est"(Double devis)Enfermer dans
    	
    	str += "World!!";
    	
    	System.out.println(str);// "HelloWorld!!"S'affiche comme
    	
    }
}

Quelle est la différence entre un type primitif et un type de référence?

point

――Les deux représentent un "type de variable".

• La différence est la "valeur à mettre dans la variable".
• Le type primitif met la "valeur" elle-même dans la variable. --100, 200, 0, etc. pour les entiers --Pour les lettres, 'a', 'a', etc. --Vrai, faux pour le type logique --Pour le type de référence, "valeur d'adresse mémoire (emplacement mémoire où la valeur est stockée)" est entrée dans la variable. --S'il s'agit d'une chaîne de type String, une valeur d'adresse avec la chaîne "abcdef" (adresse 1000, etc.)

Exemple de programme

Sample8.java

public class Sample8 {
    public static void main(String[] args){
    	//Type primitif
		int x = 10;
		int y = x;
    	
    	//Type de référence
		String s1 = "abc";
		String s2 = s1;
    }
}

Ce qui est contenu dans la variable de type primitif est la "valeur" elle-même

Ce qui est contenu dans la variable de type de référence est "valeur d'adresse mémoire"

La chaîne de caractères "abc" est incluse à l'adresse 1000.

Tableau

Exemple de programme 1

Sample9.java

public class Sample9 {
    public static void main(String[] args){
    	// 1.Déclaration de variable de tableau
    	// [Format]Nom du type de données[]Nom de la séquence;
    	int[] ai;
    	String[] as;
    	
    	// 2.Zone de réserve pour le tableau
    	// [Format]Nom de la séquence=nouveau nom de type[Nombre d'éléments];
    	ai = new int[5];
    	as = new String[10];
    	
    	// 3.Initialisation de la baie
    	// [Format]Nom de la séquence[Numéro d'élément] =valeur initiale;
    	//Remarque: les numéros d'élément commencent par "0"
    	ai[0] = 1;
    	ai[1] = 2;
    	as[0] = "abc";
    	as[1] = "defg";
    }
}

Exemple de programme 2

Sample10.java

public class Sample10 {
    public static void main(String[] args){
    	//Méthode 1: Combinez la déclaration de variable de tableau et l'allocation de zone en un seul
    	// [Format]Nom du type de données[]Nom de la séquence=nouveau nom de type[Nombre d'éléments];
    	int[] ai1 = new int[5];
    	String[] as1 = new String[10];
    	
    	//Méthode 2: Déclaration des variables de tableau,Zone sécurisée,Combinez l'initialisation en une
    	// [Format]Nom du type de données[]Nom de la séquence= {Valeur initiale 1,Valeur initiale 2,・ ・ ・};
    	int[] ai2 = {1, 2, 3};
    	String[] as2 = {"abc", "de", "fghij"};
    }
}

Connaissez-vous les trois principaux éléments de la programmation?

• Traitement séquentiel (traitement séquentiel)
• Branche conditionnelle
• Traitement itératif (traitement répétitif)

Il s'agit d'un concept important commun à tous les langages de programmation, pas seulement à Java.

1. Traitement séquentiel (traitement séquentiel)

Le traitement est exécuté dans l'ordre du haut (haut) au bas (fin) du programme.

Exemple de programme 1

Sample12.java

public class Sample12 {
    public static void main(String[] args){
    	//Le résultat de l'exécution est "1", peu importe le nombre de fois que vous le faites., 2, 3, 4,Affiché dans l'ordre de "5"
    	System.out.println("1"); 
    	System.out.println("2"); 
    	System.out.println("3"); 
    	System.out.println("4"); 
    	System.out.println("5"); 
    }
}

Exemple de programme 2

Sample13.java

public class Sample13 {
    public static void main(String[] args){
    	//C'est la même chose même si vous appelez la méthode.
    	//Le résultat de l'exécution est "1", peu importe le nombre de fois que vous le faites., 2, 3, 4,Il est affiché dans l'ordre de "5".
    	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. Branche conditionnelle

Instruction dite if ou instruction switch. Il est utilisé lors de la modification du déroulement du programme, par exemple lorsqu'une certaine condition est remplie et lorsqu'elle ne l'est pas, et lorsque vous souhaitez effectuer un traitement séparé.

Exemple de programme

Sample14.java

//Résultat d'exécution
//je suis même.
//j est un nombre impair.
//k est pair et égal à 10 ou moins.
//ré
public class Sample14 {
    public static void main(String[] args){
    	int i = 10;
    	int j = 9;
    	int k = 8;
    	int l = 2;
    	
    	// 1.1 if instruction
    	if(i % 2 == 0){
    		System.out.println("je suis même."); 
    	}
    	
    	// 1.2 if-autre déclaration
    	if(j % 2 == 0){
    		System.out.println("j est un nombre pair."); 
    	}else{
    		System.out.println("j est un nombre impair."); 
    	}
    	
    	// 1.3 if-else if instruction
    	if(k % 2 == 0 && k > 10){
    		System.out.println("k est pair et supérieur à 10."); 
    	}else if(k % 2 == 0 && k <= 10){
    		System.out.println("k est pair et égal à 10 ou moins."); 
    	}else{
    		System.out.println("k est un nombre impair."); 
    	}
    	
    	//2 instruction de commutation
    	switch (l){
    	case 0:
    		System.out.println("zéro"); 
    		break;
    	case 1:
    		System.out.println("Ichi"); 
    		break;
    	case 2:
    		System.out.println("ré"); 
    		break;
    	default:
    		System.out.println("Autre"); 
    		break;
    	}
    }
}

3. Traitement itératif (traitement répétitif)

Ce qu'on appelle la déclaration et la déclaration while. Utilisé lors de la répétition d'un certain processus.

Exemple de programme

Sample15.java

//Résultat d'exécution
//  [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 statement: Définissez 100 pour tous les éléments du tableau
    	for(int i = 0; i < ai.length; i++){
    		ai[i] = 100;
    	}
    	System.out.println(Arrays.toString(ai)); 
    	
    	// 2.Instruction while: définit tous les éléments du tableau sur 200
    	int j = 0;
    	while(j < ai.length){
    		ai[j] = 200;
    		j += 1;
    	}
    	System.out.println(Arrays.toString(ai)); 
    	
    	//Edition supplémentaire bien sûr.Il existe une méthode qui n'utilise pas de traitement itératif, mais elle est inefficace.
    	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)); 
    }
}

Faire une méthode

point

--Une méthode (fonction) est une collection de processus. --Définissez le processus avec une méthode, par exemple lors de l'exécution du même processus à plusieurs endroits. --Il existe deux méthodes, "méthode de classe" et "méthode d'instance". Commençons par la méthode de classe.

• Modificateurs d'accès: public, privé, etc. --statique: obligatoire --Return value: Type de valeur à renvoyer à l'appelant de la méthode (void si rien n'est retourné)
• Argument formel: valeur à transmettre à la méthode (omis lorsque rien n'est passé)

Déclaration de méthode de classe

Nom de la méthode de valeur de retour statique du qualificateur d'accès(Argument formel) {
Traitement de la méthode;
　　　：
}

Exemple de programme

Sample11.java

import java.util.Arrays;  //Requis pour afficher le contenu du tableau
public class Sample11 {
    public static void main(String[] args){
    	int[] ai = new int[5];
    	
    	//Passer une valeur (argument réel) lors de l'appel d'une méthode
    	//Dans le cas ci-dessous, les arguments réels sont "ai" et "0".
    	setArray(ai, 0);
    	System.out.println(Arrays.toString(ai)); //résultat:[0, 0, 0, 0, 0]

    	setArray(ai, 100);
    	System.out.println(Arrays.toString(ai)); //résultat:[100, 100, 100, 100, 100]
    }
	
	//Méthode pour définir la valeur spécifiée dans le tableau
	//argument(Argument formel)     int[]array Un tableau qui définit la valeur
	//valeur int val
	//Valeur de retour(Valeur de retour)Aucun
	public static void setArray(int[] array, int val){
		for(int i = 0; i < array.length; i++){
			array[i] = val;
		}
	}
}

référence

• Une explication approfondie de la méthode principale, indispensable pour exécuter Java, et de son mécanisme https://engineer-club.jp/java-main