Utilisateur:Fasten/Java tutorial/Classes et objets

Une page de Wikiversité.
Sauter à la navigation Sauter à la recherche
Début de la boite de navigation du chapitre
Classes et objets
Icône de la faculté
Chapitre no 7
Leçon : Java tutorial
Chap. préc. :Tableaux
Chap. suiv. :Héritage et polymorphisme
fin de la boite de navigation du chapitre
Icon falscher Titel.svg
En raison de limitations techniques, la typographie souhaitable du titre, « Java tutorial : Classes et objets
Fasten/Java tutorial/Classes et objets
 », n'a pu être restituée correctement ci-dessus.

Introduction[modifier | modifier le wikicode]

Le terme orienté objet souvent lié au langage Java vient d’une part du fait que l’on peut :

  • Créer des objets
  • Libérer des objets non utilisés à l’aide d’un ramasse-miettes

Un objet est une instance d’une classe, qui est l’outil fondamental de programmation en Java. Une classe peut aussi être considérée comme une description de ce qu’il faut faire pour créer un objet. Les classes sont composées de méthodes et d’attributs qui peuvent être public, private ou protected.

Les différents mots clés concernant l'accessibilité sont les suivants :

  • Aucun mot clé: accessible par les classes du même paquetage ou package ;
  • Public: accessible par toutes les classes ;
  • Protected: accessibles par toutes les classes héritées et les classes du même paquetage, inaccessibles par les autres ;
  • Private: inaccessible par toute autre classes.

Ces termes sont utilisables aussi bien sur les méthodes que sur les variables.

Le terme static permet aussi de spécifier des variables de classe ou des méthodes de classe.

Créer une classe permettant de créer des objets[modifier | modifier le wikicode]

La première étape pour créer de nouveaux objets est de créer une nouvelle classe de façon particulière. C’est ce que l’on va voir avec l'exemple de la classe Point.

public class Point{

   public static double dimension = 2 ;
   //Variable de classe

   private double x ;
   private double y ;
   //Variables d'instance

   public Point(){
      this(0,0) ;
   }
   //Constructeur par défaut

   public Point(double x , double y){
      this.setX(x) ;
      this.setY(y) ;
   }
   //Constructeur avec argument

   public double getX(){
      return this.x ;
   }
   
   public void setX(double x){
      this.x = x ;
   }
   //Accesseurs correspondant à la variable x.
   
   public double getY(){
      return this.y ;
   }
   
   public void setY(double y){
      this.y = y ;
   }
   //Accesseurs correspondant à la variable y.

   public void symetrieSelonX(){
      this.y = -this.y;
   }

   public void symetrieSelonY(){
      this.x = -this.x;
   }

   public static double quelleDimension(){
      return dimension ;
   }
}

Cet exemple mérite des éclaircissements qui vont être donnés dans la suite.

Variables de classe/d'instance[modifier | modifier le wikicode]

Dans l'exemple de classe que nous avons ici, il apparaît une variable de classe et deux variables d'instance. Quelle est donc la différence entre ces deux types de variables lors de la création d’un objet ?

La variable de classe n'est en rapport avec aucun objet, elle ne dépend d'aucun objet, le plus souvent elle ne sera pas modifiée au cours de l'exécution du programme. Dans notre exemple, elle sera accessible dans la classe directement par son nom et dans d'autres classes par Point.dimension ou par la méthode statique appelée par Point.quelleDimension().

Les variables d'instance servent à représenter l’objet informatiquement. Ainsi, il est possible de représenter tous les objets réels par un ensemble de données de bases. Ceci s’appelle l'agrégation. C’est la méthode la plus utilisée pour créer des objets simples. Ici, notre point est représenté par deux double qui sont dans la réalité ses coordonnées. Ces deux variables sont déclarées private par convention, en effet, on ne souhaite pas que d'autres classes puissent accéder directement à ces données. Chaque instance de l’objet (ici chaque Point) aura des valeurs différentes pour ces variables, elles sont réellement sa représentation, et contrairement aux variables de classes, ce sont bien ces données-là qui seront manipulées lors de l'exécution du programme.

Constructeur[modifier | modifier le wikicode]

Le constructeur comme son nom l'indique est la méthode qui sert à créer une instance d’un objet. Sa déclaration est particulière puisqu’un constructeur ne retourne rien (on ne peut pas avoir return dans un constructeur). On peut remarquer ici qu’il y a deux constructeurs :

  • le constructeur par défaut, sans argument, il se contentera d'appeler le deuxième constructeur avec 0 et 0 en argument.
  • le constructeur avec argument qui permet de créer un point avec les coordonnées x et y.

Plusieurs choses nouvelles apparaissent dans ces constructeurs :

  • La première, qui n’est pas des plus simples à comprendre, est l'apparition de this. Ce terme est le plus important de la programmation par objet en Java. En effet, ce terme représente la future instance de l'objet. Ainsi this pointe déjà vers une instance de l'objet. La première utilisation que l’on peut remarquer, est celle qui en est faite dans le constructeur avec argument, où les arguments portent le même nom que les variables d'instance mais ces dernières sont différenciées par l'apparition de this devant.
  • La deuxième chose importante est le chaînage des constructeurs. Il peut paraître étrange d’avoir plusieurs constructeurs mais ils se différencient parfaitement par leurs arguments, il est donc possible d’avoir toute une panoplie de constructeurs. Le chaînage des constructeurs est donc le fait de faire appel à un constructeur dans un constructeur. On remarque alors que le constructeur par défaut fait appel au constructeur avec argument par this(0,0) avec les arguments 0 et 0.
  • La dernière chose est le fait de ne pas faire appel directement aux variables d'instances mais plutôt aux accesseurs. Même si ici ce n’est pas franchement utile, on retiendra quand même cela comme une convention car cela permet de changer de représentation (changer les variables d'instance) sans ne jamais changer les constructeurs. Un exemple sera donné dans la partie consacrée aux accesseurs.

Remarque : il n’est pas obligatoire d’avoir un constructeur pour créer des objets car Java en crée un par défaut. Cependant, ce constructeur par défaut initialisera toutes les variables d'instance à la valeur null quel que soit le type de donnée.

Il est maintenant intéressant de savoir comment utiliser ces constructeurs. Le meilleur moyen de le savoir est de créer quelques points.

Point monPoint = new Point() ;
//La création d'une instance se fait de cette manière, ici on remarque
//que Point est devenu un nouveau type de donnée, on a créé un objet.
//On a utilisé ici le constructeur par défaut, donc monPoint a pour
//coordonnées (0,0).

Point monPoint2 = new Point(2,1) ;
//On a créé ici un point de coordonnées (2,1).

Accesseurs[modifier | modifier le wikicode]

Les accesseurs sont les méthodes, et d'ailleurs les seules, qui accèdent directement aux variables d'instance. Ainsi, ces méthodes seront utilisées dans les constructeurs, dans les méthodes d'instances, mais aussi dans toute autre méthode qui nécessitera une donnée particulière de notre objet.

Par convention, les accesseurs permettant d'accéder aux valeurs des variables d'instance ont toujours pour nom get + le nom de la variable et les accesseurs permettant de modifier les valeurs des variables d'instance set + le nom de la variable. Ainsi, il est en général très simple d’utiliser un code, même un code qui n’est pas le sien, si ces conventions sont respectées.

Le grand intérêt des accesseurs est de rendre indépendant tout le reste du code de la représentation de l'objet. Pour s'en convaincre, l'exemple des nombres complexes en représentation cartésienne puis en polaire est très bon à faire.

Méthodes de classe/d'instance[modifier | modifier le wikicode]

Les méthodes de classe et d'instance se différencient exactement de la même manière que les variables de classe ou d'instance. Ainsi, on appelle une méthode de classe (prenons l'exemple de la classe Point) par Point.quelleDimension(). Les méthodes d'instance ne s'appliquent qu’à une instance de classe, il est donc nécessaire de créer au moins un objet pour pouvoir appeler ces méthodes.

Point monPoint = new Point(4,6) ;
//On crée un Point

monPoint.symetrieSelonX() ;
//On appelle la méthode symetrieSelonX() sur l'instance monPoint de Point.

System.out.println("L'abscisse de monPoint est : " + monPoint.getX()) ;
System.out.println("Oracle : L'abscisse de monPoint est : 4") ;
//On remarque que les accesseurs sont appelés comme des méthodes d'instance normales, et 
//en effet, c'en sont.

System.out.println("L'ordonnée de monPoint est : " + monPoint.getY()) ;
System.out.println("Oracle : L'ordonnée de monPoint est : -6) ;

On a donc créé une instance à laquelle on a appliqué des méthodes.


Introduction[modifier | modifier le wikicode]

The term often associated with object-oriented Java language has a hand that can:

  • Create objects
  • Free unused objects using a garbage collector

An object is an instance of a class, which is the fundamental tool for Java programming. A class can also be seen as a description of what it takes to create an object. The classes are composed of methods and attributes that can bepublic,privateorprotected.

The various keywords for accessibility are:

  • No keyword: accessible by classes of the same package orpackage;
  • Public: accessible to all classes;
  • Protected: accessible by all classes and inherited classes in the same package, inaccessible by others;
  • Private: inaccessible by any other classes.

These terms are used both methods on the variables.

The termstaticalso allows you to specify class variables or class methods.

Creating a class to create objects[modifier | modifier le wikicode]

The first step to create new objects is to create a new class in a special way. This is what we will do with the example of classPoint.

public class Point {

   public static double dimension = 2;
   // Variable Class

   private double x;
   private double y;
   // Instance variables

   public Point () {
      this (0.0);
   }
   // Default constructor

   public Point (double x, double y) {
      this.setX (x);
      this.setY (y);
   }
   // Constructor with argument

   public double getX () {
      return this.x;
   }
   
   public void setX (double x) {
      this.x = x;
   }
   // Accessors corresponding to the variable x.
   
   public double Gety () {
      this.y return;
   }
   
   public void setY (double y) {
      this.y = y;
   }
   // Accessors corresponding to the variable y.

   public void symetrieSelonX () {
      this.getY () =-this.getY ();
   }

   public void symetrieSelonY () {
      this.getX () =-this.getX ();
   }

   public static double quelleDimension () {
      return dimension;
   }
}

This example deserves clarification that will be given in the following.

Variables class / instance[modifier | modifier le wikicode]

In the example class we have here, it is a class variable and two instance variables. What is the difference between these two types of variables when creating an object?

Theclass variable is related to anything, it does not depend on any subject, in most cases it will not be changed during program execution. In our example, it will be accessible in the class directly by name and other classes by Point.dimension'or thestatic method called by Point.quelleDimension ().

Theinstance variables used to represent the data objects. Thus, it is possible to represent all real objects by a set of data bases. This is calledagrégation. This is the method most used to create simple objects. Here, our point is represented by twodoublethat are in the real coordinates. These two variables are declaredprivateby convention, in fact, you do not want that other classes can directly access the data. Each instance of the object (in this case each point) will have different values ​​for these variables, they are actually its representation, and unlike class variables, the data are then to be handled during the execution of the program.

Manufacturer[modifier | modifier le wikicode]

TheConstructor as the name suggests is the method used to create an instance of an object. His statement is special because a manufacturer does not return anything (we can not havereturnin a constructor). It may be noted here that there are two constructors:

  • The default constructor with no arguments, it will simply call the second constructor with an argument 0 and 0.
  • Argument to the constructor that creates a point with coordinates x and y.

Several new things appear in these manufacturers:

  • The first, which is not very simple to understand, is the appearance ofthis. This term is the most important object-oriented programming in Java. Indeed, this term represents the future instance of the object. Andthis already advanced to an instance of the object. The first use that can be observed, is that which is done in the constructor with argument, where arguments have the same name as instance variables, but they are differentiated by the appearance ofthis before.
  • The second important thing ischaining constructors. It may seem strange to have several manufacturers, but they differ completely in their arguments, it is possible to have a range of manufacturers. Chaining constructors is the fact of using a constructor in a constructor. We noticed that the default constructor calls the constructor with this argument by(0.0)with the arguments 0 and 0.
  • The last thing is the failure to appeal directly to the instance variables but rather to the accessors. While this is not really useful, we note nevertheless that as a convention because it allows you to change representation (change instance variables) without ever changing manufacturers. An example is given in the section on getters.

Note: It is not necessary to have a constructor to create objects because Java creates a default. However, the default constructor initializes all instance variables to the value ofnullregardless of the type of data.

It is now interesting to know how to use these constructors. The best way to find out is to create a few points.

Monpoint Point = new Point ();
// Creating an instance is done in this way, we note here
// Item that has become a new data type, we created an object.
// Was used by the default constructor, so has the Monpoint
// (0,0).

MonPoint2 Point = new Point (2.1);
// Was created by a point with coordinates (2.1).

Accessors[modifier | modifier le wikicode]

Theaccessors methods are, and indeed the only, that directly access instance variables. Thus, these methods will be used in constructors, in the instance methods, but also in any other method which will require a particular data of our object.

By convention, the accessors to access the values ​​of instance variables always have to get + the namevariable nameand accessors to modify the values ​​of instance variables+ set name Variable. Thus, it is usually very simple to use a code, even code that is not hers, if these agreements are met.

The great interest of accessors is to make independent the rest of the code representation of the object. To see this, the example of complex numbers in Cartesian and in polar representation is very good to do.

Class Methods / instance[modifier | modifier le wikicode]

Class methods and instance differ in exactly the same way as class variables or instance. Thus, we call a class method (take the example of the Point class) byPoint.quelleDimension (). Instance methods only apply to a class instance, it is necessary to create at least one object in order to call these methods.

Monpoint Point = new Point (4.6);
// Create a Point

monPoint.symetrieSelonX ();
// Call the method symetrieSelonX () on the instance Monpoint Point.

System.out.println ("The abscissa of Monpoint is:" + monPoint.getX ());
System.out.println ("Oracle: The abscissa of Monpoint is: 4");
// Note that the accessor is called as normal instance methods, and
// In fact, are c'en.

System.out.println ("The orderly Monpoint is:" + monPoint.getY ());
System.out.println ("Oracle: The orderly Monpoint is: -6);

So we created an instance in which we applied methods.

class AutreClass                               // la classe "AutreClass"
{                                              // parenthèse ouvrant pour la classe
}                                              // parenthèse fermante correspondante pour la classe

class Calcul                                   // la classe "Calcul"
{                                              // parenthèse ouvrant pour la classe
     int variableGlobale = 20;                 // Déclaration d'une variable globale

     public static void main (String [] args)  // la méthode "main"
     {                                         // parenthèse ouvrant pour la méthode
         autreMéthode (variableGlobale);       // instruction: la appel de méthode "autreMéthode"
     }                                         // parenthèse fermante correspondante pour la méthode

     public static int autreMéthode (int paramètre) // la méthode "autreMéthode"
     {                                         // parenthèse ouvrant pour la méthode
         ...                                   // instruction de travail
     }                                         // parenthèse fermante correspondante pour la méthode
}                                              // parenthèse fermante correspondante pour la classe

Exercices:

  • Déplacez la méthode "autreMéthode" dans une autre classe et appelez la méthode dans la classe.
  • Qu'est-ce que c’est une instance?
  • Éliminez le mot-clé "static" dans la méthode "autreMéthode". Qu'est-ce que vous avez à faire?