[Java] Syntaxe orientée objet - Méthode / argument de classe

Méthode / champ de classe

• Champs / méthodes pouvant être appelés directement depuis la classe ** sans instanciation **
• ** Aussi appelée méthode statique / méthode statique **
• ** Membres de la classe **
• Méthode de classe
• Champ de classe
• Il n'y a qu'un seul membre de la classe dans la classe, partagé par toutes les instances
• cf: ** Membre d'instance **: Membre à appeler via objet
• Chacun a une valeur indépendante (condition réelle)

Méthode de classe

• ** Ajoutez simplement de la statique **
• Remarque
• ** Cela ne peut pas être utilisé dans les méthodes de classe **
• L'instance elle-même n'a pas été créée
• Les champs / méthodes d'instance ne peuvent pas être référencés à partir des méthodes de classe
• ** Les méthodes de classe ne sont pas appelées via des objets **

//Définissez la méthode de classe getTriangleArea pour la classe Figure
public class Figure {
  public static double getTriangleArea(double width, double height) {
    return width * height / 2;
  }
}

StaticBasic.java

public class StaticBasic {

  public static void main(String[] args) {
    System.out.println(Figure.getTriangleArea(10, 20));
//    var f = new Figure();
//    System.out.println(f.getTriangleArea(10, 20));
  }
}

Classe d'utilité

• Une classe qui n'a que des membres de classe (classe Math, etc.)
• Améliorez la lisibilité et facilitez la recherche de fonctions en regroupant les fonctions associées dans une méthode de classe.
• La classe de mathématiques regroupe le traitement numérique
• ** L'instanciation de classe peut être interdite en rendant le constructeur privé (ne peut pas être appelé de l'extérieur) **
• var m = new Math (); // erreur
• Il est courant d'utiliser le ** modificateur final ** pour interdire explicitement l'héritage de classe

public final class Math{
  private Math() {}
}

Champ de classe

• Champs pouvant être appelés directement sans passer par une instance
• ** Ajoutez simplement de la statique **
• Les champs de classe sont accessibles à partir des méthodes de classe
• Parce que le champ de classe appartient à la classe
• Accessible de l'extérieur si les droits d'accès sont satisfaits
• Remarque: les champs de classe ** affectent toutes les instances pertinentes si vous modifiez leur contenu **
• Dans d'autres langues ** Variables globales **: Variables valides tout au long du programme
• ** Puisque la dépendance entre les classes devient plus forte **, utilisez-la en principe dans les conditions suivantes
• Lecture seulement
• Suivi de l'état de la classe elle-même
• ** ex: motif Singleton ** (voir ci-dessous)

Figure.java

//Champ Pi, définition de la méthode getCircleArea dans le membre de classe de la classe Figure

public class Figure {
  public static double pi = 3.14;

  //Accéder aux champs de classe à partir des méthodes de classe
  public static void getCircleArea(double r) {
    System.out.println("L'aire du cercle est" +  r * r * pi);
  }
}

StaticBasic.java

public class StaticBasic {
  public static void main(String[] args) {
    //La figure est accessible de l'extérieur
    System.out.println(Figure.pi); //3.14
    Figure.getCircleArea(5); //L'aire du cercle est de 78.5
  }
}

Modèle d'une tonne

• Un type de modèle de conception
• Utilisé lorsque ** vous ne voulez / ne voulez pas créer une seule instance d'une classe **
• ** Déclarez le constructeur privé **
• Doit être conservé dans l'application ** Enregistrer uniquement l'instance dans le champ de classe **
• ** Instance une seule fois pour le premier chargement de classe **, ne peut pas être instanciée par la suite
• N'utilisez que la ** méthode de classe ** (= méthode d'usine pour l'acquisition d'instance) pour acquérir l'instance
• Défini comme membre de classe car il appartient à la classe de gestion / génération de l'instance elle-même

public class MySingleton {

  //Enregistrer uniquement l'instance dans le champ de classe
  private static MySingleton instance = new MySingleton();

  //Déclarer le constructeur privé
  private MySingleton() {}
  //Obtenez l'instance préparée par la méthode de classe
  public static MySingleton getInstance() {
    return instance;
  }
}

Constante de classe

• ** Constantes définies directement sous la classe {...}, champs en lecture seule **
• ** Ajoutez simplement le modificateur final **
• cf: classe constante
• Une classe qui résume les constantes utilisées dans l'ensemble de l'application en une seule classe pour faciliter l'accès (essentiellement définie par la classe associée en premier)

public class MyApp {
  public static final String BOOK_TITLE = "Maître Java!";
}

public class ConstantBasic {
  public static void main(String[] args) {
    System.out.println(MyApp.BOOK_TITLE); //Maître Java!
    //Ne peut pas être affecté au champ final
    //MyApp.BOOK_TITLE = "Je serai un maître Java!"; //Erreur
  }
}

bloc d'initialisation statique

• ** Exécuter lorsque la classe est initialisée **
• cf: Bloc d'initialisation exécuté à l'instanciation
• Static Initializer
• ** Modificateur statique au début du bloc **
• Utilisé pour initialiser les membres de la classe
• Les constantes sont copiées dans la classe de référence au moment de la compilation
• Si vous modifiez la valeur, la classe de référence constante doit également être recompilée
• La taille de la classe référente devient légèrement plus grande
• → En initialisant avec le bloc d'initialisation statique, seules les ** valeurs constantes peuvent être copiées, c'est donc une solution! ** **

public class Initializer {
  public static final String DOG;
  public static final String CAT;
  public static final String MOUSE;

  static {
    DOG = "inu";
    CAT = "neko";
    MOUSE  = "nezumi";
  }
}

Ordre d'exécution d'initialisation

** (1) Initialisation de classe une seule fois **

• Définir la valeur par défaut dans le champ de classe
• Initialisation du champ de classe
• Exécution du bloc d'initialisation statique

** (2) Exécuté à chaque fois qu'un objet est créé **

• Définir la valeur par défaut dans le champ d'instance
• Initialiser le champ d'instance
• Exécution du bloc d'initialisation
• Exécution du constructeur

//Mauvais exemple
//Le bloc d'initialisation a priorité sur l'initialiseur de champ
public class Order {
  //Initialiseur de champ
  String value = "First!";
  //constructeur
  public Order() {
    System.out.println(value); //Second!!
  }
  //Le bloc d'initialisation s'exécute avant la construction
  {
    value = "Second!!";
  }
}

public class OrderBasic {

  public static void main(String[] args) {
    var o = new Order();
  }
}

Méthode d'argument de longueur variable

• ** Ajoutez simplement ... à l'argument **
• La valeur reçue est considérée comme un tableau

public class ArgsParams {
  //Comme argument...Recevoir des arguments de longueur variable avec
  public int totalProducts(int... values) {
  // public int totalProducts(int[] values) {
    var result = 1;
    //Valeurs d'argument reçues par étendu pour et appliquées au résultat
    for (var value : values) {
      result *= value;
    }
    return result;
  }
}

public class ArgsParamsBasic {

  public static void main(String[] args) {
    var v = new ArgsParams();
    System.out.println(v.totalProducts(12, 15, -1));
    System.out.println(v.totalProducts(5, 7, 8, 2, 4, 3));

    // System.out.println(v.totalProducts(new int[] {12, 15, -1}));
  }
}

• Remarque
• ** Une méthode ne peut être spécifiée qu'à la fin de la liste d'arguments **
• Exemple NG * public void hoge(int... x, int y) * public void hoge(int... x, int... y)
• ** Ne combinez pas les arguments attendus en arguments de longueur variable **
• Arguments essentiellement normaux, la longueur variable ne recueille que les informations dont le nombre ne peut être spécifié au moment de la définition de la méthode
• ** Les arguments de longueur variable peuvent représenter un ou plusieurs arguments **
• L'argument de longueur variable est un argument qui nécessite 0 ou plusieurs valeurs
• L'argument de longueur variable peut être omis
• Dans le cas de v.totalProducts (), un tableau de taille 0 est passé en argument
• Lors de la demande d'au moins un argument Le code suivant

//Le premier argument est une initiale normale
//Déclarez le deuxième argument et les suivants avec une longueur variable
//Erreur de compilation sans arguments
public class ArgsParamsGood {
  public int totalProducts(int initial, int... values) {
    var result = initial;
    for (var value : values) {
      result *= value;
    }
    return result;
  }
}

public class ArgsParamsGoodClient {
  public static void main(String[] args) {
    var v = new ArgsParamsGood();
    System.out.println(v.totalProducts()); //no arguments
  }
}

Arguments et types de données

• La plage d'influence sur la valeur passée par le type de base et le type de référence est différente.

• Type de base

public class ParamPrimitive {
  public int update(int num) { //Argument formel num
    //Manipuler des arguments formels
    num *= 10;
    return num;
  }
}

public class ParamPrimitiveBasic {
  public static void main(String[] args) {
    //Nombre variable
    var num = 2;
    var p = new ParamPrimitive();
    System.out.println(p.update(num)); //20
    //N'affecte pas la variable d'origine num
    System.out.println(num); //2
  }
}

• Type de référence
• ** Stocker l'emplacement en mémoire au lieu de la valeur **

public class ParamRef {
  //Copiez l'adresse de référence des données variables dans les données d'argument formel
  public int[] update(int[] data) { //Données d'argument formel
    //Manipulation des données d'argument formel
    data[0] = 5;
    return data;
  }
}

public class ParamRefBasic {

  public static void main(String[] args) {
    //Données d'argument réelles
    var data = new int[] { 2, 4, 6 };
    var p = new ParamRef();
    //La même valeur que l'argument réel et l'argument formel sera référencée dans l'appel de méthode.
    System.out.println(p.update(data)[0]); //5
    //La manipulation des données d'argument formel affecte la variable d'origine
    System.out.println(data[0]); //5
  }
}

• Même avec le type de référence ** Le remplacement de la destination de référence elle-même n'affecte pas la variable d'origine **
• ex: lors du remplacement du tableau lui-même

public class ParamRefArray {
  //L'argument réel et l'argument formel pointent vers le même au moment de l'appel de méthode
  public int[] update(int[] data) {
    //Lorsqu'un nouveau tableau est attribué, l'adresse de référence elle-même change.
    data = new int[] { 10, 20, 30 };
    return data;
  }
}

public class ParamRefArrayBasic {
  public static void main(String[] args) {
    var data = new int[] { 2, 4, 6 };
    var p = new ParamRefArray();
    System.out.println(p.update(data)[0]); //10
    System.out.println(data[0]); //2
  }
}

mesures nulles

import java.util.Map;

public class BookMap {
  //Code ISBN: gérer les informations du livre par titre de livre
  private Map<String, String> data;
  //Initialiser les informations du livre avec la mappe d'arguments
  public BookMap(Map<String, String> map) {
    this.data = map;
  }
  //Obtenez le titre en utilisant le code ISBN (argument isbn) comme clé
  public String getTitleByIsbn(String isbn) {
    //Renvoie null si la clé spécifiée n'existe pas
    return this.data.get(isbn);
  }
}

Main.java

import java.util.Map;
public class Main {
  public static void main(String[] args) {
    var b = new BookMap(Map.of(
        "978-4-7981-5757-3", "Pierre philosophale",
        "978-4-7981-5202-8", "salle des Secrets",
        "978-4-7981-5382-7", "Prisonnier d'azkaban"
        ));

    var title = b.getTitleByIsbn("978-4-7981-5757-3");
    if (title == null) {
      System.out.println("Disapparition!(ne pas)");
    } else {
      System.out.println(title.trim()); //Pierre philosophale
    }
  }
}

Simplifiez le code ci-dessus avec la classe facultative!

• Emballage des valeurs nulles possibles avec Optinal
• ** Facultatif.ofNullable méthode **
• Génère ʻOptional `(une valeur de type String qui peut être nulle) basée sur la valeur donnée!
• Une valeur de type String qui peut être nulle
• ** méthode optTitle.orElse ** renvoie la valeur si l'objet facultatif a une valeur non nulle, sinon la valeur de l'argument
• → ** sécurité nulle ** (traitement nul forcé)

import java.util.HashMap;
import java.util.Map;
import java.util.Optional;


public class BookMap {
  private Map<String, String> data = new HashMap<>();

  public BookMap(Map<String, String> map) {
    this.data = map;
  }

  public Optional<String> getTitleByIsbn(String isbn) {
    return Optional.ofNullable(this.data.get(isbn));
  }
}

import java.util.HashMap;

public class OptionalNullCheck {

  public static void main(String[] args) {
    var b = new BookMap(
      new HashMap<String, String>() {
        {
          put("978-4-7981-5757-3", "Pierre philosophale");
          put("978-4-7981-5202-8", "salle des Secrets");
          put("978-4-7981-5382-7", "Prisonnier d'azkaban");
        }
      });

    var optTitle = b.getTitleByIsbn("978-4-7981-5382-7");
    var title = optTitle.orElse("×");
    System.out.println(title.trim()); //Prisonnier d'azkaban
  }
}

• Autres membres facultatifs de la classe
• ʻIsPresent / ʻifPresent: contrôle nul
• ** ʻorElse / ʻorElseGet: vérification Null pour obtenir la valeur **

import java.util.Optional;

public class OptionalExample {

  public static void main(String[] args) {
    //Création d'objets en option
    var opt1 = Optional.of("Échantillon 1");
    //Permettre null
    var opt2 = Optional.ofNullable(null);
    var opt3 = Optional.empty();

    //Confirmation de l'existence de la valeur
    System.out.println(opt1.isPresent()); //true
    //Exécution de l'expression Lambda si la valeur existe
    opt1.ifPresent(value -> {
      System.out.println(value); //Échantillon 1
    });

    //Si la valeur de opt2 existe, sa valeur est affichée, et si elle est nulle, l'argument est affiché.
    System.out.println(opt2.orElse("valeur nulle")); //valeur nulle

    //Exécution de l'expression Lambda lorsque opt3 est nul
    System.out.println(opt3.orElseGet(() -> {
      return "valeur nulle";
    })); //valeur nulle
  }
}