Menu

Types de classes en Java: abstrait, concret, final, statique

  • Principal
  • Autre
  • Types de classes en Java: abstrait, concret, final, statique

types classes java

Essayez Notre Instrument Pour Éliminer Les Problèmes

Ce didacticiel abordera divers types de classes en Java comme les classes abstraites, concrètes, finales, internes, POJO, statiques et autres avec des exemples:

Dans notre didacticiel précédent, nous avons discuté des classes et des objets en Java. Une classe en Java est un modèle ou un plan. Il peut également être défini comme une collection d'objets similaires. Nous définissons des objets de type classe puis communiquons via ces objets.

Chaque objet est une instance d'une classe qui a un état et un comportement.

=> Visitez ici pour la série exclusive de didacticiels de formation Java.

Types de classes en Java

Ce que vous apprendrez:

Types de classes en Java - Introduction

Nous savons tous que la classe comprend les éléments suivants:

  • Modificateurs: Spécifiez l'accès pour la classe.
  • Nom du cours: Nom de la classe.
  • Mots clés: Mots clés suggérant si une classe étend ou implémente une classe ou une interface.
  • La classe Body entre accolades {}

Selon les différents modificateurs utilisés, le corps de classe spécifié et les mots clés utilisés, nous avons différents types de classes en Java.

comment déposer un rapport de bogue
  • Classe de béton: Une classe normale qui a l'implémentation concrète des méthodes.
  • Classe POJO: Il s'agit de «Plain Old Java Object» contenant uniquement des variables membres privées et des méthodes de définition de lecture pour accéder à ces variables.
  • Classe abstraite: Cette classe a une ou plusieurs méthodes abstraites.
  • Classe finale: Une classe finale ne peut pas être héritée.
  • Classe statique: Une classe contenant uniquement des membres statiques.
  • Classe intérieure: Une classe interne est une classe membre d'une autre classe.

Dans ce didacticiel, nous aborderons chacun de ces types de classes avec des exemples.

Nous discuterons également d'autres types de classes considérées comme des classes spéciales en Java.

  • Classe anonyme: Une classe sans nom.
  • Classe immuable: Une classe dont l'objet ne peut pas être modifié.
  • Classe Singleton: Une classe dont une seule instance peut être créée.
  • Classe d'objet: La classe de base de toutes les fonctionnalités Java.
  • Classe d'emballage: Chaque type de données primitif en Java a une classe wrapper.

Mais d'abord, voyons brièvement comment importer une classe en Java avec la classe Main en Java qui contient la méthode principale ou le point de départ en Java.

Importer en Java

En Java, si nous voulons inclure une fonctionnalité ou une fonctionnalité dans notre programme, nous pouvons utiliser l'instruction «import». En utilisant l'instruction d'importation, nous pouvons importer un package entier et utiliser ses fonctionnalités dans notre programme ou nous pouvons également inclure une seule classe.

Vous trouverez ci-dessous la syntaxe de l'instruction d'importation.

import packageName/classname;

Si nous voulons importer le package java.lang et toutes ses classes, nous pouvons écrire l'instruction suivante:

import java.lang.*;

Supposons que nous voulions inclure la fonctionnalité de la classe Arrays dans notre programme, alors nous pouvons écrire l'instruction suivante:

import java.util.Arrays;

L'instruction d'importation est équivalente à l'instruction d'inclusion C / C ++. L'instruction d'importation est placée au début du programme Java en tant que première instruction. Nous pouvons avoir plus d'une instruction dans le programme Java.

Classe principale en Java

Nous savons déjà qu'en Java, la méthode main () est le point de départ de toute exécution de programme et peut être placée dans n'importe quelle classe de cette application particulière. Cependant, si nous avons une application complexe avec trop de fichiers et de classes, il est conseillé d'avoir une classe Main et de placer la méthode main () dans cette classe Main.

class Main{ public static void main(String() args){ System.out.println(“Hello, World!”); } }

Notez que la JVM ne crée pas d'objet de classe Main. La logique derrière ceci est que comme main () est une méthode statique, elle peut être appelée sans aucun objet de classe.

Types de classes en Java

Passons maintenant aux types de classes en Java. Nous expliquerons chacune de ces classes une par une suivie des exemples de programmation.

# 1) Classe de béton

Une classe concrète est une classe normale dans un programme Java. Cette classe n'aura aucune méthode abstraite. Toutes les méthodes de la classe concrète sont complètement implémentées.

Une classe concrète peut hériter d'une autre classe, voire d'une classe abstraite ou implémenter une interface. Nous pouvons instancier la classe concrète et créer ses objets.

Un exemple simple de classe concrète est présenté ci-dessous.

public class Main { // Concrete Class example static int total(int val1, int val2) { return val1 + val2; } public static void main(String args()) { int sum = total(100, 108); System.out.println('Total of two integers: ' + sum); } }

Production

sortie - Classe de béton

Le programme ci-dessus montre une classe concrète. On voit que cette classe a une implémentation complète. Il n'y a rien qui reste incomplet ou non mis en œuvre.

# 2) Classe POJO

Un POJO (Plain Old Java Object) est une classe contenant uniquement des variables membres privées. Hormis les variables membres privées, il ne contient que les méthodes getter et setter utilisées par ces variables membres.

Une classe POJO n'a pas son comportement. Cependant, il peut remplacer certaines méthodes comme égales ou interfaces.

Propriétés de la classe POJO:

  • La classe POJO doit avoir une méthode publique getter et setter.
  • Tous les membres ou variables d'instance doivent être privés.
  • La classe POJO n'étend ni n'implémente de classes ou d'interfaces pré-spécifiées.
  • Ils ne contiennent pas d'annotations pré-spécifiées.
  • N'a pas de constructeur sans argument (constructeur sans argument).

Vous trouverez ci-dessous un programme Java qui illustre la classe POJO.

//declare a POJO class class POJO_Class { private int daysOfWeek=7; //private variable public int getdaysOfWeek() { //getter return daysOfWeek; } public void setdaysOfWeek(int dow) { //setter this.daysOfWeek = dow; } } public class Main { public static void main(String args()){ POJO_Class pojoDemo = new POJO_Class(); //instance of POJO class System.out.println('Days of the week:' + pojoDemo.getdaysOfWeek()); } }

Production

sortie - classe POJO

La démonstration ci-dessus de la classe POJO montre qu'elle a une variable privée et les méthodes de définition getter pour cette variable. Pour accéder à cette variable membre, nous utilisons la méthode getter. La méthode setter est utilisée pour mettre à jour la valeur.

# 3) Classe abstraite

Une classe abstraite est une classe incomplète ou dont l'implémentation n'est pas terminée. Une classe abstraite ne peut pas être instanciée. Il doit être étendu par les autres classes et implémenter ses méthodes pour former une classe concrète.

Une classe abstraite est déclarée en utilisant le mot-clé «abstract». Une classe abstraite peut avoir des méthodes statiques et finales ainsi que des constructeurs.

Voyons une classe abstraite en Java.

interface multiply //interface multiply { int product(int num1, int num2); } // abstract class abstract class Product implements multiply { // this is an abstract method to calculate product of two numbers public abstract int product(int num1, int num2); } // Concrete class :this will implement the abstract method above class Main extends Product { public int product(int num1, int num2) { return num1*num2; } // main method public static void main(String args()) { Main obj = new Main(); int prod = obj.product(100, 20); // print product System.out.println('Product of two numbers: ' + prod); } }

Production

output - Classe abstraite

Dans le programme ci-dessus, nous avons une interface multiplier. Nous créons une classe abstraite Product qui implémente une interface de multiplication. À l'intérieur du produit, nous avons un produit de méthode qui n'est pas implémenté. Ensuite, nous avons une classe Main qui hérite de la classe Product et implémente la méthode product. Plus tard, nous appelons cette méthode sur l'objet de classe Main.

# 4) Classe statique

Un statique en Java en général signifie l'objet qui appartient à une classe et non aux instances individuelles. Ainsi, un membre ou une méthode statique en Java n'a pas besoin d'être accédé avec un objet mais directement en utilisant un nom de classe.

Une classe statique en Java ne peut contenir que des membres statiques. De plus, nous ne pouvons pas instancier une classe statique.

Le programme Java suivant illustre une classe statique.

class Static_Class { static int total; // static variable static void sum(int val1, int val2) { // static method System.out.print('Static method to calculate sum:' + ' '); total = val1 + val2; System.out.println(val1 + '+' + val2); // print the numbers } static class Nested_Class { // static class static { // static block System.out.println('static block inside a static nested class'); } public void displaySum() { sum(25, 75); // call static method // print the value in static variable total, it holds the sum of two numbers System.out.println('Sum of two numbers:' + total); } } } public class Main { public static void main(String args()) { // declare static class object Static_Class.Nested_Class object = new Static_Class.Nested_Class(); object.displaySum(); // call displaySum method inside a static class } }

Production

sortie - Classe statique

La classe ci-dessus illustre la classe statique. Ici, nous avons une classe statique qui est membre d'une autre classe concrète. À l'intérieur de la classe statique, nous calculons la somme de deux nombres et stockons le résultat dans une variable statique qui est membre de la classe externe.

# 5) Classe finale

Une classe finale est une classe qui ne peut pas être héritée ou sous-classée. Une fois qu'une classe est déclarée finale en Java, c'est une sorte de constante et elle devient immuable.

Par conséquent, pour rendre une classe immuable, nous devons la déclarer comme définitive.

//final class final class Base_Class { void Display() { System.out.println('Base_Class::Display()'); } } //class Derived_Class extends Base_Class { //Compile-time error - can't inherit final class class Derived_Class{ void Display() { System.out.println('Derived_Class::Display()'); } } public class Main { public static void main(String() arg) { Base_Class base_obj = new Base_Class(); //create a final class object base_obj.Display(); Derived_Class deri_obj = new Derived_Class(); deri_obj.Display(); } }

Production

sortie - Classe finale

Le programme ci-dessus déclare d'abord une Base_Class marquée «finale». Par conséquent, lorsque nous essayons de l'étendre dans Derived_Class, nous obtenons une erreur de compilation. (La ligne commentée). Mais nous pouvons créer son objet et appeler la méthode Display.

# 6) Classe imbriquée / Classe intérieure

La classe imbriquée, également appelée classe interne en Java, est utilisée pour améliorer l'encapsulation. Une classe imbriquée / classe interne est une classe incluse dans une autre classe.

Tout comme une classe a des variables et des méthodes comme membres, elle peut également avoir une classe interne comme membre.

Une classe imbriquée a la structure suivante:

class OuterClass{ class NestedClass{ //nested class code… } //outerclass code… }

Les classes internes ont les sous-types suivants:

  • Classe intérieure imbriquée
  • Méthode Classe interne locale
  • Classe intérieure anonyme
  • Classe imbriquée statique

# 1) Classe intérieure imbriquée

programme sûr pour télécharger des vidéos youtube

Une classe interne imbriquée a accès aux variables membres privées d'une classe externe. Nous pouvons également appliquer des modificateurs d'accès à la classe interne imbriquée.

# 2) Méthode Classe intérieure locale

Il s'agit de la classe interne qui est déclarée dans une méthode de classe externe.

# 3) Classe intérieure anonyme

La classe interne anonyme est une classe interne déclarée à l'intérieur d'une classe externe et est sans nom.

# 4) Classe imbriquée statique

La façon dont une classe a une variable membre statique, elle peut également avoir une classe statique comme membre.

Un exemple de classe Nested / Inner est donné ci-dessous:

public class Main { //nested/inner class enclosed inside Main class. class InnerClass { public void inner_print() { System.out.println('Inner class'); } } public static void main(String() args) { System.out.println('Main in Outer class'); } }

Production

sortie - Classe imbriquée / Classe interne

Autres classes spéciales en Java

Classe immuable en Java

Une classe immuable génère des objets immuables. Un objet immuable est un objet dont le contenu ne peut pas être modifié une fois l'objet créé. Ainsi, une classe immuable est celle dont l'objet ne peut pas être changé une fois créé.

Toutes les classes wrapper en Java pour les types primitifs (Integer, Boolean, Byte, etc.) sont immuables. La classe String est également immuable.

Nous pouvons également avoir des classes immuables définies par l'utilisateur en Java.

Pour qu'une classe soit immuable, elle doit être déclarée finale avec tous ses membres de données. En outre, la classe doit avoir un constructeur paramétré. Toutes les variables membres doivent avoir une méthode getter mais pas une méthode setter.

Toutes les conditions ci-dessus doivent être remplies pour qu'une classe soit immuable.

Implémentons un programme Java pour illustrer la classe immuable.

final class City { final String city_name; final int cityId; //parameterised constructor public City(String name, int id) { this.city_name = name; this.cityId = id; } //getters for member variables public String getcityName() { return city_name; } public int getcityId() { return cityId; } } // Driver class class Main { public static void main(String args()) { City city = new City('New York', 1001); System.out.print('City Id:' + city.getcityId() + ' '); System.out.println('City Name:' + city.getcityName()); //city.cityId = 1002; //cannot assign a value to final variable regNo } }

Production

sortie - Classe immuable

Dans le programme ci-dessus, nous avons déclaré une classe City. Ceci est une classe finale et dans cette classe, nous avons déclaré deux variables membres et un constructeur paramétré. Nous avons également déclaré des méthodes getter pour ces deux variables membres. Ainsi, la classe City répond à toutes les exigences d'une classe immuable.

Notez la ligne de code commentée dans la méthode principale. Si nous décommentons cette ligne, nous obtiendrons une erreur du compilateur (fournie dans le commentaire ici) car nous essayons de définir la valeur d'une variable membre.

Classe Singleton en Java

Une classe singleton autorise une seule instance à la fois. En Java, un singleton est un modèle de conception. Ce modèle de conception garantit qu'une seule instance d'une classe existe à tout moment. Ainsi, toute classe définie comme un singleton a un seul point d'accès et il est global.

Notez que la fin du cycle de vie de l'application ne détruit pas une classe singleton comme les classes normales. Lorsqu'une classe est déclarée singleton, nous ne créons pas de nouvelle instance à chaque fois qu'une nouvelle requête pour l'objet est effectuée.

La même instance est utilisée encore et encore. De cette façon, nous pouvons économiser de l'espace mémoire principalement dans le cas d'applications multi-thread et de base de données.

Nous pouvons utiliser une classe singleton pour des activités telles que la mise en cache, la journalisation, etc.

Le programme suivant illustre une classe Singleton.

class Singleton { // static variable of type Singleton private static Singleton single_instance = null; // String variable public String str; // private constructor : restricted to this class private Singleton() { str = 'Singleton class::private constructor'; } // create instance of Singleton class using getInstance static method public static Singleton getInstance() { if (single_instance == null) single_instance = new Singleton(); return single_instance; } } class Main { public static void main(String args()) { // instantiate Singleton class with obj1 Singleton obj1 = Singleton.getInstance(); // instantiate Singleton class with obj2 Singleton obj2 = Singleton.getInstance(); System.out.println('obj1(str):' + obj1.str); System.out.println('obj2(str):' + obj2.str); // change variable of instance obj1 obj1.str = (obj1.str).toUpperCase(); System.out.println(' After changing obj1(str):'); System.out.println('obj1(str):' + obj1.str); System.out.println('obj2(str):' + obj2.str); } }

Production

sortie - Classe Singleton en Java

Dans le programme ci-dessus, nous avons défini une classe singleton avec un constructeur privé. Nous avons défini une variable membre de type String. Dans la méthode main, nous déclarons deux instances de la classe singleton. Ensuite, nous modifions la variable String en utilisant l'une des instances.

Lorsque nous imprimons la valeur String pour les deux instances, nous remarquons que la valeur de la variable String a changé pour les deux instances. Par conséquent, même si nous avons changé la valeur d'une seule instance, en raison de la classe singleton, les modifications sont reflétées dans toutes les instances.

Nous renvoyons toujours la même instance même si nous semblons créer des instances différentes.

Classe d'objet en Java

La classe Object est la classe parente ou la première classe en Java. Il se situe au niveau le plus élevé de la hiérarchie Java.

Comme toutes les classes ont la classe Object comme superclasse, tous les objets Java, y compris les tableaux, implémentent les méthodes de la classe Object. La classe d'objet est présente dans le package «java.lang».

La déclaration pour java.lang.Object est:

objet de classe publique

Le tableau suivant décrit les constructeurs et les méthodes de la classe Object.

Constructeur / MéthodeLa description
Classe getClass ()Renvoie la classe d'exécution de l'objet.
Constructeur de classe d'objets
Objet()Constructeur de classe d'objets
Méthodes de classe d'objets
Clone d'objet protégé ()Renvoie un clone ou une copie de l'objet.
booléen égal (Object obj)Vérifie si un objet donné obj est égal à cet objet.
protected void finaliser ()Appelé par le garbage collector lorsque toutes les références à l'objet sont détruites.
int hashCode ()Renvoie le code de hachage pour l'objet.
annuler notifier ()Utilisez pour réveiller un seul thread en attente.
void notifyAll ()Réveille tous les threads en attente.
Chaîne toString ()Renvoie String équivalent de l'objet.
attente vide ()Fait attendre un thread jusqu'à ce qu'il soit réveillé par la méthode de notification par un autre thread.
attente vide (long timeout)Fait attendre le thread jusqu'à ce que le temps donné par 'timeout' s'écoule ou soit réveillé par les méthodes notify ou notifyAll.
attente vide (long timeout, int nanos)Fait attendre le thread jusqu'à ce que le temps spécifié se soit écoulé ou jusqu'à ce que notify () ou notifyAll () soit appelé par un autre thread.

Implémentons un exemple de programme Java qui illustrera certaines des méthodes de la classe Object.

public class Main { public static void main(String() args) { Main t = new Main(); System.out.println('Main class Object HashCode:' + t.hashCode()); t = null; // call garbage collector System.gc(); System.out.println('Main class:End'); } @Override protected void finalize() { System.out.println('Main Class::finalize method called.'); } }

Production

sortie - Classe d

Ici, nous avons une classe principale. Dans la méthode main (), nous créons un objet de la classe Main. Cet objet est un descendant de la classe Object et prend en charge toutes les méthodes de la classe Object. Ainsi, nous utilisons cet objet et appelons quelques méthodes de classe Object comme hashCode (), System.GC (), finalize () etc.

Classe Wrapper en Java

Java fournit une fonctionnalité appelée classe wrapper qui a un mécanisme qui convertit le type de données primitif en objet et vice versa. Les classes wrapper sont les classes qui représentent des types primitifs comme int, char, etc. en tant qu'objets.

Ainsi, chaque type de données primitif en Java a sa classe wrapper correspondante.

Le tableau suivant présente les types de données primitifs et leur classe wrapper équivalente.

Type primitifType d'emballage
flotterFlotter
booléenBooléen
carboniserPersonnage
octetOctet
courtCourt
intEntier
longueLongue
doubleDouble

Pour convertir les primitives en objets et les objets en primitives, nous avons des techniques appelées respectivement «autoboxing» et «boxing». Ase Java est un langage de programmation orienté objet, nous traitons toujours des objets, et nous avons également beaucoup de fonctionnalités comme les collections, Sérialisation , etc. qui ont également besoin d'objets et de types primitifs.

Il est donc impératif que nous ayons toujours besoin d’objets et de types primitifs en Java et que nous ayons donc besoin de ces techniques d’autoboxing et de déballage.

Autoboxing

Top 10 des téléchargeurs de musique pour Android

L'autoboxing est une technique de conversion automatique d'un type de données primitif en un objet de sa classe wrapper correspondante. Par exemple , la conversion de int en classe Integer, char en classe Character, etc. sont des instances d'auto-box.

Noter: Les classes wrapper utilisent la méthode valueOf () pour convertir la primitive en objets dépréciés depuis Java 5.

Déballage

La conversion inverse des objets de classe wrapper en leurs types de données primitifs correspondants est appelée «déballage».

Noter: Depuis Java 5, la méthode intValue () qui convertit l'objet wrapper en un type primitif est dépréciée.

Ci-dessous, un exemple de boxe / déballage.

public class Main { public static void main(String args()){ //Convert int to Integer : boxing int num=20; Integer int_class= Integer.valueOf(num);//explicit conversion from int to Integer Integer inum=num;//autoboxing System.out.println('int => Integer: ' + num+' => '+inum); //Convert Integer to int: unboxing Integer val=new Integer (3); int ival=val.intValue();//explicit conversion from Integer to int int jval=val;//unboxing System.out.println('Integer => int:' + val+' => '+jval); } }

Production

sortie - Classe Wrapper

Le programme ci-dessus montre l'autoboxing et unboxing sur la valeur int. Tout d'abord, nous convertissons int en objet Integer, puis un objet Integer est converti en type de données int.

Implémentons un programme illustrant les classes wrapper présentes en Java.

public class Main { public static void main(String args()) { byte bbyte=10; short sshort=20; int iint=300; long llong=400; float ffloat=3.14F; double ddouble=77.2D; char cchar='A'; boolean bboolean=true; //Convert primitives into objects => Autoboxing Byte byteobj=bbyte; Short shortobj=sshort; Integer intobj=iint; Long longobj=llong; Float floatobj=ffloat; Double doubleobj=ddouble; Character charobj=cchar; Boolean boolobj=bboolean; //Print converted objects System.out.println('Primitives converted to Objects:'); System.out.println('Byte object: '+byteobj); System.out.println('Short object: '+shortobj); System.out.println('Integer object: '+intobj); System.out.println('Long object: '+longobj); System.out.println('Float object: '+floatobj); System.out.println('Double object: '+doubleobj); System.out.println('Character object: '+charobj); System.out.println('Boolean object: '+boolobj); //Convert Objects to Primitives => Unboxing byte bytevalue=byteobj; short shortvalue=shortobj; int intvalue=intobj; long longvalue=longobj; float floatvalue=floatobj; double doublevalue=doubleobj; char charvalue=charobj; boolean boolvalue=boolobj; //Print primitives System.out.println('Converting Objects to Primitives'); System.out.println('byte value: '+bytevalue); System.out.println('short value: '+shortvalue); System.out.println('int value: '+intvalue); System.out.println('long value: '+longvalue); System.out.println('float value: '+floatvalue); System.out.println('double value: '+doublevalue); System.out.println('char value: '+charvalue); System.out.println('boolean value: '+boolvalue); } }

Production

sortie - Boxe et Unboxing

La sortie du programme ci-dessus montre la conversion des types primitifs en objets wrapper (Autoboxing) et inverse la conversion des objets wrapper en types primitifs (unboxing).

Questions fréquemment posées

Q # 1) Quel est le type de données de classe en Java?

Répondre: Java fournit une classe nommée «Classe» qui contient des informations sur toutes les classes, objets et interfaces de l'application en cours d'exécution. La classe Class représente également les types de données primitifs et le type void.

La classe Class fait partie du package java.lang.

Q # 2) Quelle est la classe normale en Java?

Répondre: Une classe normale en Java est une classe non statique. Nous pouvons créer des objets d'une classe normale en utilisant le nouveau mot-clé. En outre, toute classe normale peut avoir une autre classe comme membre. Dans ce cas, la classe membre est appelée classe imbriquée ou interne et la classe englobante est appelée classe externe.

Q # 3) La chaîne est-elle une classe wrapper en Java?

Répondre: Non, String n'est pas une classe wrapper en Java. Pour qu'une classe soit une classe wrapper, nous avons besoin de son type primitif correspondant. Par exemple, pour la classe wrapper Integer, nous avons le type primitif int. Pour la classe String, nous n'avons pas de type de données primitif correspondant.

Q # 4) Quel est l'avantage de la classe Wrapper?

Répondre: Les classes wrapper sont utilisées pour la conversion de types de données primitifs en objets. En d'autres termes, les classes wrapper enveloppent des types primitifs dans des objets. Les classes wrapper sont utilisées lorsque certaines fonctionnalités Java telles que les collections n'attendent que des objets et non des types de données primitifs.

Q # 5) Pourquoi la classe Singleton est-elle utilisée en Java?

Répondre: Chaque fois que nous voulons un point d'accès global pour un objet particulier, nous optons pour un modèle de singleton qui nous permet de concevoir une classe de singleton dans laquelle il n'y aura qu'une seule instance. Les classes Singleton sont utilisées dans les caches, le pool de threads, les applications de base de données, la journalisation, etc.

Conclusion

Dans ce tutoriel, nous avons couvert les différents types de classes utilisés en Java. Nous avons vu les types de classes concret, abstrait, final, statique, imbriqué, POJO, etc. En dehors de cela, nous avons également discuté des classes Singleton, des classes immuables et également de leurs exemples d'implémentation.

Nous avons également couvert les classes wrapper et les classes d'objets en Java. Les classes wrapper sont les classes qui enveloppent les types de données primitifs de Java dans des objets. La classe d'objets en Java est la superclasse de toutes les autres classes. C'est la classe la plus élevée de la hiérarchie Java.

Maintenant que nous avons discuté des classes et des objets en Java et des types de classes, dans le prochain tutoriel, nous allons procéder avec une discussion détaillée sur les constructeurs en Java.

=> Consultez le guide de formation Perfect Java ici.

lecture recommandée

^