Résumé du mot réservé Java

table des matières

Qu'est-ce qu'un mot réservé?
Liste des mots réservés
Explication de chaque mot réservé

Qu'est-ce qu'un mot réservé?

Un mot dont le but est prédéterminé dans un langage de programmation. Fondamentalement, les identificateurs (nom de classe, nom de fonction, nom de variable) peuvent être définis librement, mais le même nom que le mot réservé ne peut pas être utilisé.

Liste des mots réservés


abstract	assert	boolean	break	byte
case	catch	char	class	const
continue	default	do	double	else
enum	extends	final	finally	float
for	goto	if	implements	import
instanceof	int	interface	long	native
new	package	private	protected	public
return	short	static	strictfp	super
switch	synchrnized	this	throw	throws
transient	try	void	volatile	while
_

Description de chaque mot réservé

abstract

Utilisé lors de la déclaration d'une classe abstraite.
Une classe abstraite est une classe qui a les méthodes vides suivantes.

nom de la méthode abstraite(argument, argument, ...);

Quand utiliser

Lorsque vous souhaitez créer des règles de mise en œuvre lors d'un développement avec plusieurs personnes.
Lorsque vous souhaitez unifier les noms de méthodes, standardisez la logique et comprenez ce que vous faites.
Lorsque vous ne souhaitez pas écrire de traitement commun à chaque fois pour toutes les classes.
Lorsque le développeur définit une sous-classe et veut pouvoir vérifier si la méthode est oubliée ou si le nom de la méthode est correct.

Exemple de code

abstract class AbstractClass {
  abstract public void method();
}

class ConcreteClass extends AbstractClass{
  public void method(){
    //Détails d'implémentation
  }
}

AbstractClass c = new AbstractClass(); //Erreur de compilation
AbstractClass c = new ConcreteClass(); //Oui
ConcreteClass c = new ConcreteClass(); //Oui

assert

abstract: utilisé lors de la déclaration d'une classe abstraite
assert: Utilisé pour la vérification du fonctionnement du programme (assertion).
Assertion (vérification d'opération): Une méthode pour vérifier si un programme fonctionne normalement. Si vous déclarez une condition qui est toujours vraie à ce moment-là dans diverses parties du programme, Java détectera automatiquement que la condition n'est pas remplie à l'exécution et une AssertionError sera renvoyée.
Vous pouvez activer ou désactiver les assertions en passant l'option -enebleassertions (ou -ea) au moment de l'exécution.

Quand utiliser

Lorsque vous souhaitez fournir un support de débogage.
Lorsque vous souhaitez décrire l'intention du développeur dans le code source du programme.

Exemple de code

private int divide(int x, int y) {
    assert y != 0 : y +"Doit être un nombre supérieur à 0";

    return x / y;
}

boolean

Un type de données qui indique que des données vraies ou fausses doivent être incluses.
S'il est déclaré comme variable d'instance, false sera entré comme valeur initiale, mais s'il est déclaré comme variable locale, la valeur initiale ne sera pas définie, elle doit donc être définie.
Variable d'instance: variable déclarée dans la classe
Variable locale: variable déclarée dans la méthode
Il existe également un booléen, qui est utilisé comme classe. De plus, alors que boolean ne peut pas exprimer null, Boolean peut gérer null. Toutefois, si la variable n'est pas définie sur null, une NullPointerException se produira.

Quand utiliser

Lors de l'expression du résultat de la comparaison des valeurs numériques et des chaînes de caractères.
Lorsque l'instruction if indique la direction du branchement.
Au moment de décider de continuer la boucle avec une instruction for ou while.

Exemple de code

//Dans le cas de l'instruction if
public class Main {
    public static void main(String[] args) throws Exception {
        boolean bool1 = false;
        
        if(bool1) {
          System.out.println("La valeur de bool1 est true");            
        } else {
          System.out.println("La valeur de bool1 est false");
        }
        
        int number = 100;
        
        boolean isResult = number < 200;
        
        if(isResult) {
          System.out.println("La valeur de isResult est true");            
        } else {
          System.out.println("La valeur de isResult est false");    
        }
 
    }
}
//Résultat d'exécution
La valeur de bool1 est false
La valeur de isResult est true

//For while déclaration
public class Main {
    public static void main(String[] args) throws Exception {
        boolean bool = true;　//Réglage de la valeur initiale
        int count = 1; //Réglage de la valeur initiale
        
        while(bool) {
            System.out.println("La valeur de count est" + count + "est.");  
            if(count == 5) {
                bool = false; //Traitement à exécuter lorsque la valeur de count atteint 5.
            }
            count++; //Ajoutez 1 à la valeur de la variable "count".
        }
 
    }
}
//Résultat d'exécution
La valeur de count est 1.
La valeur de count est 2.
La valeur de count est 3.
La valeur de count est 4.
La valeur de count est 5.

//Pour le type booléen
public class Main {
    public static void main(String[] args) throws Exception {
        Boolean bool = null;
        
        if(bool == null) {
            System.out.println("La valeur de bool est nulle");
        } else if(bool) {
            System.out.println("La valeur de bool est true");
        } else {
            System.out.println("La valeur de bool est false");            
        }
 
    }
}
//Résultat d'exécution
La valeur de bool est nulle

break

L'instruction break est une syntaxe utilisée dans les blocs d'instructions for, while, do.. while et switch pour éclater au milieu du traitement. Sortez de la boucle la plus profonde (processus répétitif). Lorsque vous quittez une double boucle, attachez une étiquette (comme un nom) à la première instruction for et spécifiez cette étiquette lorsque vous quittez avec break.

Quand utiliser

Lorsque vous souhaitez terminer le processus et exécuter le processus suivant dans des conditions spécifiques.

Exemple de code

//Pour l'instruction switch
public static void main(String[] args) {
  int num = 3;
  switch(num) {
    case 1:
      System.out.println("C'est 1");
      break;
    case 2:
      System.out.println("C'est 2");
      break;
    case 3:
      System.out.println("C'est 3");
      break;
    case 4:
      System.out.println("C'est 4");
      break;
    default:
      System.out.println("C'est par défaut");
  }
}
//Résultat d'exécution
C'est 3

//Pour déclaration
public static void main(String[] args) {
  for (int i = 1; i <= 5; i++) {
    if (i == 3) {
      break;
    }
    System.out.println(i + "Temps");
  }
  System.out.println("C'est fait");
}
//Résultat d'exécution
Première fois
Deuxième fois
C'est fait

//For while déclaration
public static void main(String[] args) {
  int num = 1;
  while(true) {
    if (num == 3) {
      break;
    }
    System.out.println(num + "C'est la deuxième fois");
    num++;
  }
  System.out.println("C'est fait");
}
//Résultat d'exécution
C'est la première fois
C'est la deuxième fois
C'est fait

//Pour double boucle
loop1: for(Formule d'initialisation;Expression conditionnelle;Changer de formule){//Spécifiez le nom de l'instruction for dans loop1
        for(Formule d'initialisation;Expression conditionnelle;Changer de formule){
                if(Expression conditionnelle lors de la sortie de la boucle for) break loop1;//Spécifiez la sortie pour l'instruction dans loop1

Traitement du contenu
        }
}
//Résultat d'exécution
Lorsque la condition est remplie, quittez le processus loop1

byte

Un des types de données entiers appelés primitives.
Peut représenter des nombres entiers de -128 à 127.

Quand utiliser

Lors de la manipulation de fichiers binaires et de données binaires "telles quelles".
Fichier binaire: un fichier de données binaires. Parmi ceux-ci, ceux qui peuvent être gérés par l'éditeur de texte sont classés comme des fichiers texte.
Données binaires: Données exprimées en binaire pour un traitement direct par l'ordinateur.
Les données envoyées par le serveur pendant le streaming lors du visionnage d'une vidéo sont des données binaires.
Souvent utilisé pour représenter une collection de données binaires dans un tableau plutôt que comme une seule variable.

Exemple de code

//Déclaration de la variable de type octet et affectation de la valeur initiale
byte b = 100;
 
//Déclaration du tableau de type d'octet et affectation de valeur à chaque index
byte[] byteArray1 = new byte[3];
byteArray1[0] = 11;
byteArray1[1] = 12;
byteArray1[2] = 13;
 
//Déclaration du tableau de type d'octet et initialisation en même temps
byte[] byteArray2 = { -128, 0, 127 };

switch

Mots réservés pour le traitement de branche conditionnel.

Quand utiliser

Utilisé lorsqu'il existe plusieurs destinations de succursales conditionnelles.

Exemple de code

public class Main {
  public static void main(String[] args) {
    int num = 3;
    switch(num) {
    case 1:
      System.out.println("Le nombre de variable est 1");
      break;
    case 2:
      System.out.println("Le nombre de variable est 2");
      break;
    case 3:
      System.out.println("Le nombre de variable est 3");
      break;
    case 4:
      System.out.println("Le nombre de variable est 4");
      break;
    default:
      System.out.println("La variable num n'est pas un entier de 1 à 4");
    }
  }
}
//Résultat d'exécution
Le nombre de variable est 3

case

Un mot réservé utilisé lors de l'exécution d'un traitement de branchement conditionnel dans une instruction switch.

Quand utiliser

Utilisé lors de la description de la destination de branche conditionnelle de l'instruction switch.

Exemple de code

public class Main {
  public static void main(String[] args) {
    int num = 3;
    switch(num) {
    case 1:
      System.out.println("Le nombre de variable est 1");
      break;
    case 2:
      System.out.println("Le nombre de variable est 2");
      break;
    case 3:
      System.out.println("Le nombre de variable est 3");
      break;
    case 4:
      System.out.println("Le nombre de variable est 4");
      break;
    default:
      System.out.println("La variable num n'est pas un entier de 1 à 4");
    }
  }
}
//Résultat d'exécution
Le nombre de variable est 3

default

Un mot réservé pour le traitement lorsque la condition n'est pas remplie dans l'instruction switch.
Un mot réservé pour avoir une méthode à implémenter dans l'interface.

Quand utiliser

Utilisé lors de l'exécution du traitement lorsque la condition n'est pas remplie dans l'instruction switch.
Lorsque vous voulez que l'interface ait des méthodes.

Exemple de code

public class Main {
  public static void main(String[] args) {
    int num = 5;
    switch(num) {
    case 1:
      System.out.println("Le nombre de variable est 1");
      break;
    case 2:
      System.out.println("Le nombre de variable est 2");
      break;
    case 3:
      System.out.println("Le nombre de variable est 3");
      break;
    case 4:
      System.out.println("Le nombre de variable est 4");
      break;
    default:
      System.out.println("La variable num n'est pas un entier de 1 à 4");
    }
  }
}
//Résultat d'exécution
La variable num n'est pas un entier de 1 à 4

//Pour l'interface
interface Foo{
    void print(String s);
    default void twice(String s){
        print(s);
        print(s);
    }
}

try

Mots réservés utilisés pour le traitement pouvant entraîner des exceptions.

Quand utiliser

Utilisé pour décrire le traitement qui peut provoquer une exception lorsque vous souhaitez effectuer le traitement lorsqu'une exception se produit.
Lorsque vous souhaitez comprendre la cause d'un problème lors du traitement.

Exemple de code

public class Main {
 
    public static void main(String[] args) {
        int result;
        result = div(5, 0);
        System.out.println("Valeur de retour= " + result);
    }
 
    public static int div(int num1, int num2) {
        try {
            int result = num1 / num2;
            
            return result;
 
        } catch (ArithmeticException e) {
            System.out.println("Une exception s'est produite.");
            System.out.println(e);
 
            return 0;
        }
    }
 
}

catch

Un mot réservé pour le traitement lorsqu'une exception se produit.
Décrivez comme suit.

catch(Nom de la variable de classe d'exception) {
Gestion des exceptions;
}

Classe d'exception: il y a les éléments suivants.
Throwable
- Error
Exceptions d'erreur * OutOfMemoryError * ClassFormatError ...etc.
- Excption
Exception de type d'exception * IOException * ConnectException ...etc.
Exception d'exécution * NullPointException * ArrayIndexOUtOFBOUndsExeception ...etc.

Quand utiliser

Lorsqu'un processus peut provoquer une exception, il est utilisé pour décrire le processus que vous souhaitez exécuter lorsqu'une exception se produit réellement.

Exemple de code

public class Main {
 
    public static void main(String[] args) {
        int result;
        result = div(5, 0);
        System.out.println("Valeur de retour= " + result);
    }
 
    public static int div(int num1, int num2) {
        try {
            int result = num1 / num2;
            
            return result;
 
        } catch (ArithmeticException e) {
            System.out.println("Une exception s'est produite.");
            System.out.println(e);
 
            return 0;
        }
    }
 
}
//Résultat d'exécution
Une exception s'est produite.
java.lang.ArithmeticException: / by zero
Valeur de retour= 0

finally

Un mot réservé qui déclare le processus à exécuter indépendamment du fait qu'une exception se produise.

Quand utiliser

Utilisé pour décrire le processus que vous souhaitez exécuter lorsqu'un processus est susceptible de provoquer une exception, indépendamment du fait qu'une exception se produise ou non.

Exemple de code

int n[] = {18, 29, 36};

System.out.println("début");

try{
  for (int i = 0; i < 4; i++){
    System.out.println(n[i]);
  }
}
catch(ArrayIndexOutOfBoundsException e){
  System.out.println("Au-delà de la portée du tableau");
}
finally{
  System.out.println("Sortie de la matrice terminée");
}

System.out.println("Fini");

throw

Un mot réservé pour déclencher intentionnellement une exception et gérer l'exception.
Lever intentionnellement une exception: déclencher une exception et renvoyer un message d'erreur lorsqu'une certaine condition est remplie.

Quand utiliser

Utilisé lorsque vous souhaitez lever une exception lors du traitement.

Exemple de code

public class Main {
 
    public static void main(String[] args) {
        int result;
        result = div(5, 0);
        System.out.println("Valeur de retour= " + result);
    }
 
    public static int div(int num1, int num2) {
        try {
            if (num2 == 0) {
                throw new ArithmeticException("Lever une exception lorsqu'elle est divisée par 0");
            }
            int result = num1 / num2;
 
            return result;
 
        } catch (Exception e) {
            System.out.println("Une exception s'est produite.");
            System.out.println(e);
 
            return 0;
        }
    }
 
}
//Résultat d'exécution
Une exception s'est produite.
java.lang.ArithmeticException:Lever une exception lorsqu'elle est divisée par 0
Valeur de retour= 0

throws

Un terme réservé qui permet à l'appelant de gérer l'exception lorsqu'une exception se produit.
Appelant: dans le code ci-dessous, main appelle la méthode mathématique, donc main est l'appelant et math est l'appelé.

public static void main(String[] args) {
    int num = 10;

    math(num);

    math(int i) {
        int i += 100;
    }
}

Quand utiliser

Utilisé lorsque vous souhaitez gérer l'occurrence d'exception de la méthode appelée dans la méthode appelante.
Vous pouvez améliorer la lisibilité en appelant diverses méthodes avec la méthode principale et en y traitant les exceptions.

Exemple de code

public class Main {
 
    public static void main(String[] args) {
        int result = 0;
        try {
            result = div(5, 0);
        } catch (Exception e) {
            System.out.println("Une exception s'est produite.");
            System.out.println(e);
        }
 
        System.out.println("Valeur de retour= " + result);
    }
 
    public static int div(int num1, int num2) throws ArithmeticException {
        int result = num1 / num2;
 
        return result;
    }
 
}
//Résultat d'exécution
Une exception s'est produite.
java.lang.ArithmeticException: / by zero
Valeur de retour= 0

for

Mots réservés qui peuvent créer des processus itératifs.

for(Formule d'initialisation;Expression conditionnelle;Changer de formule){
Processus à exécuter
}

Il existe également une instruction for étendue, qui est décrite comme suit.

for (Saisissez le nom de la variable:Nom du tableau ou nom de la collection){
Processus à exécuter
}

Quand utiliser

Utilisé lors de la répétition du traitement.

Exemple de code

public class sample {
    public static void main (String[] args){
        int sum = 0;//[1]
        for (int number = 1; number <= 10; number++) {//[2]
            sum += number;//[3]
        }
        System.out.println("sum:" + sum);//[4]
    }
}
//Résultat d'exécution
sum:55

continue

Un mot réservé pour sauter le reste du traitement comme pour instruction et while instruction et revenir au début de la répétition.

Quand utiliser

Utilisé lorsque vous souhaitez ignorer le reste du processus et revenir au début du processus itératif sous certaines conditions lors de l'exécution du processus itératif.
Ne peut être utilisé que dans le traitement itératif.

Exemple de code

class sample{
    public static void main(String args[]){
  
      for (int i = 1; i < 10; i++){
        if (i % 2 == 0){//Dans ce cas, uniquement lorsque la valeur de i est paire(1)Sera ignoré
          continue;
        }
  
        System.out.println("i = " + i);//(1)
      }
    }
  }
//Résultat d'exécution
i = 1
i = 3
i = 5
i = 7
i = 9

Mot réservé pour le branchement conditionnel.

Quand utiliser

Il existe 6 façons de l'utiliser.
1. Méthode de description lorsqu'il y a plusieurs conditions dans l'instruction if-else
1. Comment utiliser les opérateurs de comparaison (égaux et inégaux)
1. Comment utiliser les opérateurs logiques (OU / ET / NON)
1. Une méthode de description dans laquelle l'instruction if-else est omise sur une ligne en utilisant l'opérateur ternaire.
1. Comment vérifier si la chaîne correspond (égale) / contient la chaîne
1. Comment contrôler la boucle avec pause ou continuer

Exemple de code

//En cas de 1
public class Main{
  public static void main(String[] args){
    int number = 80;
 
    if (number > 90) {
      System.out.println("Excellent résultat!");
    } else if (number > 60) {
      System.out.println("C'est un bon résultat.");
    } else {
      System.out.println("Faisons de notre mieux.");
    }
  }
}
//Résultat d'exécution
C'est un bon résultat.

//En cas de 2
public class Main{
  public static void main(String[] args){
    int number = 10;
    if (number < 20) {
      System.out.println(number + "Est inférieur à 20");
    }
  }
}
//Résultat d'exécution
10 est inférieur à 20

//En cas de 3
public class Main{
  public static void main(String[] args){
    int number = 10;
 
    if ((number < 20) || (number >= 10)) {
      System.out.println(number + "Est une valeur supérieure ou égale à 10 ou inférieure à 20");
    }
  }
}
//Résultat d'exécution
10 est une valeur supérieure ou égale à 10 ou inférieure à 20

//En cas de 4
public class Main {
    public static void main(String[] args) {
 
        int number = 10;
        String str = (number == 5) ? "le nombre est 5" : "le nombre n'est pas 5";
        System.out.println(str);
    }
}
//Résultat d'exécution
le nombre n'est pas 5

//En cas de 5
public class Main {
    public static void main(String[] args) {
 
        String str1 = "Pain au pot";
        if(str1 == "Pain au pot") {
          System.out.println("str1 correspond à la chaîne "potepan"");
        } else {
          System.out.println("str1 ne correspond pas à la chaîne "potepan"");
        }
    }
}
//Résultat efficace
str1 correspond à la chaîne "potepan"

else

Un mot réservé pour le traitement lorsque la condition est fausse lors de l'exécution d'un branchement conditionnel avec l'instruction if.

Quand utiliser

Utilisé pour décrire le traitement lorsque la condition n'est pas satisfaite dans l'instruction if.

Exemple de code

class sample {
    public static void main (String[] args){
        int number = 200;//[1]
        if (number >= 1 && number <= 9){//[2]
            System.out.println("[3] number : 1 - 9");
        } else if (number >= 10 && number <= 99) {//[4]
            System.out.println("[5] number : 10 - 99");
        } else {//[6]
            System.out.println("[7] number >= 100");
        }
    }
}
//Résultat d'exécution
[7] number >= 100

char

Un type qui peut stocker un caractère.
Utilisez celui exprimé en Unicode 16 bits.
Unicode 16 bits: caractères numérotés de 0 à 65535.

Quand utiliser

Utilisé lors du stockage d'un caractère.

Exemple de code

class sample {
    public static void main(String[] args) {
        char  chrHensu1 = 'A';      //Remplacez A tel quel
        char  chrHensu2 = 0x0041;   //Spécifiez 0x0041
        char  chrHensu3 = 65;       //Précisez 65
         
        System.out.println(chrHensu1);
        System.out.println(chrHensu2);
        System.out.println(chrHensu3);
    }
}
//Résultat d'exécution
A
A
A

class

Un mot réservé qui déclare une classe.

Quand utiliser

Utilisé lors de la déclaration d'une classe.

Exemple de code

nom de classe de classe{
Traitement d'exécution...
}

const

Mot réservé invalide.
Un mot réservé qui signifie «constante» dans les langages C / c ++.
En Java, cela correspond à "final".

Quand utiliser

Puisqu'il s'agit d'un mot réservé, il ne peut pas être utilisé pour les noms de variables, les noms de fonctions et les noms de classes.

Exemple de code

Aucun

Mots réservés utilisés avec les instructions while.

Quand utiliser

Dans le traitement itératif, l'évaluation de la première expression conditionnelle est généralement effectuée avant le démarrage du traitement itératif. Dans certains cas, le processus suivant peut être exécuté sans même être traité une seule fois.
Utilisé lorsque vous souhaitez traiter l'instruction while une seule fois afin que cette situation ne se produise pas.

Exemple de code

public class sample {
    public static void main(String[] args) {
        int i = 0;
        do {
            System.out.println((i + 1) + "C'est le deuxième processus");
            i++;
        } while (i < 3);
        System.out.println("Le traitement est terminé");
    }
}
//Résultat d'exécution
C'est le premier processus
C'est le deuxième processus
C'est le troisième processus
Le traitement est terminé

double

L'un des types de données pouvant gérer un petit nombre.
Il existe également une classe Double, qui peut également représenter null.
Peut être exprimé comme nul lorsqu'il y a une erreur dans le numéro attribué et qu'il n'y a pas de valeur.

Quand utiliser

Utilisé lors du traitement de grands nombres compris entre 10 ^ 303 et 10 ^ -324.
La façon d'écrire des nombres qui peuvent être attribués à des variables doubles est la suivante.
Déclin (entier, fraction)
Déclin + notation exponentielle
Nombre binaire (à partir de 0b, entier), Java 7 ou version ultérieure
8 nombres de base (commençant par 0, entier)
Hexagone (commençant par 0x, entier)
Hexagone + notation exponentielle

Exemple de code

//Nombres avec des points décimaux en nombres décimaux et des entiers en nombres binaires, octaux et hexadécimaux
double d1 = 12345; //Nombre décimal(entier)
double d2 = 1.2345; //Nombre décimal(Il y a un point décimal)
double d3 = -123_456.789_012; //Nombre décimal, avec délimiteur
double d4 = 0b0101; //Entier binaire
double d5 = 012345; //Huit entier
double d6 = 0x12345; //Entier hexagonal

//Notation exponentielle pour les nombres décimaux et hexadécimaux
double d1 = 1.23e4; //Notation exponentielle décimale(1.23 × 10 4) → 12300
double d2 = -1.23e-4; //Notation exponentielle décimale(-1.23x10-4e puissance) → -0.000123
double d3 = 0x1.23p4; //Notation d'exposant hexagonale(0x1.23 x 2 à la 4e puissance) → 18.1875
double d4 = -0x1.23p-4; //Notation d'exposant hexagonale(-0x1.23x2-4e puissance) → -0.071044921875

//D comme suffixe/Si vous ajoutez D, le littéral sera traité comme double.
double d1 = 5 / 10; //→ 0, int 5 est divisé par int 10 donc le résultat du calcul est int 0
double d2 = 5 / 10d; // → 0.Puisque 5 sur 5 et int sont divisés par 10 de double, 5 devient également double et le résultat du calcul est 0 de double..Devenir 5

enum

Un type qui peut combiner plusieurs constantes en une seule.
Comme il s'agit d'une classe, vous pouvez définir des champs et des méthodes.
point important
Vous pouvez affecter des valeurs à l'énumérateur de la classe Enum, auquel cas vous devez définir des champs et des constructeurs.
Seuls les modificateurs d'accès privés sont autorisés dans le constructeur de classe Enum.
La classe Enum ne peut pas hériter d'une autre classe, mais elle peut implémenter une interface.
Décrivez et utilisez comme suit.

Nom de l'énumération du modificateur d'accès{Recenseur 1,Recenseur 2,・ ・ ・};

Quand utiliser

Utilisé lorsque vous souhaitez traiter une valeur fixe.
Parce que vous pouvez décrire la constante que vous avez choisie dans enum, et vous pouvez décrire le processus pour cette valeur avec une instruction switch ou similaire.

Exemple de code

Lors de l'utilisation de l'instruction switch
public class Main {
 
    public static void main(String[] args) {
        Fruit fruit_type = Fruit.Orange;
        
        switch(fruit_type) {
            case Orange:
                System.out.println("Délicieuses oranges");
                break;
            case Apple:
                System.out.println("Je veux manger des pommes");
                break;
            case Melon:
                System.out.println("Le melon est tout");
                break;
        }
    }
    
    protected enum Fruit {
        Orange,
        Apple,
        Melon
    };
    
}
//Résultat d'exécution
Délicieuses oranges

Lors de la définition des champs et des méthodes
public class sample {
    public static void main(String[] args) {
        for(Fruit frt : Fruit.values()) {
            System.out.println(frt.ordinal() + ":" + frt.name() + "," + frt.getValue());
        }
    }
    protected enum Fruit {
        Orange("Ehime"),
        Apple("Aomori"),
        Melon("Ibaraki");
        
        //Définir le champ
        private String name;
        
        //Définir le constructeur
        private Fruit(String name) {
            this.name = name;
        }
        
        //Méthode
        public String getValue() {
            return this.name;
        }
    }
    
}
//Résultat d'exécution
0:Orange,Ehime
1:Apple,Aomori
2:Melon,Ibaraki

extends

Mots réservés pour l'héritage de classe.
La classe héritière est appelée "classe de base", "super classe", "classe parent", etc.
Les classes qui héritent de la classe de base sont appelées "classes dérivées", "sous-classes", "petites classes", etc.
Dans une classe dérivée, si vous souhaitez modifier le traitement de la classe de base, vous pouvez écrire un autre traitement sans changer le nom de la méthode ou l'argument de ce traitement. C'est ce qu'on appelle un remplacement.

Quand utiliser

La quantité de code à programmer peut être réduite et la lisibilité du code source peut être améliorée.
En définissant une classe parente, elle peut être utilisée dans d'autres classes enfants, afin que le code puisse être manipulé ensemble.

Exemple de code

public class Student{
　　String name;
　　int id;
　　attend(){}
}

public class School extends Student{
　　test(){}
}

interface

Mots réservés utilisés lors de la mise en œuvre de l'interface.
Il existe une règle selon laquelle l'interface ne peut définir que des constantes et des méthodes.

Quand utiliser

Utilisez les constantes définies dans l'interface dans la méthode définie.
C'est la même chose si vous définissez ce qui est défini dans la classe parente dans la petite classe comme l'héritage de classe, mais la grande différence avec l'héritage de classe est que la classe ne peut hériter qu'un seul à la fois, alors que l'interface Peut être mis en œuvre plusieurs à la fois. Au lieu de cela, vous devez définir toutes les méthodes définies dans l'interface sans interface où vous avez implémenté l'interface.

Exemple de code

//Créer une interface
interface Calc {
    int NUM1 = 1;
    int NUM2 = 2;
 
    void calc();
}
 
//Implémentez l'interface et créez une classe à ajouter
class Add implements Calc {
    public void calc() {
        System.out.println(NUM1 + NUM2);
    }
}
 
//Implémentez l'interface et créez une classe à soustraire
class Sub implements Calc {
    public void calc() {
        System.out.println(NUM1 - NUM2);
    }
}
 
//Créer une classe qui exécute la classe qui implémente l'interface
public class sample {
    public static void main(String[] args) {
        Add add = new Add();
        add.calc();
 
        Sub sub = new Sub();
        sub.calc();
    }
}
//Résultat d'exécution
3
-1

implements

Mots réservés utilisés lors de l'implémentation d'une interface lors de la définition d'une classe.

Quand utiliser

En supposant que l'interface est définie, utilisez-la lorsque vous souhaitez l'implémenter dans la classe.

Exemple de code

public class Sample implémente le nom de l'interface{}

private

Modificateur d'accès.
Modificateurs d'accès: contrôlez les restrictions d'accès des classes définies et où leurs membres peuvent y accéder.

Quand utiliser

Un modificateur accessible uniquement à partir de la classe.

Exemple de code

class PublicClass {
    private String fieldVariable = "Variables de champ PublicClass.";
    
    public void publicMethod() {
        System.out.println(fieldVariable + "Sortie de publicMethod.");
    }
}
 
public class sample {
 
    public static void main(String[] args) {
        PublicClass pc = new PublicClass();
        pc.publicMethod();
    }
 
}
//Résultat d'exécution
Variables de champ PublicClass.Sortie de publicMethod.

protected

Modificateur d'accès.

Quand utiliser

Un modificateur d'accès qui permet d'accéder à une classe du même package ou d'un package différent depuis une sous-classe qui hérite de cette classe.

Exemple de code

//Lors du référencement à partir d'une sous-classe
class SuperClass {
    protected String str = "Variables SuperClass";
}
 
public class sample extends SuperClass {
 
    public static void main(String[] args) {
        sample sc = new sample();
        System.out.println(sc.str);
    }
 
}
//Résultat d'exécution
Variables SuperClass

//Lors du référencement de la même classe
public class sample{
 
    public static void main(String[] args) {
        method();
    }
 
    protected static void method() {
        System.out.println("Méthode avec protégé");
    } 
}
//Résultat d'exécution
Méthode avec protégé

//Si vous ne pouvez pas accéder
class SuperClass {
    protected String str = "Variables SuperClass";
}
 
class SubClass_NG {
 
    public static void main(String[] args) {
        SubClass_NG sc = new SubClass_NG();
        System.out.println(sc.str);
    }
 
}
//Résultat d'exécution
sample.java:9:Erreur:Impossible de trouver le symbole

public

Modificateur d'accès.

Quand utiliser

Un modificateur qui le rend accessible de n'importe où.
Il n'y a qu'une seule classe et interface publique par fichier.
De plus, le nom de fichier à l'exclusion de l'extension, le nom de la classe et le nom de l'interface doivent être identiques.
Le modificateur d'accès qui peut être bouilli dans la classe directement sous le paquet doit être public.

Exemple de code

class PublicClass {
    public String fieldVariable = "Variables de champ PublicClass.";
    
    public void publicMethod() {
        System.out.println(fieldVariable + "Sortie de publicMethod.");
    }
}
 
public class sample {
 
    public static void main(String[] args) {
        PublicClass pc = new PublicClass();
        System.out.println(pc.fieldVariable);
    }
 
}
//Résultat d'exécution
Variables de champ PublicClass.

package

Mots réservés pour déclarer la création d'un package.

Quand utiliser

Utilisé lors de la déclaration d'un package.
Qu'est-ce qu'un package: Un mécanisme pour regrouper et séparer les classes et les interfaces.
Fondamentalement, les noms de classes en double ne sont pas autorisés, mais si les packages sont différents, il n'y a pas de problème même si les noms de classes sont couverts.
Par conséquent, le package est utilisé pour que le nom de la classe puisse être couvert lors du développement avec plusieurs personnes.

Exemple de code

package lang.java.hello;
 
public class HelloJava {
    public HelloJava() {
        System.out.println("Hello Java!");
    }
}
package lang.cpp.hello;
 
public class HelloCpp {
    public HelloCpp() {
        System.out.println("Hello C++!");
    }
}

import

Mots réservés pour l'importation de packages.

Quand utiliser

Utilisé lors de l'importation de packages.
Décrivez comme suit.

nom du package d'importation.Nom de la classe que vous souhaitez importer;

Vous pouvez importer toutes les classes d'un package en ajoutant. * (Wildcard) après le nom du package.

Exemple de code

import lang.cpp.hello.HelloCpp;
import lang.java.hello.HelloJava;
 
public class Main {
 
    public static void main(String[] args) {
        HelloJava hello1 = new HelloJava();
        HelloCpp hello2 = new HelloCpp();
    }
 
}

while

Syntaxe pour le traitement itératif.

Quand utiliser

L'instruction for peut spécifier le nombre d'itérations, mais l'instruction while est utilisée lors de l'exécution d'itérations pour lesquelles le nombre n'est pas spécifié.

Exemple de code

public class sample {
    public static void main(String[] args) {
        int num = 0;
        while (num < 3) {
            System.out.println(num);
            num++;
        }
    }
}
//Résultat d'exécution
0
1
2

goto

Mot réservé non valide en Java.
Dans les langages C / C ++, un mot réservé pour sauter à une ligne spécifique.

Quand utiliser

Indisponible. Si vous l'utilisez, une erreur de compilation se produira.

Exemple de code

Aucun

void

Un mot réservé qui indique qu'il n'y a pas de valeur de retour.

Quand utiliser

Utilisé lorsqu'il n'y a pas de valeur de retour de la méthode.
Valeur de retour: la valeur renvoyée en exécutant le processus d'aucune méthode.

Exemple de code

public class sample {

    static String sampleMethod() {
  
        //Renvoie la chaîne
      return "La méthode d'échantillonnage a été appelée";
    }
  
    public static void main(String[] args) {
  
        //Appelez sampleMethod et affectez le résultat à une variable de type String nommée str
        String str = sampleMethod();
  
        //Sortir le contenu de la variable str
      System.out.println(str);
    }
  }
//Résultat d'exécution
La méthode d'échantillonnage a été appelée

return

Mot réservé lors du retour de la valeur de retour.

Quand utiliser

1. Lors du renvoi d'une valeur de retour.
1. S'il est utilisé au milieu d'une méthode, le processus est renvoyé à l'appelant sans exécuter le processus suivant.

Exemple de code

//En cas de 2
public class sample {
 
	public static void main(String[] args) {
		num(0, 2);
	}
 
	private static void num(int num1, int num2) {
		if (num1 == 0) {
			System.out.println("Revenez à l'appelant.");
			return;
		}
		int addAns = num1 + num2;
		System.out.println("La réponse est" + addAns + "est.");
	}
 
}
//Résultat d'exécution
La réponse est 2.

//S'il n'y a pas de retour dans le même code source
public class sample {
 
	public static void main(String[] args) {
		num(0, 2);
	}
 
	private static void num(int num1, int num2) {
		if (num1 == 0) {
			System.out.println("Revenez à l'appelant.");
			
		}
		int addAns = num1 + num2;
		System.out.println("La réponse est" + addAns + "est.");
	}
 
}
//Résultat d'exécution
Revenez à l'appelant.
La réponse est 2.
//Commentaire
Puisqu'il n'y a pas de retour, le traitement suivant de l'instruction if a été effectué.

new

Mots réservés qui peuvent être instanciés (créer des objets).

Quand utiliser

Utilisé lors de l'instanciation.
Un objet créé à partir d'une classe
Celui qui est exécuté simultanément au moment de l'instanciation est appelé un constructeur.
Écrivez le processus d'initialisation dans ceci.

Exemple de code

nom de la classe principale de la classe publique{
    public static void main(String[] args) {

        //Génération d'instance
Nom de la classe Nom de la variable=nouveau nom de classe();
    }
}

nom de classe de classe{

    //Constructeur (exécuté lors de l'instanciation)
nom de classe publique(){
Processus d'initialisation, etc.
    }
}

static

Un terme réservé qui vous permet d'accéder aux variables sans instancier la classe.

Quand utiliser

Peut être appelé avec le nom de la classe.Nom de la méthode ();.
Lorsque vous ne souhaitez pas effectuer de traitement d'initialisation en créant une instance à chaque appel. Utilisé lorsque vous souhaitez accéder au même objet.

Exemple de code

class ClassSample {
    private int val1 = 0; //Variables non statiques(Variable d'instance)
    private static int val2 = 0; //variable statique(Variable de classe)
 
    //Ajoutez 1 à la variable chaque fois que la classe du constructeur est instanciée
    public ClassSample(int val1, int val2) {
        this.val1 += val1;
        ClassSample.val2 += val2; //"nom de la classe.Déclarez une variable statique avec "nom de variable"
    }
 
    //Afficher la valeur de la variable
    public void print(){
        System.out.println("val1 = " + val1 + ", val2 = " + val2);
    }
}
 
public class sample {
 
    public static void main(String[] args) { 
        for (int i = 0; i < 3; i++){
            ClassSample cs = new ClassSample(1, 1);
            cs.print();
        }
    }
 
}
//Résultat d'exécution
val1 = 1, val2 = 1
val1 = 1, val2 = 2
val1 = 1, val2 = 3

final

Un mot réservé qui représente une constante.

Quand utiliser

Peut être utilisé pour les classes, méthodes et variables respectivement.
Pour les variables: utilisé lorsque la valeur de la variable ou la destination de référence ne peut pas être modifiée.
Toutes les variables finales sont des variables locales, des arguments et des champs (variables d'instance, variables de classe).
Pour une classe: utilisé lorsque la classe ne peut pas être héritée.
Pour les méthodes: utilisé pour rendre impossible le remplacement.
Les classes abstraites et les interfaces ne peuvent pas être définitives.
Parce qu'il ne peut pas être hérité ou implémenté.

Exemple de code

//Pour les variables
int x = 0; //Déclaration de variable ordinaire, avec valeur initiale
x = 1;     //Changer la valeur d'une variable
 
final int y = 10; //Déclarez la variable comme finale, avec la valeur initiale
y = 100;          //La variable finale ne peut pas être modifiée et une erreur de compilation se produit.!!
 
String s = "A"; //Déclaration de variable de type référence ordinaire, avec valeur initiale
s = "B";        //Modifier la destination de référence de la variable de type de référence
 
final String s2 = "C"; //La variable de type de référence est déclarée comme finale, avec la valeur initiale
s2 = "D";              //La variable finale ne peut pas être modifiée et une erreur de compilation se produit.!!

//Pour la classe
final class FinalSample {
}
 
class ChildFinalSample extends FinalSample { //Erreur de compilation!!la classe finale ne peut pas être héritée
}

//Pour les méthodes
class FinalSample {
 final void method() { //méthode d'instance finale
 }
}
 
class ChildFinalSample extends FinalSample { //Puisqu'il ne s'agit pas d'une classe finale, il peut être hérité
 void method() { //Erreur de compilation!!la méthode d'instance finale ne peut pas être remplacée
 }
}

Mot réservé non valide en Java.

Quand utiliser

ne pas utiliser.

Exemple de code

Aucun

float

Un type de données de base qui représente une valeur fractionnaire en 32 bits.

Quand utiliser

Utilisé lorsque vous souhaitez exprimer une valeur dans une fraction flottante.
Numéro d'espèce flottant: données numériques supposant qu'une erreur se produira dans le calcul.
Différence par rapport au double: différence du nombre de bits pouvant être manipulés
double : 64bit | float : 32bit

Exemple de code

public class sample {
  public static void main(String[] args) {
    float f = 1.25f;
    int num = 10;
    float addNum = num + f;

    System.out.println(num + " + " + f + " = " + addNum);
  }
}
//Résultat d'exécution
10 + 1.25 = 11.25

int

Un type de données de base qui représente un entier en 32 bits.

Quand utiliser

Puisqu'il s'agit d'un entier, il gère les valeurs qui augmentent ou diminuent de 1. Il peut représenter des nombres entiers jusqu'à ± 2,1 milliards.
Comment écrire des littéraux int
Nombre binaire (commençant par «0b», à partir de Java 7)
8 numéros de base (commençant par «0»)
Refuser (sans préfixe)
Hexagone (commençant par «0x»)
Qu'est-ce que Integer?
Puisqu'il s'agit d'un type d'objet, il est traité comme une classe.
Utilisé lorsque vous souhaitez convertir du type int en type String.
null est disponible.

Exemple de code

int i1 = 123456789; //Nombre décimal
int i2 = 0b1010101; //Nombre binaire
int i3 = 012345670; //8 base
int i4 = 0x123ABCDE; //Hexadécimal
int i5 = 123_456_789; //Séparateur de chiffres(Tous les 3 chiffres)
int i6 = 0b1111_1010_0101; //Séparateur de chiffres(Tous les 4 bits)

long

Un type de données de base qui représente un entier en 64 bits.

Quand utiliser

Utilisé lors de la gestion de grands nombres qui ne peuvent pas être gérés par le type int.
int
Valeur maximale: 2 ^ 32-1
Valeur minimale: -2 ^ 31
long
Valeur maximale: 2 ^ 63-1
Valeur minimale: -2 ^ 63

Exemple de code

public class sample {
    public static void main(String [] args) {
      int m = 2147483647;
      System.out.println(m);
      
      m += 1;
      System.out.println(m);
  
      long n = 2147483647;
      System.out.println(n);
    
      n += 1;
      System.out.println(n);
    }
  }
//Résultat d'exécution
2147483647
-2147483648
2147483647
2147483648

short

Type de données de base qui représente un entier en 16 bits.

Quand utiliser

Utilisé lors du traitement des nombres entre -32768 et 32767.
Pas de fréquence de crédit élevée.
int > long > short
Lorsqu'une opération est effectuée avec un type court, le résultat de l'opération est renvoyé sous forme de type int, donc si une valeur n'est pas reçue avec une variable de type int, une erreur de compilation se produira.

Exemple de code

public class sample {
    short a=100;
    short b=10;
    short c=0;
    
    c = a + d;
    System.out.println("c =" + c );
  }
//Résultat d'exécution
sample.java:6:Erreur: <identifier>il n'y a pas

instanceof

Un terme réservé qui détermine si la classe référencée par la variable est correcte.

Quand utiliser

Lors du référencement du type de données.
Pour déterminer si une sous-classe hérite d'une superclasse.
Pour déterminer si une interface est implémentée.

Exemple de code

//En se référant au type de données
public class sample {
    public static void main(String[] args) {
 
        Object obj = "samurai";
        System.out.println(obj instanceof String);
        System.out.println(obj instanceof Integer);
    }
}
//Résultat d'exécution
true
false

//Pour déterminer si une sous-classe hérite d'une classe spar
public class sample {
    public static void main(String[] args) {
 
        SubClass sub = new SubClass();
        System.out.println(sub instanceof SubClass);
        System.out.println(sub instanceof SuperClass);
    }
}
 
class SuperClass {}
class SubClass extends SuperClass{}
//Résultat d'exécution
true
true

//Pour déterminer si une interface est implémentée
public class sample {
    public static void main(String[] args) {
 
        SubClass sub = new SubClass();
        System.out.println(sub instanceof SubClass);
        System.out.println(sub instanceof Interface);
    }
}
 
interface Interface {}
class SuperClass implements Interface {}
class SubClass extends SuperClass {}
//Résultat d'exécution
true
true

this

Un mot réservé qui signifie soi-même.

Quand utiliser

Lors du référencement de méthodes et de variables de la même classe.
Lors de l'appel d'un autre constructeur.

Exemple de code

//Lors du référencement de méthodes et de variables de la même classe
public class sample {

    //Exemple de variable de classe
    String animal = "Lapins";

    public void printAnimal() {

      //Variables locales
      String animal = "Chat";
      System.out.println("Animal variable locale:" + animal);
      System.out.println("Classe variable animal:" + this.animal);

    }

    public static void main(String[] args) {

        sample s = new sample();
        s.printAnimal();

      }
  }
//Résultat efficace
Animal variable locale:Chat
Classe variable animal:Lapins

//Lors de l'appel d'un autre constructeur
class ThisSample8 {
    String name;
    int amount;
    
    //① Constructeur par défaut
    ThisSample8() {
    this("Gonbei anonyme", 10); //Appelez ③ avec la valeur par défaut
    }
    
    //② Constructeur surchargé(Partie 1)
    ThisSample8(String name) {
    this(name, 20); //Appelez ③ en utilisant des arguments
    }
    
    //③ Constructeur surchargé(Partie 2)
    ThisSample8(String name, int amount) {
    //L'initialisation du champ se fait uniquement avec ce constructeur
    this.name = name;
    this.amount = amount;
    }
    
    void printProperty() {
    System.out.println(String.format("mon nom est%s. L'argent que tu as%C'est d yen.", name, amount));
    }
    
    public static void sample(String[] args) {
    ThisSample8 sample1 = new ThisSample8();
    sample1.printProperty(); //→ Gonbei anonyme, 10 yens
    
    ThisSample8 sample2 = new ThisSample8("Yamada Taro");
    sample2.printProperty(); //→ Taro Yamada, 20 yens
    
    ThisSample8 sample3 = new ThisSample8("Jiro Suzuki", 1000);
    sample3.printProperty(); //→ Jiro Suzuki, 1000 yens
    }
   }
//Résultat d'exécution
Je m'appelle Anonymous Gonbei. L'argent que vous avez est de 10 yens.
Mon nom est Taro Yamada. L'argent dont vous disposez est de 20 yens.
Je m'appelle Jiro Suzuki. L'argent que vous avez est de 1000 yens.

super

Mots réservés pour référencer des instances et des membres de superclasse.

Quand utiliser

Lors de l'appel du constructeur d'une super classe.
Lors de l'appel de la méthode avant la substitution.

Exemple de code

//Lors de l'appel du constructeur d'une super classe
public class sample {
    public static void main(String[] args) throws Exception {
        
        SubClass sub = new SubClass();
    }
}
 
class SuperClass {
 
    public SuperClass(){
        System.out.println("Super_Const");
    }
 
    public SuperClass(String str){
        System.out.println("str : " + str);
    }
    public SuperClass(int num){
        System.out.println("num : " + num);
    }
}
 
class SubClass extends SuperClass {
 
    public SubClass(){
        super("apple");
    }
}
//Résultat d'exécution
str : apple
//Lors de l'appel de la méthode avant de remplacer
class SuperClassSample {
    String str = "SuperClass";
 
    public String getSrt() {
        return str;
    }
}
 
class SubClassSample extends SuperClassSample {
    String str = "SubClass";
 
    public String getSrt() {
        return str;
    }
 
    public void print() {
        System.out.println("super.str = " + super.str);
        System.out.println("str = " + str);
 
        System.out.println("super.getSrt() = " + super.getSrt());
        System.out.println("getSrt() = " + getSrt());
    }
}
 
public class sample {
    public static void main(String[] args) {
 
        SubClassSample scs = new SubClassSample();
        scs.print();
 
    }
}
//Résultat d'exécution
super.str = SuperClass
str = SubClass
super.getSrt() = SuperClass
getSrt() = SubClass

native

Un modificateur qui indique une méthode écrite dans un langage autre que Java.

Quand utiliser

Il existe un mécanisme appelé JNI (java Native Interface) qui relie le code natif tel que le langage C / C ++.
Il est en fait utilisé dans le code source de l'UCS.
Définissez le nom de la méthode comme une interface dans un fichier Java.
Si vous définissez le fichier c avec JNIEXPORT, le fichier Java et le fichier c sont associés.
Le nom de la méthode décrit dans le fichier Java est le nom de la méthode réellement traitée dans le fichier c.

Exemple de code

//Fichier Java
pablic native boolean isCameraMute();

//fichier c
JNIEXPORT jboolean Préfixe JNICALL_isCameraMute();
return isCsmeraMute();

strictfp

Un mot réservé pour traiter strictement les virgules flottantes selon les règles définies par la norme appelée IEEE754.
Les classes, interfaces et méthodes peuvent être utilisées, mais les variables ne peuvent pas être modifiées.

Quand utiliser

Qu'est-ce que l'IEEE (Institute of Electrical and Electronics Enginners): Un organisme de recherche universitaire dans le domaine de l'ingénierie électrique et de l'information, dont le siège est aux États-Unis. Organisme de normalisation technologique.
Qu'est-ce que IEEE754: une norme pour les virgules flottantes. Il est utilisé pour obtenir le même résultat dans tout environnement où l'erreur de calcul en virgule flottante diffère selon 32 bits ou 64 bits.
Si strictfp n'est pas utilisé, cela dépend de la CPU du PC.

Exemple de code

public class sample {
    public static void main(String args[]) {
        new sample();
    }
    //Générer un constructeur
    public sample() {
        this.strictfpTest();
    }

    strictfp public void strictfpTest() {
        double a = 0.01;
        double b = 0.02;
        double c = 0.0001;

        System.out.println(a * b * c);
    }
}
//Résultat d'exécution
2.0E-8

synchronized

Mot réservé pour contrôle exclusif.

Quand utiliser

Utilisé lors de l'exécution d'un contrôle exclusif.
Contrôle exclusif: Empêcher l'accès simultané aux ressources partagées qui peuvent être utilisées par plusieurs processus.

Exemple de code

//Lorsque vous n'utilisez pas synchronisé
public class sample{
    public static void main(String[] args) {
        Bathroom bathroom = new Bathroom();
        FamilyTread father = new FamilyTread(bathroom, "père");
        FamilyTread mother = new FamilyTread(bathroom, "mère");
        FamilyTread sister = new FamilyTread(bathroom, "sœur");
        FamilyTread me = new FamilyTread(bathroom, "je");

        father.start();
        mother.start();
        sister.start();
        me.start();
    }
}

class FamilyTread extends Thread {
    private Bathroom mBathroom;
    private String mName;

    FamilyTread(Bathroom bathroom, String name) {
        this.mBathroom = bathroom;
        this.mName = name;
    }

    public void run() {
        mBathroom.openDoor(mName);
    }

}

class Bathroom {
    void openDoor(String name) {
        System.out.println(name + ""Je vais prendre un bain!"");
        for (int count = 0; count < 100000; count++) {
            if (count == 1000) {
                System.out.println(name + ""J'ai pris un bain."");
            }
        }
        System.out.println(name + ""Je suis sorti du bain!"");
    }
}
//Résultat d'exécution
Père "Je vais prendre un bain!"
Mère "Je vais prendre un bain!"
Père "J'ai pris un bain."
Ma soeur "Je vais prendre un bain!"
Je prends un bain!"
Mère "J'ai pris un bain."
J'ai "j'ai pris un bain."
Ma soeur "J'ai pris un bain."
Père "Je suis sorti du bain!"
Ma soeur "Je suis sortie du bain!"
Je "Je suis sorti du bain!"
Mère "Je suis sortie du bain!"

//Lorsque synchronisé est utilisé pour la salle de bains de classe
class Bathroom {
    synchronized void openDoor(String name) {
        System.out.println(name + ""Je vais prendre un bain!"");
        for (int count = 0; count < 100000; count++) {
            if (count == 1000) {
                System.out.println(name + ""J'ai pris un bain."");
            }
        }
        System.out.println(name + ""Je suis sorti du bain!"");
    }
//Résultat d'exécution
Père "Je vais prendre un bain!"
Père "J'ai pris un bain."
Père "Je suis sorti du bain!"
Je prends un bain!"
J'ai "j'ai pris un bain."
Je "Je suis sorti du bain!"
Mère "Je vais prendre un bain!"
Mère "J'ai pris un bain."
Mère "Je suis sortie du bain!"
Ma soeur "Je vais prendre un bain!"
Ma soeur "J'ai pris un bain."
Ma soeur "Je suis sortie du bain!"

transient

Un modificateur qui exclut les objets de la sérialisation.

Quand utiliser

Sérialisation: Conversion du contenu d'un objet en un tableau d'octets afin qu'il puisse être enregistré dans un fichier ou envoyé à une autre machine.
Lorsque l'interface Serializable est implémentée, tous les champs sont sérialisés par défaut, mais il est utilisé lorsque vous souhaitez les exclure.
Si vous n'avez pas besoin de sauvegarder l'état.
Correspond au champ que vous souhaitez initialiser lors de la restauration de celui sérialisé.
Si la classe que vous souhaitez sérialiser a des champs non sérialisables.
Les champs de la classe à sérialiser doivent être primitifs ou sérialisables.
Classes qui ne peuvent pas être sérialisées: List, Map, Connection, InputStream, etc.
Méthode qui effectue réellement l'entrée / sortie de la sérialisation: write.Object () S

Exemple de code

//Main.java
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream; 
import java.io.ObjectOutputStream; 
import java.io.Serializable;

public class Main { 
    public static void main(String[] args) throws Exception { 
        Player player = new Player(new Badminton()); 
        player.play();         System.out.println();

        Player clonePlayer = deepCopy(player); 
        clonePlayer.play(); 
        System.out.println();

        System.out.print("Même instance de Player:"); 
        System.out.println(player == clonePlayer); 
        System.out.print("Même instance de badminton:"); 
        System.out.println(player.getSports() == clonePlayer.getSports()); 
    }

    @SuppressWarnings("unchecked") 
    public static <T extends Serializable> T deepCopy(T t) throws Exception { 
        if (t == null) { 
            return null; 
        }

        ByteArrayOutputStream byteOut = null; 
        ObjectOutputStream objectOut = null; 
        try { 
            byteOut = new ByteArrayOutputStream(); 
            objectOut = new ObjectOutputStream(byteOut); 
            objectOut.writeObject(t); 
        } finally { 
            objectOut.close(); 
        }

        ObjectInputStream objectin = null; 
        T copy = null; 
        try { 
            objectin = new ObjectInputStream(new ByteArrayInputStream
                                                     (byteOut.toByteArray())); 
            copy = (T) objectin.readObject(); 
        } finally { 
            objectin.close(); 
        } 
        return copy; 
    } 

}

//Sports.java
public interface Sports { 
    void play(); 
}

class Badminton implements Sports { 
    @Override 
    public void play() { 
        System.out.println("Jouez au badminton."); 
    } 
}

//Player.java
import java.io.Serializable;

@SuppressWarnings("serial") 
public class Player implements Serializable { 
    private transient Sports sports;

    public Player(Sports sports) { 
        this.sports = sports; 
        System.out.println("C'est un constructeur."); 
    }

    public Sports getSports() { 
        return sports;    
 }
 public void play() { 
        System.out.println("Réchauffer.");

        sports.play();

        System.out.println("Refroidir"); 
    } 
}

volatile

Un modificateur qui correspond à la valeur de la variable dans chaque thread avec la mémoire partagée.

Quand utiliser

Pour supprimer la mise en cache des valeurs de champ.
Pour le multithreading, chaque thread peut mettre en cache la même valeur de ressenti. À ce stade, il existe un risque que les valeurs soient différentes même dans le même champ.
Qu'est-ce qu'un cache: En affichant une valeur dans un endroit différent de la mémoire principale, la quantité de stockage est généralement inférieure à celle de la mémoire, mais la valeur peut être appelée et mise à jour à grande vitesse.
Pour empêcher le compilateur de s'optimiser.
Qu'est-ce qu'un compilateur: logiciel qui convertit collectivement des programmes informatiques écrits en programmation de haut niveau (C, Java, etc.) faciles à comprendre pour les humains et ayant des fonctions et une syntaxe compliquées dans un format qui peut être interprété et exécuté par un ordinateur.

Exemple de code

public class VolatileSample {
 
    private static volatile int count = 0;
    //private static int count = 0;
 
    public static void main(String[] args) {
        new MultiThread1().start();
        new MultiThread2().start();
    }
 
    static class MultiThread1 extends Thread {
        public void run() {
            int val = count;
            while(count < 3) {
                if (val != count) {
                    String message = getName() + ": val = " + val + ", count = " + count;
                    System.out.println(message + "mise à jour");
                    val = count;
                }
            }
        }
    }
 
    static class MultiThread2 extends Thread {
        public void run() {
            int val = count;
            while(count < 3) {
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                String message = getName() + ": val = " + val + ", count = " + count;
                System.out.println(message);
                count = ++val;
            }
        }
    }
}
//Résultat d'exécution
Thread-1: val = 0, count = 0
Thread-0: val = 0, count =1 mise à jour
Thread-1: val = 1, count = 1
Thread-0: val = 1, count =2 mise à jour
Thread-1: val = 2, count = 2