Pause café #107. Méthode constructeur en Java I Surcharge de constructeur. Classes et interfaces Java abstraites

Méthode constructeur en Java I Surcharge du constructeur

Source : Programmation orientée objet77 Qu'est-ce qu'un constructeur ? Il s'agit d'un type spécial de méthode dont le nom est le même que le nom de la classe, qui détermine la manière dont l'objet est initialisé lors de sa création. Comme d'autres méthodes, nous pouvons également définir une méthode Constructeur dans notre programme Java, mais contrairement à d'autres méthodes, nous ne pouvons pas appeler directement le Constructeur ; Java appelle automatiquement le constructeur lorsqu'un objet est créé. Lorsque nous utilisons le mot-clé new pour créer un objet d'une classe, Java fait trois choses :

• Alloue de la mémoire pour un objet.
• Initialisez cette variable d'instance d'objet avec sa valeur initiale ou par défaut.
• Appelle le constructeur de méthode de la classe.

Si une classe ne définit aucune méthode Constructor , nous créerons quand même un objet de cette classe, mais nous devons définir une variable d'instance ou appeler d'autres méthodes, qui doivent ensuite initialiser l'objet avec cet objet. En définissant une méthode Constructor dans nos propres classes, nous pouvons définir les valeurs initiales d'une variable d'instance, appeler une méthode basée sur cette variable, ou appeler des méthodes sur d'autres objets, ou calculer les propriétés initiales de notre objet. Nous pouvons également surcharger Constructor comme les méthodes normales pour créer un objet qui possède certaines propriétés basées sur l'argument que nous passons à new .

Constructeur de base

Par définition, Constructor ressemble à une méthode classique avec deux différences principales.

• Le constructeur et le nom de la classe sont toujours les mêmes.
• Il n'a pas de type de retour

Par exemple, le tableau ci-dessous montre une classe Person simple avec un constructeur qui initialise sa variable d'instance en fonction du nouvel argument . La classe comprend également une méthode par laquelle un objet peut se présenter, ainsi qu'une méthode main() pour tester chacune de ces classes.

class Person
{
    String name;
    int age;

    Person (String n, int a)
{
    name = n;
    age = a;
}

void printPerson ()
{
System.out.print("Hi, I am " +name);
System.out.println(" I am "+ age + " years old.");
}

public static void main(String args[])
{

    Person p;

    p = new Person ("Ajab", 20);
    p.printPerson();

    p = new Person ("Rizwan", 30);
    p.printPerson();

Nous obtenons le résultat :

Surcharge du constructeur

Comme d'autres méthodes, Constructor peut également accepter différents nombres et types de paramètres, permettant de créer des objets avec des propriétés spécifiées ou permettant à Constructor de calculer des propriétés en fonction de différents types d'entrée. Par exemple, la classe MyRectone dans une table donnée crée un constructeur MyRectone et transmet un paramètre différent au lieu de créer des méthodes différentes pour les arguments donnés.

class MyRectone
 {

    int x1 = 0;
    int y1 = 0;
    int x2 = 0;
    int y2 = 0;

MyRectone ( int x1, int x2, int x2, int y2)
 {

    this.x1 = x1;
    this.y1 = y1;
    this.x2 = x2;
    this.y2 = y2;

}

MyRectone (Point topLeft, Point bottomRight)
 {

    x1 = topLeft.x;
    y1 = topLeft.y;
    x2 = bottomRight.x;
    y2 = bottomRight.y;

}

MyRectone ( Point topLeft, int w, int h)
{

    x1 = topLeft.x;
    y1 = top left.y;
    x2 = ( x1 + w);
    y2 = (y1 + h);

}

void printRect ()
{

    System.out.print ("MyRectone: <" + x1 + ", " + y1);
    system.out.println (", " + x2 + " ,"+ y2 + ">");

}

public static void main (String args [] )
{

    MyRectone rect;
    System.out.println ("Calling MyRectone with coordinates 35,35 70,70");

    rect = new MyRectone (35,35,70,70);
    rect.printRect();

    System.out.println ("Calling MyRectone with coordinates (15,15) (30,30)");
    rect = new MyRectone (15,15,30,30);
    rect.printRect();

    System.out.print (" Calling buildRect w/1 point (10,10),");
    System.out.println ("width (50) and height (50)");
    rect = new MyRectone ( new Point (10,10), 50, 50);
    rect.printRect();

Conclusion:

Appeler un autre constructeur

Un constructeur peut être un sur-ensemble d'un autre constructeur défini dans votre classe ; c'est-à-dire qu'ils peuvent se comporter de la même manière et un peu plus. Plutôt que de dupliquer un comportement identique sur plusieurs méthodes de constructeur de notre classe, il est logique de pouvoir simplement appeler ce premier constructeur à partir du corps du deuxième constructeur. Java fournit une syntaxe spéciale pour cela. Pour appeler un constructeur défini dans la classe actuelle, utilisez ce formulaire :

this (arg1, arg2, arg3… ..);

Les arguments pour cela sont, bien entendu, les arguments du constructeur.

Classes et interfaces Java abstraites

Source : Dev.to Une classe abstraite est une classe qui possède certaines méthodes sans définition complète et qui possède le modificateur abstract .

• Vous ne pouvez pas créer un objet à l'aide du constructeur d'une classe abstraite.
• Vous pouvez utiliser une classe abstraite comme classe de base pour définir une classe dérivée.
• Une classe abstraite possède au moins une méthode abstraite.
• Méthode abstraite : a un en-tête comme une méthode régulière, mais sans corps, et nécessite le modificateur abstrait et un point-virgule.
• Une méthode abstraite ne peut pas être privée.
• Une classe abstraite peut être un type.

Exemple:

public abstract class Example{
  private String data1;
  private double data2;

public abstract double getPay();
}

Interface : Définit un ensemble de méthodes que toute classe qui implémente cette interface doit avoir.

• Une interface est un type.
• Il contient des en-têtes de méthode sans définition ni variable d'instance :

public interface Interface1{
public void method1();
public int method2();
}

Pour implémenter une interface, une classe doit faire deux choses :

• Inclure les implémentations InterfaceName .
• La classe doit implémenter tous les en-têtes de méthode répertoriés dans l'interface.

public class Implementer implements Interface1 {

    @Override
    public void method1() {
    //definition   
    }

    @Override
    public int method2() {
    //definition   
    }

}

• Les en-têtes de méthode sont déclarés publics .
• Une classe abstraite peut également implémenter une interface, cette classe fournit des définitions pour certains en-têtes de méthode dans l'interface.
• Les interfaces Java peuvent également contenir des constantes , par exemple :

public interface Constant {

    public static final int JANUARY = 1, FEBRUARY = 2, MARCH = 3;
}

• Toute classe qui implémente l' interface Constant aura automatiquement ces constantes, par exemple :

public class Constants implements Constant {

    public static void main(String[] args) {
        System.out.println(JANUARY);
    }

}

• Vous pouvez mélanger l'utilisation des interfaces en incluant des constantes et des en-têtes de méthode dans une seule interface.
• Java ne prend pas en charge l'héritage multiple, une classe ne peut donc étendre qu'une seule classe de base. Cependant, en utilisant des interfaces, une classe peut implémenter plusieurs interfaces :

public class Implementer implements Interface1, Interface2, .. InterfaceN{

}

• La raison pour laquelle une classe Java ne peut étendre qu'une seule classe de base est que si Java autorise deux classes de base, les deux classes peuvent avoir le même en-tête de méthode avec une définition différente, ce qui entraîne une incohérence.
• Deux interfaces peuvent être incompatibles si vous définissez deux constantes avec le même nom et des valeurs différentes :

public interface Interface1{
public static final int ANSWEAR = 0;
}

 public interface Interface1{
public static final int ANSWEAR = 3;
}