java POO

1. Deuxième partie
Java et la Programmation
Orientée Objet

2. Votre première classe
• une définition.
Une classe est une structure informatique représentant les principales
caractéristiques d'un élément du monde réel grâce :
• des variables, qui représentent les divers attributs de l'élément que vous
souhaitez utiliser .
• des méthodes, qui permettent de définir les comportements de vos
éléments.
• Pour accéder à une classe il faut en déclarer une instance de classe ou
objet.
Une classe contient donc des variables et des méthode.

3. • La syntaxe de déclaration d'une classe.
La syntaxe de déclaration d'une classe est la
suivante :
modificateurs class nom_de_classe { ... }

4. Si vous avez bien suivi la première partie, vous devriez savoir que notre classe
contenant la méthode main ressemble à ceci :
class Sdz1{
public static void main(String[] args){
}
}
nous allons créer une seconde classe dans ce fameux projet !
Créons sans plus tarder une classe Ville. Allez dans File/New/Class.
il ne peut y avoir qu'une seule méthode main active par projet !

6. • Une classe est un modèle ou encore un moule avec lequel on crée des objets par
une opération d'instanciation.
• La déclaration d'un objet crée une référence, mais il n’est pas créé physiquement. Il
faut utiliser l’opérateur new créant dynamiquement un espace mémoire pour
contenir l'objet.
Syntaxe:
NomClasse nomObjet = new NomClasse();
Exemple:
Ville ville = new Ville();
• Une classe contient des variables et des méthodes.
Exemple:
classe + instanciation = objet

7. Accès aux données d’un objet
NomObjet.<nomVariable> = <valeur d’initialisation>

8. Accès aux méthodes d’un objet:
<variable> = NomObjetNomObjet.<nomfct>(arg1, arg2, … , arg)

9. Une méthode particulière: le
constructeur
• Un constructeur est une méthode appelée
automatiquement lors de l'instanciation de l’objet;
ainsi une initialisation des attributs de l’objet sera
systématiquement exécutée par le constructeur.
• Le constructeur est identifié par son nom qui est
celui de la classe et par le fait qu'il est sans type
retourné.
• Il peut y avoir plusieurs constructeurs surchargés
(avec des arguments différents à la création des
objets)

12. Exemple de classe comportant un constructeur

13. Accesseurs et mutateurs(Getters et
Setters.)
• Un accesseur est une méthode qui va nous
permettre d'accéder aux variables de nos
objets en lecture.
• un mutateur nous permettra d'en faire de
même en écriture !
• Grâce aux accesseurs, vous pourrez afficher
les variables de vos objets, et grâce aux
mutateurs, vous pourrez les modifier.

15. méthode main

18. • les constructeurs → méthodes servant à créer
des objets ;
• les accesseurs → méthodes servant à accéder
aux données des objets ;
• les méthodes d'instance → méthodes servant
à la gestion des objets.

19. exercice1
• Écrire en JAVA une classe «Rectangle» ayant
deux variables « a » et « b » et une fonction
membre « surface() » qui retournera la
surface du rectangle.

20. corriger
• class Rectangle {
private
int a,b;
Rectangle() {a=0; b=0;}
Rectangle (int a, int b){ this.a=a; this.b=b; }
int surface(){
return a*b;
}
};
• class Main {
public static void main(String[] args){
Rectangle r1 = new Rectangle ();
Rectangle r2 = new Rectangle (5,4);
System.out.println("la surface est:"+r1.surface());
System.out.println("la surface est:"+r2.surface());
}
}

21. EXERCICE2
• Ecrire en JAVA une classe « Somme » ayant
deux variables « n1 » et « n2 » et une
fonction membre « som() » qui calcule la
somme. Dans la méthode principale main
demandez à l’utilisateur d’entrez deux entiers
et passez-les au constructeur par défaut de la
classe « Somme » et afficher le résultat de
l’addition des deux nombres.

22. CORRECTION
Import java.util.Scanner;
class Somme{
public
int n1, n2;
Somme(int nbr1, int nbr2){
n1=nbr1;
n2=nbr2;
}
int som(){
return n1 + n2;
}
};
class Main {
public static void main(String[] args){
int n1, n2;
Scanner sc = new Scanner (System.in);
System.out.println("Entrer N1:");
n1 =sc.nextInt();
System.out.println("Entrer N2:");
n2 = sc.nextInt();
Somme obj= new Somme(n1,n2);
System.out.println("Le resultat de l'addition est :"+obj.som());
}
}

23. EXERCICE3
• Écrire classe JAVA appelée « Etudiant » avec les
membres suivant :
nom : (de type char),
note1, note2 : (de type float)
calc_moy() : calcule la note moyenne.
afficher () : affiche le nom et la note moyenne.
Le programme principal (main) demande à
l’utilisateur d’entrer le nom et les notes d'un
étudiant. et affiche leur nom et la note
moyenne.

24. import java.util.Scanner;
class Etudiant {
public
String nom;
float note1, note2;
Etudiant(String _nom, float _note1, float _note2){
nom = _nom;
note1 = _note1;
note2 = _note2;
}
float calc_moy(){
return (note1 + note2)/2;
}
void afficher (){
System.out.println("Etudiant: "+ nom +" n moyenne: "+ calc_moy());
}
};
class Main {
public static void main(String[] args){
String nom;
int note1, note2;
Scanner sc = new Scanner (System.in);
System.out.println("Entrer le nom:");
nom = sc.nextLine();
System.out.print("Entrez note 1:");
note1= sc.nextInt();
System.out.print("Entrez note 2: ");
note2 = sc.nextInt();
Etudiant E = new Etudiant (nom, note1, note2);
E.afficher();
}
}

25. EXERCICE4
Écrire un programme en JAVA qui simule la gestion d’un simple compte
bancaire. Le compte est créé avec un solde initial. Il est possible de
déposer et de retirer des fonds, d’ajouter des intérêts et de connaître le
solde actuel.
1. un constructeur par défaut qui met le solde initial à zéro.
2. Un constructeur qui accepte une balance initial comme paramètre.
3. Une fonction getBalance qui renvoie le solde actuel.
4. Une méthode deposer pour déposer un montant spécifié.
5. Une méthode retirer pour retirer un montant spécifié.
6. Une méthode ajouter_Interet pour ajouter de l’intérêt au compte.
La méthode ajouter_Interet prend le taux d’intérêt comme paramètre
et modifie le solde du compte en solde * (1 + taux d’intérêt).

26. Corriger
class Compte {
private
double balance = 0;
public
Compte() {balance =0; }
Compte(double initial_balance) {balance = initial_balance ; }
double getBalance() { return balance; }
void deposer(double amount) { balance += amount; }
void retirer (double amount) { balance -= amount; }
void ajouter_Interet (double rate) { balance = balance*(1 + rate); }
};
class Main {
public static void main(String[] args) {
Compte compte1 = new Compte();
Compte compte2 = new Compte(3000);
compte1.deposer(100);
compte2.retirer(1000);
compte1.ajouter_Interet (0.3);
System.out.println(compte1.getBalance());
System.out.println(compte2.getBalance());
}
}

27. Exercice 6
L'héritage
• Écrivez un programme en JAVA qui définit une classe
appelée Forme avec un constructeur qui donne de la
valeur à la largeur(x) et à la hauteur(y). Définir la
méthode aire() dans les deux sous-classes Triangle et
Rectangle, qui calculent l’aire. Dans la méthode
principale main, définissez deux variables, un triangle
et un rectangle, puis appelez la fonction aire() dans
ces deux variables.
• Notez que:
• l’aire du triangle est = largeur * hauteur / 2
• l’aire du rectangle est = largeur * hauteur.

28. class Forme {
protected
float x, y;
public Forme() { x=0; y=0; }
Forme(float x, float y)
{
this.x = x;
this.y = y;
}
};
class Rectangle extends Forme
{
public Rectangle (){ super();}
Rectangle (int x,int y){ super (x,y);}
float aire()
{
return (x * y);
}
};
class Triangle extends Forme
{
public Triangle (int x ,int y)
{super(x,y);}
float aire()
{
return (x * y / 2);
}
};
class Main {
public static void main(String[] args) {
Rectangle R = new Rectangle (2,3);
Triangle T = new Triangle (2,3);
Rectangle R1 = new Rectangle ();
System.out.println(R.aire());
System.out.println(T.aire());
System.out.println(R1.aire());