Manipulation des classes et des objets en Java
Manipulation des classes et des objets en Java
-
Objectifs
- Découvrir les éléments d’une classe (attributs, constructeurs et méthodes)
- Ecrire des classes en java et les instancier en des objets/instances
-
Rappel du cours
- Une classe est une entité qui représente un ensemble d’objets ayant la même structure et le même comportement.
- La déclaration d’une classe est comme suit:
[Public/Private] class NomDeLaClasse{}
- Il existe d’autre éléments qui peuvent être utilisés pour la déclaration d’une classe et qui sont en relation avec le concept d’héritage.
- Une classe comporte 3 éléments principaux:Les attributs, les constructeurs et les méthodes.
-
Les attributs
- Les attributs permettent de caractériser l’état des objets. Ils sont déclarés comme suit:
[public/private/protected] (static] [final) typeAttribut nomAttribut [=valeur];
- Un attribut privé (private) est accessible par les méthodes de la même classe.
- Un attribut protégé (protected) est accessible par les méthodes de la même classe, des classes dérivées et des classes du même package.
- Un attribut public (public) est accessible par toutes les méthodes des autres classes.
- Un attribut défini ‘final’ est un attribut constant.
- Un attribut défini ‘static‘ est nommé un attribut de classe. Sa valeur est unique pour tous les objets. Il peut être appelé par la classe elle-même ou par les objets dérivé de la classe ou il est défini.
-
Les constructeurs
- Les constructeurs sont des méthodes d’initialisation des attributs de l’objet créé. Ils sont toujours publics et n’ont pas de type de retour.
- Cas1::
- Si le constructeur n’est pas défini, les attributs sont initialisés par des valeurs par défaut par un constructeur non paramétré offert par java. La classe est instanciée comme suit:
ClassName objectName = new ClassNameO;
- Exemple:
Personne pi= new Personnel()
; - Cas2::
- La classe contient un ou plusieurs constructeurs qui diffèrent au niveau de la signature.
-
Les méthodes
- Les méthodes permettent de définir le comportement des objets de la classe. Elles sont déclarées comme suit:
[private/public/protected] [static] typeDeRetour NomMethode (typeParaml nomParaml, typeParam2 nomParam2){}
- Il existe l’élément
[final/abstract]
qui peut être utilisé pour la déclaration de la méthode et qui est en relation avec le concept d’héritage. - Remarque: une méthode peut être surchargée: On peut avoir plusieurs méthodes mais qui sont différentes au niveau des paramètres (type, ordre, nombre d’arguments…).
-
Exercices
-
Exercice01:
- Créer une classe « Point » qui permet de représenter un point sur un axe. Chaque point sera caractérisé par un nom (de type char) et une abscisse (de type double).
- La classe « Point » comporte:
- Un constructeur qui prend en argument le nom et l’abscisse d’un point.
- Une méthode ‘affiche‘ qui permet d’afficher dans la fenêtre de console le nom et l’abscisse du point.
- Une méthode ‘translate‘ qui permet de translater un point d’une distance définie par la valeur de son argument.
- Écrire un programme qui permet de créer un robot, d’en afficher les caractéristiques, de modifier sa position et son orientation, puis d’en afficher à nouveau les caractéristiques.
- Classe Point
- Programme principal pour tester la classe Point
-
Exercice02:
- Ecrire un programme qui simule le mouvement d’un robot simple. Un tel robot occupe une certaine position (X,Y), il a une orientation parmi {Nord, Est, Sud, Ouest}, il est initialisé à une position et une orientation données, il peut tourner à droite et il peut avancer d’un pas.
- La classe Robot comporte:
- Les attributs ‘x’ et ‘y’ de type int,
- L’attribut ‘orientation’ qui peut prendre une valeur constante entre 1 et 4 ; 1 pour Nord, 2 pour Est, 3 pour Sud et 4 pour Ouest.
- La méthode ‘tourneraDroite’ qui modifie l’orientation du robot sans changer sa position,
- La méthode ‘avancer’ qui modifie la position du robot selon son orientation actuelle,
- La méthode ‘afficheRobot’ qui affiche la position et l’orientation du robot.
- Ecrire un programme qui permet de créer un robot, en afficher ses caractéristiques, modifier sa position et son orientation et en afficher à nouveau les caractéristiques
- Classe Robot
- Programme principal pour tester la classe Robot
-
Exercice 3:
- Un Employé est caractérisé par un nom (String), un grade (String), un salaire (float) et le service auquel il est affecté (Service).
- Les méthodes prévues pour un employé sont les suivantes : getNom(), setGrade(), getGrade(), setService(), getService(), setSalaire(), getSalaire() et toString() qui retourne une description sur l’employé (sans citer son service).
- Un service est caractérisé par un nom (String), un numéro de téléphone (int), le chef du service (Employe) et tous les employés qui travaillent dans ce service (Vector).
- Les méthodes prévues sont les suivantes : getNom(), getNombreEmploye(), setNumTel(), getNumTel(), getChef(), setChef(), affecterEmploye(), eliminerEmploye() et toString() qui retourne une description sur un objet service qui considère uniquement le nom pour le chef et les employés d’un service. Le nom du chef ne doit pas être cité plus d’une fois (en tant qu’employé et chef).
- 1) Définir les classes Employe et Service
- 2) Ecrire une classe Test qui permet de :
- Créer deux objets Service S1 et S2 et quatre objets Employe E1, E2, E3 et E4.
- Affecter les employés E1 et E2 dans le service S1 et les employés E3 et E4 dans le service S2. E1 et E3 sont les chefs de service.
- Echanger les employés E2 et E4 entre les deux services, augmenter le salaire de E2 et le rendre chef de son nouveau service.
- Afficher les informations des deux chefs de service puis les informations des deux services.
- Classe Employe
- Classe Employe : Définit un employé avec un nom, un grade, un salaire et le service auquel il est affecté. Les méthodes de la classe permettent de récupérer et de définir ces attributs.
- Classe Service
- Classe Service : Gère un service avec un nom, un numéro de téléphone, un chef, et une liste d’employés. La classe permet d’affecter et de retirer des employés, de définir le chef du service, et d’afficher les informations du service.
- Classe Test
- Classe Test : Teste les fonctionnalités des classes Employe et Service. Elle crée des objets de ces classes, affecte des employés à des services, échange des employés entre services, modifie les salaires, et affiche les informations sur les chefs et les services.
-
Exercice 4:
- Un livre est caractérisé par un titre (String), l’année d’édition (int), l’éditeur (Editeur) et ses auteurs (un tableau d’Auteur). Une fois édité, les données d’un livre ne peuvent pas être changées; une nouvelle édition d’un livre engendre donc la création d’un nouvel objet Livre. Les méthodes prévues pour chaque livre sont les suivantes : getTitre(), getAnneeEdition(), getEditeur(), getPremierAuteur() et toString() qui ne considère pas les informations des auteurs.
- Un éditeur est caractérisé par un nom (String), une adresse (String), tous les livres édités (un tableau de Livre) et le nombre de livres édités (int). Les méthodes prévues pour un tout Editeur sont : setAdresse(), getAdresse(), getNom(), getNombreLivre(), nouveauLivre(), toString() (sans considérer les livres édités) et finalement getlivres() qui retourne une description des livres édités.
- Un auteur est caractérisé par un nom (String), une adresse (String), les livres qu’il a écrits (un tableau de Livre) ainsi que par leur nombre (int). Les méthodes prévues pour tout objet Auteur sont : getNom(), setAdresse(), getAdresse(), nouveaulivre(), getNombreLivre(), getLivre() qui retourne une description sur les livres écrits et finalement toString() qui ne considère pas les livres.
- 1) Définir les classes Livre, Auteur et Editeur
- 2) Ecrire une classe Test composée des méthodes main() et afficher(). La méthode main() permet de créer quatre objets Auteur : A1, A2, A3 et A4, trois objets Livres L1, L2 et L3, et finalement, deux objet Editeur E1 et E2. A1 et A2 sont les auteurs de L1 édité par E1. A3 est l’auteur unique de L2 édité par El. A2, A3 et A4 sont les auteurs de L3 édité par E2. Les références des objets Livre seront mises dans un tableau tabLivres. Faites l’appel de la méthode afficher() pour afficher les caractéristiques des livres édités à partir de l’an 2000 avec le nom du premier auteur de chaque livre.
- 3) On suppose que le nombre de Livres, Auteurs et Editeurs peut être assez important. Traiter l’exercice en utilisant des objets Vector à la place des tableaux.
- Définition des classes Livre, Auteur, et Editeur
- Classe Test
Exemple:
public class Personne {
String name; // Déclaration de l'attribut 'name'
int age; // Déclaration de l'attribut 'age'
// Constructeur avec deux paramètres
public Personne(String name, int age) {
this.name = name; // Initialisation de l'attribut 'name' avec la valeur du paramètre 'name'
this.age = age; // Initialisation de l'attribut 'age' avec la valeur du paramètre 'age'
}
// Constructeur avec un seul paramètre
public Personne(String name) {
this.name = name; // Initialisation de l'attribut 'name' avec la valeur du paramètre 'name'
this.age = 20; // Initialisation de l'attribut 'age' avec la valeur par défaut de 20
}
}
Solution
public class Point {
private char name; // Attribut pour stocker le nom du point
private double abscisse; // Attribut pour stocker l'abscisse du point
// Constructeur qui prend le nom et l'abscisse en argument
public Point(char name, double abscisse) {
this.name = name;
this.abscisse = abscisse;
}
// Méthode pour afficher le nom et l'abscisse du point
public void affiche() {
System.out.println("Point " + name + " : abscisse = " + abscisse);
}
// Méthode pour translater le point d'une certaine distance
public void translate(double distance) {
abscisse += distance;
}
}
public class Main {
public static void main(String[] args) {
// Création d'un point nommé 'A' avec une abscisse de 5.0
Point pointA = new Point('A', 5.0);
// Affichage des caractéristiques du point
pointA.affiche();
// Translation du point de 3.5 unités
pointA.translate(3.5);
// Affichage des caractéristiques du point après translation
pointA.affiche();
}
}
Solution
public class Robot {
private int x, y; // Attributs pour stocker la position du robot
private int orientation; // Attribut pour stocker l'orientation du robot
// Constructeur qui initialise la position et l'orientation du robot
public Robot(int x, int y, int orientation) {
this.x = x;
this.y = y;
this.orientation = orientation;
}
// Méthode pour faire tourner le robot à droite
public void tournerADroite() {
orientation = (orientation % 4) + 1;
}
// Méthode pour faire avancer le robot d'un pas selon son orientation
public void avancer() {
switch (orientation) {
case 1: // Nord
y++;
break;
case 2: // Est
x++;
break;
case 3: // Sud
y--;
break;
case 4: // Ouest
x--;
break;
}
}
// Méthode pour afficher la position et l'orientation du robot
public void afficheRobot() {
String direction = "";
switch (orientation) {
case 1:
direction = "Nord";
break;
case 2:
direction = "Est";
break;
case 3:
direction = "Sud";
break;
case 4:
direction = "Ouest";
break;
}
System.out.println("Position: (" + x + ", " + y + "), Orientation: " + direction);
}
}
public class Main {
public static void main(String[] args) {
// Création d'un robot à la position (0, 0) avec l'orientation Nord (1)
Robot robot = new Robot(0, 0, 1);
// Affichage des caractéristiques initiales du robot
robot.afficheRobot();
// Faire avancer le robot
robot.avancer();
robot.afficheRobot();
// Faire tourner le robot à droite (de Nord à Est)
robot.tournerADroite();
robot.afficheRobot();
// Faire avancer le robot à nouveau
robot.avancer();
robot.afficheRobot();
}
}
Solution
import java.util.Vector;
class Employe {
private String nom;
private String grade;
private float salaire;
private Service service;
public Employe(String nom, String grade, float salaire) {
this.nom = nom;
this.grade = grade;
this.salaire = salaire;
}
public String getNom() {
return nom;
}
public String getGrade() {
return grade;
}
public void setGrade(String grade) {
this.grade = grade;
}
public float getSalaire() {
return salaire;
}
public void setSalaire(float salaire) {
this.salaire = salaire;
}
public Service getService() {
return service;
}
public void setService(Service service) {
this.service = service;
}
@Override
public String toString() {
return "Employe [Nom=" + nom + ", Grade=" + grade + ", Salaire=" + salaire + "]";
}
}
import java.util.Vector;
class Service {
private String nom;
private int numTel;
private Employe chef;
private Vector employes;
public Service(String nom, int numTel) {
this.nom = nom;
this.numTel = numTel;
this.employes = new Vector<>();
}
public String getNom() {
return nom;
}
public int getNumTel() {
return numTel;
}
public void setNumTel(int numTel) {
this.numTel = numTel;
}
public Employe getChef() {
return chef;
}
public void setChef(Employe chef) {
this.chef = chef;
if (!employes.contains(chef)) {
employes.add(chef);
}
}
public void affecterEmploye(Employe e) {
employes.add(e);
e.setService(this);
}
public void eliminerEmploye(Employe e) {
employes.remove(e);
}
public int getNombreEmploye() {
return employes.size();
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("Service [Nom=").append(nom).append(", NumTel=").append(numTel).append("]\n");
sb.append("Chef: ").append(chef.getNom()).append("\nEmployés:\n");
for (Employe e : employes) {
if (e != chef) {
sb.append("- ").append(e.getNom()).append("\n");
}
}
return sb.toString();
}
}
public class Test {
public static void main(String[] args) {
// Création des services
Service S1 = new Service("Informatique", 12345);
Service S2 = new Service("Ressources Humaines", 67890);
// Création des employés
Employe E1 = new Employe("Alice", "Manager", 5000);
Employe E2 = new Employe("Bob", "Technicien", 3000);
Employe E3 = new Employe("Charlie", "Manager", 5500);
Employe E4 = new Employe("David", "Assistant", 2800);
// Affectation des employés aux services
S1.affecterEmploye(E1);
S1.affecterEmploye(E2);
S2.affecterEmploye(E3);
S2.affecterEmploye(E4);
// Définition des chefs de service
S1.setChef(E1);
S2.setChef(E3);
// Échange des employés E2 et E4 entre les services
S1.eliminerEmploye(E2);
S2.eliminerEmploye(E4);
S1.affecterEmploye(E4);
S2.affecterEmploye(E2);
// Augmentation du salaire de E2 et le rendre chef de son nouveau service
E2.setSalaire(3500);
S2.setChef(E2);
// Affichage des informations des chefs de service
System.out.println("Informations des chefs de service :");
System.out.println(S1.getChef());
System.out.println(S2.getChef());
// Affichage des informations des services
System.out.println("\nInformations des services :");
System.out.println(S1);
System.out.println(S2);
}
}
Solution
import java.util.Vector;
class Livre {
private final String titre;
private final int anneeEdition;
private final Editeur editeur;
private final Vector auteurs;
public Livre(String titre, int anneeEdition, Editeur editeur, Vector auteurs) {
this.titre = titre;
this.anneeEdition = anneeEdition;
this.editeur = editeur;
this.auteurs = auteurs;
}
public String getTitre() {
return titre;
}
public int getAnneeEdition() {
return anneeEdition;
}
public Editeur getEditeur() {
return editeur;
}
public Auteur getPremierAuteur() {
return auteurs.size() > 0 ? auteurs.get(0) : null;
}
@Override
public String toString() {
return "Livre{Titre='" + titre + "', Année d'édition=" + anneeEdition + ", Éditeur=" + editeur.getNom() + "}";
}
}
class Editeur {
private final String nom;
private String adresse;
private final Vector livres;
public Editeur(String nom, String adresse) {
this.nom = nom;
this.adresse = adresse;
this.livres = new Vector<>();
}
public String getNom() {
return nom;
}
public void setAdresse(String adresse) {
this.adresse = adresse;
}
public String getAdresse() {
return adresse;
}
public int getNombreLivre() {
return livres.size();
}
public void nouveauLivre(Livre livre) {
livres.add(livre);
}
public String getLivres() {
StringBuilder sb = new StringBuilder();
for (Livre livre : livres) {
sb.append(livre.getTitre()).append(", ");
}
return sb.toString();
}
@Override
public String toString() {
return "Éditeur{Nom='" + nom + "', Adresse='" + adresse + "'}";
}
}
class Auteur {
private final String nom;
private String adresse;
private final Vector livres;
public Auteur(String nom, String adresse) {
this.nom = nom;
this.adresse = adresse;
this.livres = new Vector<>();
}
public String getNom() {
return nom;
}
public void setAdresse(String adresse) {
this.adresse = adresse;
}
public String getAdresse() {
return adresse;
}
public void nouveauLivre(Livre livre) {
livres.add(livre);
}
public int getNombreLivre() {
return livres.size();
}
public String getLivre() {
StringBuilder sb = new StringBuilder();
for (Livre livre : livres) {
sb.append(livre.getTitre()).append(", ");
}
return sb.toString();
}
@Override
public String toString() {
return "Auteur{Nom='" + nom + "', Adresse='" + adresse + "'}";
}
}
public class Test {
public static void main(String[] args) {
// Création des auteurs
Auteur A1 = new Auteur("Auteur1", "Adresse1");
Auteur A2 = new Auteur("Auteur2", "Adresse2");
Auteur A3 = new Auteur("Auteur3", "Adresse3");
Auteur A4 = new Auteur("Auteur4", "Adresse4");
// Création des éditeurs
Editeur E1 = new Editeur("Éditeur1", "AdresseÉditeur1");
Editeur E2 = new Editeur("Éditeur2", "AdresseÉditeur2");
// Création des livres
Vector auteursL1 = new Vector<>();
auteursL1.add(A1);
auteursL1.add(A2);
Vector auteursL2 = new Vector<>();
auteursL2.add(A3);
Vector auteursL3 = new Vector<>();
auteursL3.add(A2);
auteursL3.add(A3);
auteursL3.add(A4);
Livre L1 = new Livre("Livre1", 2001, E1, auteursL1);
Livre L2 = new Livre("Livre2", 1999, E1, auteursL2);
Livre L3 = new Livre("Livre3", 2005, E2, auteursL3);
// Enregistrer les livres dans les éditeurs
E1.nouveauLivre(L1);
E1.nouveauLivre(L2);
E2.nouveauLivre(L3);
// Ajout des livres aux auteurs
A1.nouveauLivre(L1);
A2.nouveauLivre(L1);
A3.nouveauLivre(L2);
A2.nouveauLivre(L3);
A3.nouveauLivre(L3);
A4.nouveauLivre(L3);
// Tableau de livres
Vector tabLivres = new Vector<>();
tabLivres.add(L1);
tabLivres.add(L2);
tabLivres.add(L3);
// Appel de la méthode afficher
afficher(tabLivres);
}
public static void afficher(Vector tabLivres) {
System.out.println("Livres édités à partir de l'an 2000 :");
for (Livre livre : tabLivres) {
if (livre.getAnneeEdition() >= 2000) {
System.out.println(livre + ", Premier Auteur : " + livre.getPremierAuteur().getNom());
}
}
}
}