Formation au développement Java

01. Construction de l'environnement de développement Java

0101. Installation de Java

010101. jdk1.8.0_241 Adresse de téléchargement

https://www.oracle.com/cn/java/technologies/javase-jdk8-downloads.html

010102. Veuillez installer conformément au manuel de procédure.

010103. Paramètre JAVA_HOME

0102. Installation IDE

010201. IntelliJ IDEA 2019.3 Adresse de téléchargement

https://www.jetbrains.com/idea/download/download-thanks.html?platform=windows&code=IIC

010202. Veuillez installer selon le manuel de procédure.

のダブルクリック

010203. Autre

• Localisation japonaise d'Eclipsen (https://mergedoc.osdn.jp/)
• VSCODE(https://code.visualstudio.com/docs/?dv=win64user)

02. Principes de base de Java

0201 Syntaxe Java-Basic

■ Lorsque vous pensez aux programmes Java, il y a les éléments suivants.

• objet --Classe --Méthode --Variables d'instance

■ Premier programme Java

java

public class Test {
    /**
     * First program
     * @param args
     */
    public static void main(String []args){
        System.out.println("Hello World!");
    }
}

cmd

C:\Users\luyu1\IdeaProjects\Learn20200314\src>javac Test.java
C:\Users\luyu1\IdeaProjects\Learn20200314\src>java Test

■ Syntaxe de base Pour les programmes Java, il est très important de garder à l'esprit les points suivants:

--Sensible aux majuscules et minuscules --Nom de classe (en majuscules) --Nom de la méthode (en minuscules) --Class name = Enregistrer le nom du fichier

• Entrée d'exécution (public static void main (String args []))

■ Identificateur Java En Java, il y a quelques points à garder à l'esprit concernant les identifiants.

• Tous les identifiants doivent commencer par une lettre (A à Z ou a à z), une lettre de devise ($) ou un trait de soulignement (_).

• L'identifiant peut avoir n'importe quelle combinaison de caractères après le premier caractère.

• Les mots-clés ne peuvent pas être utilisés comme identifiants.

――Le plus important est que l'identifiant respecte la casse.

--Exemples d'identifiants valides: âge, $ salaire, _valeur, __ 1_valeur.

• Exemple d'identifiant incorrect: 123abc, -salary.

java

■ Modificateur Java Il existe deux catégories de modificateurs.

• Modificateurs accessibles - par défaut, public, protégé, privé

• Modificateurs inaccessibles - final, abstract, strictfp

java

■ Variables Java Voici les types de variables Java

• Variables locales
• Variables de classe (variables statiques)
• Variables d'instance (variables non statiques)

java

■ Tableau Java Un tableau est un objet qui stocke plusieurs variables du même type.

■ Énumération Java

java

class FreshJuice {
   enum FreshJuiceSize{ SMALL, MEDIUM, LARGE }
   FreshJuiceSize size;
}

public class FreshJuiceTest {

   public static void main(String args[]) {
      FreshJuice juice = new FreshJuice();
      juice.size = FreshJuice.FreshJuiceSize.MEDIUM ;
      System.out.println("Size: " + juice.size);
   }
}

■ Mots clés Java La liste suivante répertorie les termes réservés Java.

■ Commentaires Java Prend en charge les commentaires sur une et plusieurs lignes. Tous les caractères disponibles dans le commentaire seront ignorés par le compilateur Java.

java

public class MyFirstJavaProgram {

   /* This is my first java program.
    * This will print 'Hello World' as the output
    * This is an example of multi-line comments.
    */

   public static void main(String []args) {
      // This is an example of single line comment
      /* This is also an example of single line comment. */
      System.out.println("Hello World");
   }
}

■ Utilisez des lignes vides Les lignes qui ne contiennent probablement que des blancs commentés sont appelées des lignes vides et Java les ignore complètement.

■ Héritage En Java, les classes peuvent être dérivées de classes. Fondamentalement, si vous devez créer une nouvelle classe et qu'elle contient déjà une partie du code dont vous avez besoin, vous pouvez dériver la nouvelle classe à partir de votre code existant. Dans ce scénario, les classes existantes sont appelées des superclasses et les classes dérivées sont appelées des sous-classes.

■ Interface Dans le langage Java, les interfaces peuvent être définies comme des contrats sur la manière dont les objets communiquent entre eux. Les interfaces jouent un rôle important dans le concept d'héritage.

L'interface définit la méthode et doit être utilisée par la classe dérivée (sous-classe). Cependant, la mise en œuvre de la méthode relève entièrement de la sous-classe.

0202. Objets et classes Java

Java est un langage orienté objet. En tant que langage doté de capacités orientées objet, Java prend en charge les concepts de base suivants:

--Polytype --Héritage

• Encapsulation --Abstrait --Classe
• objet
• exemple
• Méthode --Message passant

Ce chapitre décrit les classes de concepts et les objets.

Objet-Un objet a un état et un comportement. Exemple: un chien a un état de couleur, de nom, de race, de comportement, etc., et secoue, se nourrit et mange. L'objet est une instance de la classe.

La classe Classe A peut être définie comme un modèle / graphique qui décrit le comportement / l'état pris en charge par un objet de ce type.

■ Objets Java Regardons de plus près ce qu'est un objet. Étant donné le monde réel, nous pouvons trouver de nombreux objets, voitures, chiens, humains, etc. autour de nous. Tous ces objets ont des états et des comportements.

Étant donné un chien, sa condition - nom, race, couleur et comportement - est bar, agitant et courant.

En comparant les objets logiciels à des objets réels, ils ont des caractéristiques très similaires.

Les objets logiciels ont également des états et des comportements. L'état d'un objet logiciel est stocké dans un champ et son comportement est affiché via une méthode.

Par conséquent, dans le développement de logiciels, les méthodes fonctionnent dans l'état interne des objets et la communication inter-objets se fait par des méthodes.

■ Classe Java Une classe est une classe dans laquelle des objets individuels sont créés.

Voici un exemple de classe.

java

public class Dog {
   String breed;
   int age;
   String color;

   void barking() {
   }

   void hungry() {
   }

   void sleeping() {
   }
}

La classe peut contenir l'un des types de variables suivants:

Variables locales - Les variations définies dans une méthode, un constructeur ou un bloc sont appelées variables locales. La variable est déclarée et initialisée dans la méthode, et la variable est détruite lorsque la méthode se termine.

Variables d'instance - Les variables d'instance sont des méthodes au sein d'une classe, mais externes à la méthode. Ces variables sont initialisées lorsque la classe est instanciée. Les variables d'instance sont accessibles depuis une méthode, un constructeur ou un bloc de cette classe particulière.

Variables de classe - Les variables de classe sont des variables déclarées dans une classe, et non dans une méthode, à l'aide de mots-clés statiques.

La classe peut contenir n'importe quel nombre de méthodes pour accéder aux valeurs de différents types de méthodes. Dans l'exemple ci-dessus, barking (), hungry (), sleeping () sont les méthodes.

Vous trouverez ci-dessous quelques-uns des sujets importants qui doivent être abordés lors de l'examen des cours de langage Java.

■ Constructeur Lors de la discussion sur les classes, l'un des sous-sujets les plus importants est le constructeur. Chaque classe a un constructeur. Si vous n'écrivez pas explicitement un constructeur de classe, le compilateur Java crée un constructeur par défaut pour cette classe.

Au moins un constructeur est appelé chaque fois qu'un nouvel objet est créé. La règle principale du constructeur est que le constructeur doit avoir le même nom que la classe. Une classe peut contenir plusieurs constructeurs.

Voici un exemple de constructeur

java

public class Dog {
   String breed;
   int age;
   String color;
   
   public Dog(){
   }
   public Dog(String breed){
     this.breed = breed;
   }
   void barking() {
   }

   void hungry() {

   }

   void sleeping() {
   }
}

■ Créer un objet La classe fournit un plan pour l'objet. Fondamentalement, les objets sont créés à partir de classes. Java utilise le nouveau mot-clé pour créer un nouvel objet. Il y a trois étapes lors de la création d'un objet à partir d'une classe

--Declaration --Une déclaration de variable avec un nom de variable de type objet. --Instantiate - Crée un objet en utilisant le mot-clé "new". --Initialisation --Le mot-clé "new" est suivi d'un appel au constructeur. Cet appel initialise un nouvel objet.

java

public class Dog {
   String breed;
   int age;
   String color;
   
   public Dog(){
   }
   public Dog(String breed){
     this.breed = breed;
   }
   void barking() {
   }

   void hungry() {

   }

   void sleeping() {
   }
   public static void main(String []args) {
      Dog dog1 = new Dog("afador");
   }
}

■ Accès aux variables et méthodes d'instance Les variables et méthodes d'instance sont accessibles via l'objet créé. Pour accéder aux variables d'instance, voici le chemin complet

java

public class Dog {
   private String breed;
   public static int age;
   private String color;
   
   public Dog(){
   }
   public Dog(String breed){
     this.breed = breed;
   }
   private void barking() {
     System.out.println("I am barking!");
   }

   protected void hungry() {
     System.out.println("I am hungry!");
   }

   public void sleeping() {
       System.out.println("I am sleeping!");
   }
   public static void main(String []args) {
      Dog dog1 = new Dog();
      
      String s1 = dog1.breed;//ok?
      int s2 = dog1.age;//ok?
      dog1.barking();//ok?
      dog1.hungry();//ok?
      dog1.sleeping();//ok?
   }
}

■ Règles de déclaration du fichier source Dans la dernière partie de cette section, examinons les règles de déclaration du fichier source. Ces règles sont essentielles lors de la déclaration de classes, d'instructions d'importation et d'instructions de package dans le fichier source.

• Il ne peut y avoir qu'une seule classe publique par fichier source.

• Le fichier source peut contenir plusieurs classes non publiques.

• Le nom de la classe publique doit être le nom du fichier source, avec .java ajouté à la fin. Par exemple, le nom de la classe doit être la classe publique Employee {} et le fichier source doit être Employee.java.

• Si la classe est définie dans un package, le package doit être sur la première ligne du fichier source.

--S'il existe une instruction d'importation, elle doit être écrite entre l'instruction package et la déclaration de classe. S'il n'y a pas de package, l'instruction d'importation doit figurer sur la première ligne du fichier source.

--Import et package signifie toutes les classes qui existent dans le fichier source. Vous ne pouvez pas déclarer différentes importations et / ou packages pour différentes classes dans le fichier source.

Les classes ont plusieurs niveaux d'accès et il existe différents types de classes. Classe abstraite, classe finale, etc. Ceux-ci sont traités dans le chapitre Qualificateurs d'accès.

Outre les types de classes ci-dessus, Java a également des classes spéciales appelées classes internes et classes anonymes. ■ Package Java En termes simples, c'est un moyen de classer les classes et les interfaces. Lors du développement d'une application en Java, des centaines de classes et d'interfaces sont créées. Par conséquent, il est impératif de classer ces classes et de rendre la vie beaucoup plus facile.

java

package jp.co.learning;

■ Instruction d'importation En Java, le compilateur peut facilement trouver le code source ou la classe si un nom complet est spécifié, y compris le nom du package et de la classe. L'instruction import est un moyen pour le compilateur de spécifier l'emplacement approprié pour trouver une classe particulière.

Par exemple, la ligne suivante demande au compilateur de charger toutes les classes disponibles dans le répertoire java_installation / java / io

java

import java.io.*;

■ Exemple d'échantillon 1 Dans l'exemple de l'exemple 1, deux classes sont créées. Ce sont Employee et EmployeeTest.

Ouvrez d'abord le Bloc-notes et ajoutez le code suivant. N'oubliez pas qu'il s'agit d'une classe Employee et que la classe est une classe publique. Enregistrez ensuite ce fichier source sous Employee.java.

La classe Employee a quatre variables d'instance: nom, âge, désignation et salaire. Cette classe a un constructeur explicitement défini qui accepte les paramètres.

java

package jp.co.learning;
import java.io.*;
public class Employee {

   String name;
   int age;
   String designation;
   double salary;

   // This is the constructor of the class Employee
   public Employee(String name) {
      this.name = name;
   }

   // Assign the age of the Employee  to the variable age.
   public void empAge(int empAge) {
      age = empAge;
   }

   /* Assign the designation to the variable designation.*/
   public void empDesignation(String empDesig) {
      designation = empDesig;
   }

   /* Assign the salary to the variable	salary.*/
   public void empSalary(double empSalary) {
      salary = empSalary;
   }

   /* Print the Employee details */
   public void printEmployee() {
      System.out.println("Name:"+ name );
      System.out.println("Age:" + age );
      System.out.println("Designation:" + designation );
      System.out.println("Salary:" + salary);
   }
}

Comme mentionné précédemment dans ce didacticiel, le processus commence par la méthode principale. Par conséquent, pour exécuter cette classe Employee, vous devez créer une méthode principale et un objet. Créez des classes séparées pour ces tâches.

Voici la classe EmployeeTest: Cette classe crée deux instances de la classe Employee et appelle des méthodes sur chaque objet pour affecter des valeurs à chaque variable.

Enregistrez le code suivant dans le fichier EmployeeTest.java.

java

package jp.co.learning;
import java.io.*;
public class EmployeeTest {

   public static void main(String args[]) {
      /* Create two objects using constructor */
      Employee empOne = new Employee("James Smith");
      Employee empTwo = new Employee("Mary Anne");

      // Invoking methods for each object created
      empOne.empAge(26);
      empOne.empDesignation("Senior Software Engineer");
      empOne.empSalary(1000);
      empOne.printEmployee();

      empTwo.empAge(21);
      empTwo.empDesignation("Software Engineer");
      empTwo.empSalary(500);
      empTwo.printEmployee();
   }
}

0203. Java-Constructor

Il existe deux types de constructeurs disponibles en Java.

• Constructeur sans paramètre
• Constructeur paramétré

■ Constructeur sans paramètre

java

Public class MyClass {
   Int num;
   MyClass() {
      num = 100;
   }
}

tester

java

public class ConsDemo {
   public static void main(String args[]) {
      MyClass t1 = new MyClass();
      MyClass t2 = new MyClass();
      System.out.println(t1.num + " " + t2.num);
   }
}

■ Constructeur paramétré

java

public class MyClass {
   int x;
   
   // Following is the constructor
   MyClass(int i ) {
      x = i;
   }
}

tester

java

public class ConsDemo {
   public static void main(String args[]) {
      MyClass t1 = new MyClass( 10 );
      MyClass t2 = new MyClass( 20 );
      System.out.println(t1.x + " " + t2.x);
   }
}

0204. Type de données Java-Basic

Il existe deux types de données en Java.

--Type de données primitif --Type de données de référence / objet

■ Type de données de base byte

• Le type de données octet est un entier à 2 compléments signé de 8 bits
• La valeur minimale est -128 (-2 ^ 7)
• La valeur maximale est de 127 (y compris) (2 ^ 7 -1)
• La valeur par défaut est 0 --Parce que les octets sont quatre fois plus petits que les entiers, vous utilisez principalement des tableaux d'octets au lieu d'entiers pour économiser de l'espace dans les grands tableaux.
• Exemple: octet a = 100, octet b = -50

short

• Les types de données courts sont des entiers à complément 2 signés 16 bits --La valeur minimale est -32768 (-2 ^ 15)
• La valeur maximale est 32767 (y compris les deux extrémités) (2 ^ 15 -1)
• Les types de données courts peuvent également être utilisés pour stocker la mémoire sous forme de types de données octets. short est deux fois plus petit qu'un entier
• La valeur par défaut est 0.
• Exemple: court s = 10000, court r = -20000

int

--Le type de données Int est un entier à complément 2 signé de 32 bits.

• La valeur minimale est -2.147.483.648 (-2 ^ 31)
• La valeur maximale est 2.147.483.647 (y compris les deux extrémités) (2 ^ 31 -1) --En général, les entiers sont utilisés comme type de données par défaut pour les valeurs entières, sauf en cas de problèmes de mémoire.
• La valeur par défaut est 0
• Exemple: int a = 100000, int b = -200000

long

--long type de données est un entier à 2 compléments signé 64 bits

• La valeur minimale est -9,223,372,036,854,775,808 (-2 ^ 63)
• La valeur maximale est 9,223,372,036,854,775,807 (y compris) (2 ^ 63-1)
• Ce type est utilisé lorsque vous avez besoin d'une plage plus large que int

float

--Exemple: long a = 100000L, long b = -200000L- Le type de données à virgule flottante est une simple précision 32 bits IEEE 754 à virgule flottante-Float est principalement utilisé pour économiser de la mémoire sur de grands tableaux de nombres à virgule flottante. -La valeur par défaut est 0.0f- Les types de données à virgule flottante ne sont pas utilisés pour les valeurs exactes telles que la devise-Exemple: float f1 = 234.5f

double

--Le type de données double est une virgule flottante IEEE 754 64 bits à double précision

• Habituellement, ce type de données est utilisé comme type de données par défaut pour les valeurs décimales et est généralement le choix par défaut
• N'utilisez pas de type de données double pour des valeurs exactes telles que la devise
• La valeur par défaut est 0.0d
• Exemple: double d1 = 123,4

boolean

--Boolean Le type de données représente 1 bit d'information

• Seulement deux valeurs possibles: true et false
• Ce type de données est utilisé pour les indicateurs simples qui suivent les conditions vrai / faux
• La valeur par défaut est false
• Exemple: booléen un = vrai

char

Le type de données --char est un seul caractère Unicode 16 bits

• La valeur minimale est '\ u0000' (ou 0) --Le maximum est '\ uffff' (ou contient 65 535) --Le type de données de caractère est utilisé pour stocker des caractères arbitraires
• Exemple: char letterA = 'A'

■ Type de données référence / objet

0205. Type de variable Java

Toutes les variables doivent être déclarées avant de pouvoir être utilisées. Format de base: data type variable [ = value][, variable [ = value] ...] ; Exemple:

java

int a, b, c;         // Declares three ints, a, b, and c.
int a = 10, b = 10;  // Example of initialization
byte B = 22;         // initializes a byte type variable B.
double pi = 3.14159; // declares and assigns a value of PI.
char a = 'a';        // the char variable a iis initialized with value 'a'

Il existe trois types de variables.

• Variables locales --Variables d'instance
• Variables de classe / statiques

■ Variables locales

• Les variables locales sont déclarées dans des méthodes, des constructeurs ou des blocs.

• Les variables locales sont créées lorsque vous entrez une méthode, un constructeur ou un bloc, et sont détruites lorsque vous quittez une méthode, un constructeur ou un bloc.

• Les modificateurs d'accès ne peuvent pas être utilisés pour les variables locales.

• Les variables locales ne sont visibles que dans la méthode, le constructeur ou le bloc déclaré.

• Les variables locales sont implémentées en interne au niveau de la pile.

• Les variables locales n'ont pas de valeurs par défaut, vous devez donc les déclarer et leur attribuer des valeurs initiales avant de les utiliser pour la première fois.

java

public Class Test{
  //Constructeur
  public Test(){
    String str = "test1";
    System.out.println(str);
  }
  //Méthode
  private void test1(){
    String str = "test";
    System.out.println(str);
    
    int test;
    if(test==0){
       int t1 = 1;
       test = t1;
    }
    System.out.println(test);
    System.out.println(t1);
  }

  public static void main(String[] args){
    Test test = new Test();
    test.test1();
  }
}

■ Variables d'instance Les variables d'instance sont déclarées dans la classe, mais en dehors des méthodes, des constructeurs ou de tout bloc.

Lorsque de l'espace est alloué pour les objets du tas, des emplacements sont créés pour chaque valeur de variable d'instance.

Les variables d'instance sont créées lorsqu'un objet est créé à l'aide du mot-clé "nouveau" et sont détruites lorsque l'objet est détruit.

Les variables d'instance contiennent des valeurs qui doivent être référencées par des parties importantes de l'état d'un objet qui doivent exister dans plusieurs méthodes, constructeurs, blocs ou dans toute la classe.

Les variables d'instance peuvent être déclarées au niveau de la classe avant ou après utilisation.

Vous pouvez spécifier des modificateurs d'accès pour les variables d'instance.

Les variables d'instance sont visibles pour toutes les méthodes, tous les constructeurs et tous les blocs de la classe. En général, il est recommandé de garder ces variables privées (niveau d'accès). Cependant, vous pouvez utiliser des modificateurs d'accès pour donner à ces variables une visibilité sous-classe.

Les variables d'instance ont des valeurs par défaut. Pour les nombres, la valeur par défaut est 0, pour les valeurs booléennes, elle est fausse et pour les références d'objet, elle est nulle. Les valeurs peuvent être affectées dans la déclaration ou dans le constructeur.

Les variables d'instance sont accessibles directement en appelant le nom de la variable dans la classe. Cependant, dans une méthode statique (si la variable d'instance est accessible), elle doit être appelée avec un nom complet. ObjectReference.VariableName.

Exemple:

java

import java.io.*;
public class Employee {

   //Cette variable d'instance est visible par toutes les classes enfants.
   public String name;

   //La variable de salaire n'est visible que dans la classe Employee.
   private double salary;

   //La variable de nom est affectée dans le constructeur.
   public Employee (String empName) {
      name = empName;
   }

   //Une valeur est affectée à la variable de salaire.
   public void setSalary(double empSal) {
      salary = empSal;
   }

   //Cette méthode imprime les détails des employés.
   public void printEmp() {
      System.out.println("name  : " + name );
      System.out.println("salary :" + salary);
   }

   public static void main(String args[]) {
      Employee empOne = new Employee("Ransika");
      empOne.setSalary(1000);
      empOne.printEmp();
   }
}

■ Variables de classe / statiques

• Les variables de classe, également appelées variables statiques, sont déclarées dans la classe à l'aide du mot clé static, mais en dehors de la méthode, du constructeur ou du bloc.

--Il n'y a qu'une seule copie de chaque variable de classe par classe, quel que soit le nombre d'objets créés à partir de celle-ci.

• Les variables statiques sont rarement utilisées sauf lorsqu'elles sont déclarées en tant que constantes. Les constantes sont des variables déclarées comme publiques / privées, finales et statiques. Les variables constantes ne changent jamais par rapport à leurs valeurs initiales.

• Les variables statiques sont stockées dans la mémoire statique. Il est rare d'utiliser autre chose que des variables statiques qui sont déclarées finales et utilisées comme constantes publiques ou privées.

• Les variables statiques sont créées lorsque le programme démarre et sont détruites lorsque le programme est arrêté.

• La visibilité est similaire aux variables d'instance. Cependant, la plupart des variables statiques sont déclarées publiques car elles doivent être disponibles pour les utilisateurs de la classe.

• La valeur par défaut est la même que la variable d'instance. Pour les nombres, la valeur par défaut est 0. False pour les valeurs booléennes. Null pour les références d'objet. Les valeurs peuvent être affectées dans la déclaration ou dans le constructeur. De plus, vous pouvez affecter des valeurs dans des blocs d'initialisation statiques spéciaux.

• Vous pouvez accéder aux variables statiques en appelant le nom de classe ClassName.VariableName.

--Lors de la déclaration d'une variable de classe comme finale statique publique, le nom de la variable (constante) est entièrement en majuscules. Si les variables statiques ne sont pas publiques et définitives, la syntaxe de dénomination est la même que pour les variables d'instance et locales.

java

import java.io.*;
public class Employee {

   //les variables de salaire sont des variables statiques privées
   private static double salary;

   //DEPARTMENT est une constante
   public static final String DEPARTMENT = "Development ";

   public static void main(String args[]) {
      salary = 1000;
      System.out.println(DEPARTMENT + "average salary:" + salary);
   }
}

0206.Type de modificateur Java

Les modificateurs sont des mots-clés que vous ajoutez à ces définitions pour changer leur signification.

• Modificateur de contrôle d'accès
• Modificateur de non-accès

■ Modificateur de contrôle d'accès

Java fournit un certain nombre de modificateurs d'accès pour définir les niveaux d'accès pour les classes, les variables, les méthodes et les constructeurs. Les quatre niveaux d'accès sont:

• Affiché sur l'emballage. C'est la valeur par défaut. Aucun modificateur requis. --Affiche uniquement dans les classes (privées). --Public au monde.
• Apparaît dans les packages et toutes les sous-classes (protégées).

■ Modificateur de non-accès Java fournit de nombreux modificateurs sans accès pour obtenir de nombreuses autres fonctionnalités.

• Modificateur statique pour créer des méthodes de classe et des variables.

• Modificateur final qui implémente la dernière classe, méthode et variable.

--Modificateur abstrait pour créer des classes et des méthodes abstraites.

• Modificateurs synchronisés et volatils utilisés pour les threads synchrones et volatils.

0207.Opérateur Java-Basic

Vous pouvez diviser tous les opérateurs Java dans les groupes suivants:

--Opérateur arithmétique

• Opérateur de relation
• Opérateur de bits --Opérateur logique --Opérateur d'assignation

--Autres opérateurs

■ Opérateur arithmétique Les opérateurs arithmétiques sont utilisés dans les formules de la même manière qu'ils sont utilisés en algèbre. Le tableau suivant présente les opérateurs arithmétiques.

Dans les 3 fichiers java suivants, "/%" est utilisé comme exemple pour lister les calculs de saut de page fréquemment utilisés dans les projets ordinaires.

ruby:Fichier: jp.co.learning.Config.java

package jp.co.learning;

/**
*Classe: Placement
*Auteur: AAAAAA
*Date de l'auteur: 2020/03/01
*/
public class Config{
    /*
     *Valeur par défaut pour afficher le nombre maximum d'enregistrements par page
     */
    public final static int DEFAULT_EACH_PAGE_CNT = 0;

}

ruby:Fichier: jp.co.learning.Page.java

package jp.co.learning;
/**
*Classe: saut de page
*Auteur: AAAAAA
*Date de l'auteur: 2020/03/01
**/
public class Page{

　　 /**
     *Nombre d'enregistrements à afficher
     **/
　　 private int records;
    /**
     *Nombre de pages d'enregistrements
     **/
    private int pageCnt;
    /**
     *Nombre d'enregistrements sur la dernière page
     **/
    private int endPageCnt;
　　 /**
     *Nombre d'enregistrements à afficher
     **/
　　 private int eachPageCnt = Config.DEFAULT_EACH_PAGE_CNT;

　　 /**
     *constructeur
     **/
     public Page(int records){

        this.records = records;

     }
　　 /**
     *Nouvelle page
     **/
     public void changePage(){

         //Lorsque le nombre d'enregistrements = 0, il renvoie directement 0.
         if(records == 0){
           return;
         }
         //Nombre d'enregistrements>S'il vaut 0, le traitement du calcul de saut de page est effectué.
         if(records % eachPageCnt == 0){
           endPageCnt = eachPageCnt;
           pageCnt = records / eachPageCnt;
         }else{
           endPageCnt = records % eachPageCnt;
           pageCnt = records / eachPageCnt + 1;
         }
     }
     /**
     *Obtenez le nombre total de pages
     * @return:Nombre total de pages
     **/
     public int getPageCnt(){
         return this.pageCnt;
     }
     /**
     *Obtenez le nombre d'enregistrements sur la dernière page
     * @return:Nombre d'enregistrements sur la dernière page
     **/
     public int getEndPageCnt(){
         return this.endPageCnt;
     }
}

ruby:Fichier: jp.co.learning.Test.java

package jp.co.learning;
/**
*Classe: Classe de test de saut de page
*Auteur: AAAAAA
*Date de l'auteur: 2020/03/01
**/
public class Test{
  /**
   *Test d'entrée
   **/
   public static void main(String[] args){
       //Définir temporairement le nombre d'enregistrements extraits de la base de données
       int records = 100;

       //Créer une instance de page avec la classe Page et effectuer un calcul de saut de page
       Page page = new Page(records);
       page.changePage();

       //Sortie du nombre de pages calculé et du nombre d'enregistrements sur la dernière page
       System.out.println("Nombre total de pages:"+page.getPageCnt());
       System.out.println("Nombre d'enregistrements sur la dernière page:"+page.getEndPageCnt());
   }
}

■ Opérateurs de relations

■ Opérateur de bits Java définit plusieurs opérateurs de bits qui peuvent être appliqués aux types entiers, long, int, short, char et byte.

Les opérateurs de bits travaillent sur des bits et effectuent des opérations bit par bit. Supposons a = 60 et b = 13. Maintenant au format binaire, cela ressemble à ceci-

a = 0011 1100

b = 0000 1101

a＆b = 0000 1100

a | b = 0011 1101

a ^ b = 0011 0001

〜a = 1100 0011

Le tableau suivant montre les opérateurs au niveau du bit

Supposons que la variable entière A contienne 60 et la variable B 13.

■ Opérateur logique Le tableau suivant montre les opérateurs logiques

Supposons que la variable booléenne A soit vraie et que la variable B soit fausse.

■ Opérateur d'affectation Voici les opérateurs d'affectation pris en charge par le langage Java.

■ Autres opérateurs

--Opérateur conditionnel (? :) Les opérateurs conditionnels sont également appelés opérateurs ternaires. L'opérateur s'écrit comme suit:

variable x = (expression) ? value if true : value if false

Exemple:

java

public class Test {

   public static void main(String args[]) {
      int a, b;
      a = 10;
      b = (a == 1) ? 20: 30;
      System.out.println( "Value of b is : " +  b );

      b = (a == 10) ? 20: 30;
      System.out.println( "Value of b is : " + b );
   }
}

--instanceof opérateur Cet opérateur est utilisé uniquement pour les variables de référence d'objet. L'opérateur vérifie si l'objet est d'un type particulier (type de classe ou type d'interface). L'opérateur instanceof s'écrit comme suit:

( Object reference variable ) instanceof  (class/interface type)

Exemple:

java

public class Test {

   public static void main(String args[]) {

      String name = "James";

      // following will return true since name is type of String
      boolean result = name instanceof String;
      System.out.println( result );
   }
}

0208. Contrôle Java-Loop

En général, les instructions sont exécutées dans l'ordre. La première instruction de la fonction est exécutée en premier, puis la seconde instruction. Les langages de programmation offrent une variété de structures de contrôle qui permettent des chemins d'exécution plus complexes. Dans les ** instructions de boucle **, nous autorisons plusieurs fois à exécuter une instruction ou un groupe d'instructions, qui est une forme courante d'instructions de boucle dans la plupart des langages de programmation ci-dessous.

Le langage de programmation Java fournit les types de boucles suivants pour gérer les exigences de boucle: Cliquez sur le lien suivant pour en savoir plus.

0209.Branchement Java-conditionnel

Il existe une ou plusieurs conditions qui sont évaluées ou testées par le programme, une instruction qui est exécutée si la condition est jugée vraie et éventuellement une autre instruction qui est exécutée si la condition est déterminée. est. Voici une forme courante de structure de décision typique trouvée dans la plupart des langages de programmation.

Le langage de programmation Java fournit les types d'énoncés de décision suivants: Cliquez sur le lien suivant pour en savoir plus.

?? :opérateur

Exp1 ? Exp2 : Exp3;

0210.Classe Java-Numeric

0211.Classe Java-Character

0212.Classe Java-String

0213.Java-Array

0214.Java-Date et heure

0215. Expression régulière Java

0216. Méthode Java

0217. Fichiers Java et E / S

0218. Exception Java

0219.Java-Classe intérieure

03. Orienté objet Java

04. Java Luxury

05. Développement de projets