UE 2I002 (ex LI230) : éléments de programmation par objets avec Java
TD 2
Juliana Silva Bernardes
[email protected]
http://www.lcqb.upmc.fr/julianab/teaching/JAVA/
!
• this
• Surcharge de constructeurs – Encapsulation
• Surcharge de methodes
• Méthode toString
!
!
Summary
3
Encapsulation
Exemple
39
public class Chien {
// variables d’instance private int taille;
private String race;
private String nom;
// Constructeur sans paramètre public Chien () {
taille = 10;
race = "";
nom = "";
}
// une méthode
public void aboyer() {
System.out.println("Ouah! Ouah!");
} }
Chien
private int taille private String race private String nom
Chien()
public void aboyer()
Exemple : la classe Test
UMLL’opérateur « point » (.) donne accès à l’état (les variables d’instance) et au comportement d’un objet (ses méthodes).
public class Test {
public static void main(String [] args) {
// créer un nouvel objet, une nouvelle instance Chien monChien = new Chien();
// lui dire d’aboyer en utilisant l’opérateur // point sur la variable monChien pour appeler // aboyer()
monChien.aboyer();
} }
Chien
- taille : int - race : String - nom : String + Chien()
+ aboyer():void
Encapsulation
On ne peut pas utiliser l’opérateur « point » (.) sur les variables de la classe que sont private
Encapsulation
41
On ne peut pas utiliser l’opérateur « point » (.) sur les variables de la classe Chien ailleurs que dans la classe Chien elle-même.
public class Test {
public static void main(String [] args) {
// créer un nouvel objet, une nouvelle instance Chien monChien = new Chien();
//définir sa taille à l’aide de l’opé point monChien.taille = ...;
// lui dire d’aboyer : appeler aboyer() monChien.aboyer();
} }
La variable taille est « propriété privée » de la classe Chien .
! La variable taille est « propriété privée » de la classe Chien .
Encapsulation
On ne peut pas utiliser l’opérateur « point » (.) sur les variables de la classe que sont private
Encapsulation
41
On ne peut pas utiliser l’opérateur « point » (.) sur les variables de la classe Chien ailleurs que dans la classe Chien elle-même.
public class Test {
public static void main(String [] args) {
// créer un nouvel objet, une nouvelle instance Chien monChien = new Chien();
//définir sa taille à l’aide de l’opé point monChien.taille = ...;
// lui dire d’aboyer : appeler aboyer() monChien.aboyer();
} }
La variable taille est « propriété privée » de la classe Chien .
! Alors comment va-t-on pouvoir acceder et modifier les variables de la classe ?
les accesseurs et les modificateurs
Les accesseurs
public class TestChien {
public static void main(String [] args) {
Chien monChien = new Chien(0.85, “labrador”, “bob");
System.out.println(monChien.getRace());}
public class Chien {
private double taille;
private String race;
private String nom;
public Chien(int taille, String race, String nom){
this.taille = taille;
this.race = race;
this.nom = nom;}
public double getTaille() {return taille;}
public String getRace() { return race;}
public String getNom() { return nom;}
<— variables d’instance
<— accesseurs
Créez un labrador qui s’appelle bob de taille 0.85 m, et Affichez sa race 😓
Les modificateurs
!
public class Test {
public static void main(String [] args) {
Chien monChien = new Chien(0.85, “labrador”, “bob");
monChien.setRace("Boxer")
System.out.println(monChien.getRace());
public class Chien {
private double taille;
private String race;
private String nom;
public Chien(int taille, String race, String nom){
this.taille = taille;
this.race = race;
this.nom = nom;}
public double getTaille() {return taille;}
public String getRace() { return race;}
public String getNom() { return nom;}
<— variables d’instance
<— accesseurs
Changez la race pour "Boxer" et Affichez 😓
Surcharge de constructeurs
public class Point2D {
// variables d’instance private int x;
private int y;
//Constructeurs
public Point2D() {x = 0; y = 0;}
public Point2D(int x, int y) {this.x = x; this.y = y;}
}
Nous pouvons avoir plus qu'un constructer dans une classe
public class TestPoint2D {
public static void main(String [] args) { Point2D p1 = new Point2D();
Point2D p2 = new Point2D(3, 5);
}
x=0
p1 => y=0
public class Point2D {
// variables d’instance private int x;
private int y;
//Constructeurs
public Point2D() {x = 0; y = 0;}
public Point2D(int x, int y) {this.x = x; this.y = y;}
}
x=0
p1 => y=0 p2 => x=3 y=5
Surcharge de constructeurs
public class TestPoint2D {
public static void main(String [] args) { Point2D p1 = new Point2D();
Point2D p2 = new Point2D(3, 5);
}
Nous pouvons avoir plus qu'un constructer dans une classe
public class Point2D {
// variables d’instance private int x;
private int y;
//Constructeurs
public Point2D() {this(0, 0);}
public Point2D(int x, int y) {this.x = x; this.y = y;}
}
Surcharge de constructeurs
public class TestPoint2D {
public static void main(String [] args) { Point2D p1 = new Point2D();
Point2D p2 = new Point2D(3, 5);
}
Nous pouvons avoir plus qu'un constructer dans une classe
Attention : Réutilisez les constructeurs existent.
public class Employe {
// variables d’instance private String nom;
private double salaire;
//Constructeurs
public Employe() {this(0, 0);}
public Employe(String nom, double salaire) { this.nom = nom; this.salaire = salaire;}
}
Surcharge de constructeurs
Ecrivez la class Employe Employe
- salaire : double - nom : String + Employe()
+ Employe(String, double)
😓
Signature = nom de la méthode et de la liste ordonnée des types de ses arguments
Surcharge de methodes
public void setTaille(double taille)
‣ Plusieurs méthodes de mêmes noms peuvent coexister dans une
classe pourvu que leurs signatures soient différentes.
Surcharge de methodes
public class Employe{
private String nom;
private double salaire;
!
public double prime(){
return salaire*1.05;
}
public double prime(int nombreEnfants){
return salaire*(1 + 0.1*nombreEnfants);
}
Employe
- salaire : double - nom : String + Employe()
+ Employe(String, double) + prime(): double
+ prime(int): double
Ecrivez les methods prime :
• Le premier sans arguments 5% sur le salaire
• Le deuxieme 10% sur le salaire pour chaque enfant 😓
😓
Créez l'employé Jonh (salaire = 2000) sans enfants et donnez-lui sa prime.
Créez l'employé Paul (salaire = 3000) avec 3 enfants et donnez-lui sa prime.
Surcharge de methodes
public class Employe{
private String nom;
private double salaire;
!
public double prime(){
return salaire*1.05;
}
public double prime(int nombreEnfants){
return salaire*(1 + 0.1*nombreEnfants);
} }
public class TestEmploye{
public static void main(String [] args) {
Employe e1 = new Employe(“Jonh”, 2000);
e1.prime();
!
Employe e2 = new Employe(“Paul”, 3000);
e2.prime(3);
} }
😓
‣ Décrire sous la forme d’une chaîne de caractères l’état de l’objet au moment de l’invocation.
‣ Elle peut (doit) être définie (redéfinie) pour chaque classe
‣ Il faut respecter la syntaxe suivante :
Méthode toString()
public String toString ()
{
String s = “”;
s = s + “qq choise” + ..;
return s ;
}
Méthode toString()
public class Point2D {
// variables d’instance private int x;
private int y;
. . .
public String toString() {
String s;
s = “(“ + x + “,” + y “)”;
return s;
} }
public class TestPoint2D {
public static void main(String [] args) { Point2D p1 = new Point2D(3, 5);
System.out.println(p1.toString());
!
Point2D p2 = new Point2D(7, 9);
System.out.println(p2);
}
