PREMIERS CONCEPTS

ORIENTÉS OBJETS

NADIA CHALABI
NAD.CHALABI@GMAIL.COM
 Introduction

 En java la notion d’objet est omniprésente.

 Dans un langage procédural:

➢ Le fonctionnement d’une application est réglé par une succession

d’appels aux différentes procédures et fonction disponibles dans le code.

➢ Procédures et fonctions qui manipulent des données de l’application.

➢ Il n’y a aucun lien entre les données et le code qui les manipulent.

 Le langage objet au contraire essaye de regrouper le code.

 Introduction

❑ Ce regroupement est appelé classe.

❑ Une application développée avec un langage objet, est

constituée de nombreuses classes.

❑ Les classes vont décrire les caractéristiques de chacun des

éléments.
 Notion d’objets

 Un objet est une structure informatique définie par un état et un

comportement
Objet=état + comportement
 L’état regroupe les valeurs instantanées de tous les attributs de l’objet.
 Le comportement regroupe toutes les compétences et décrit les actions et les
réactions de l’objet. Autrement dit le comportement est défini par les
opérations que l’objet peut effectuer.
 L’état d’un objet peut changer dans le temps.
 Généralement, c’est le comportement qui modifie l’état de l’objet
 Notion d’objet
les 3 véhicules partagent les mêmes types de
caractéristiques d'un point de vue conceptuelle
Etat de l’objet Objet 1 Objet 2 Objet 3

Attributs

Méthodes ou
comportement

Il y a de nombreuses autres caractéristiques que nous allons ignorer dans

cet exemple, afin de limiter la complexité (→ abstraction).
 Identité de l’objet

 En plus de son état, un objet possède une identité

qui caractérise son existence propre.

 Cette identité s’appelle également référence ou handle de l’objet.

 En terme informatique de bas niveau, l’identité d’un objet

représente son adresse mémoire.

 Deux objets ne peuvent pas avoir la même identité:

c’est-à-dire que deux objet ne peuvent pas avoir le
même emplacement mémoire
 Notion de classe

 Les objets qui ont des caractéristiques communes sont regroupés dans une
entité appelée classe.

 Une classe est une description formelle d'une collection d'objets similaires, de
même identité.

 Chaque objet appartient à une classe.

 Les généralités sont contenues dans les classe et les particularités dans les
objets.

 Les objets informatique sont construits à partir de leur classe par un processus
qui s’appelle l’instanciation.

 Tout objet est une instance d’une classe.

Voiture v1;// v1 est un objet de type Voiture
 Constructeurs

 Le constructeur est une méthode portant toujours le même

nom que la classe elle-même.

 Il ne retourne aucun type, même pas void.

 Comme pour une méthode classique, un constructeur peut

attendre des paramètres.

 Le constructeur d’une classe qui n’attend pas de paramètres

est désigné comme le constructeur par défaut de la classe.

 Le rôle du constructeur est principalement l’initialisation des

champs d’une instance de classe.
 Les méthodes

 Les méthodes sont simplement des fonctions définies à

l’intérieur d’une classe. Elles sont en général utilisées pour
manipuler les champs de la classe. La syntaxe générale de
déclaration d’une méthode est décrite ci-dessous.

[modificateurs] typeDeRetour nomDeLaMethode

([listeDesParamètres])
[throws listeException]
{ }
 Les méthodes
 Le type de retour peut être n’importe quel type de données, type de base du
langage ou type objet.

 Si la méthode n’a pas d’information à renvoyer vous devez utiliser le mot

clé void en remplacement du type de retour.

 La liste des paramètres est identique à une liste de déclaration de variables.

 Il faut spécifier le type du paramètre et le nom du paramètre.

 Si plusieurs paramètres sont attendus il faut séparer leur déclaration par

une virgule.

 Même si aucun paramètre n’est attendu, les parenthèses sont tout de même
obligatoires.

 Le mot clé throws indique la liste des exceptions que cette méthode peut
déclencher lors de son exécution.
 Méthodes et modificateurs d’accès

❑abstract : indique que la méthode est abstraite et qu’elle ne contient pas de code.
La classe où elle est définie doit elle aussi être abstraite.

❑final : indique que la méthode ne peut pas être redéfinie dans une sous-classe.

❑native : indique que le code de la méthode se trouve dans un fichier externe écrit
dans un autre langage.

❑synchronized : indique que la méthode ne peut être exécutée que par un seul
thread à la fois.
 Représentation UML d’une classe

Une classe est représenté par un rectangle à 3 compartiments:

Les classes sont stockées dans des packages

 Les packages offrent un

mécanisme général pour la
partition des modèles et le
regroupement des éléments
de la modélisation.
 Chaque package est
représenté graphiquement
par un dossier.
 Les packages divisent et
organisent les modèles de
la même manière que les
dossier organisent le
système de fichier.
 Accessibilité au membres d’une classe

Dans java, il existe 4 niveaux de protection :

 private (-) : Un membre privé d’une classe n’est accessible qu’à -
l’intérieur de cette classe.
 protected (#) : un membre protégé d’une classe est accessible à :
- L’intérieur de cette classe
- Aux classes dérivées de cette classe.
- Aux classes du même package.
 public (+) : accès à partir de toute entité interne ou
externe à la classe
 Autorisation par défaut : dans java, en l’absence des trois
autorisations précédentes, l’autorisation par défaut est package. Cette
autorisation indique que uniquement les classes du même package ont
l’autorisation d’accès.
Exemple d’implémentation d’une classe
 Exercice

 Créer deux comptes.

 Verser la somme de 3000 euros sur le compte 1.
 Retirer 2000 euros du compte 1.
 Affichez le solde du compte 1.
 Création des objets dans java
new Crée un objet dans l’espace mémoire
et retourne l’adresse mémoire (handle)
 Constructeur par défaut

 Quand on ne définit aucun constructeur pour une classe, le

compilateur crée le constructeur par défaut.
 Le constructeur par défaut n’a aucun paramètre et ne fait aucune
initialisation
 Exercice

 Complétez la classe avec un constructeur avec et sans

paramètres.
 Complétez la classe avec la méthode toString().
 Créez deux personnes.
 Affichez les deux personnes
 Getters et Setters
 Les attributs privés d’une classe ne sont accessibles qu’à l’intérieur de la
classe.
 Pour donner la possibilité à d’autres classes d’accéder aux membres
privés, il faut définir dans la classes des méthodes publiques qui
permettent de :

- lire la variables privés. Ce genre de méthodes s’appellent les

accesseurs ou Getters

- modifier les variables privés. Ce genre de méthodes

s’appellent les mutateurs ou Setters
 Getters et Setters

• Les getters sont des méthodes qui commencent toujours par le mot get
et finissent par le nom de l’attribut en écrivant en majuscule la lettre
qui vient juste après le get. Les getters retourne toujours le même type
que l’attribut correspondant.

Par exemple, dans la classe CompteSimple, nous avons défini un

attribut privé :
private String nom;
Le getter de cette variable est :

 Les setters sont des méthodes qui commencent toujours par le mot set
et finissent par le nom de l’attribut en écrivant en majuscule la lettre
qui vient juste après le set. Les setters sont toujours de type void et
reçoivent un paramètre qui est de même type que la variable:
 Membres statiques d’une classe.

 Dans l’exemple de la classe Compte, chaque objet Compte possède ses

propres variables code et solde. Les variables code et solde sont appelées
variables d’instances.

 Les objets d’une même classe peuvent partager des mêmes variables qui
sont stockées au niveau de la classe. Ce genre de variables, s’appellent les
variables statiques ou variables de classes.

 Un attribut statique d’une classe est un attribut qui appartient à la classe et

partagé par tous les objets de cette classe.

 Comme un attribut une méthode peut être déclarée statique, ce qui signifie
qu’elle appartient à la classe et partagée par toutes les instances de cette
classe.

 Dans la notation UML, les membres statiques d’une classe sont soulignés
▪ Supposons que nous voulions ajouter à la
classe Compte une variable qui permet
de stocker le nombre le comptes créés.
▪ Comme la valeur de variable nbComptes
est la même pour tous les objets, celle-ci
sera déclarée statique. Si non, elle sera
dupliquée dans chaque nouveau objet
créé
▪La valeur de nbComptes est au départ
initialisée à 0, et pendant la création
d’une nouvelle instance (au niveau du
constructeur), nbCompte est incrémentée
et on profite de la valeur de nbComptes
pour initialiser le code du compte.
 Destruction des objets : Garbage Collector

 Dans certains langages de programmation, le programmeur doit s ’occuper

lui même de détruire les objets inutilisables.

 Java détruit automatiquement tous les objets inutilisables en utilisant ce qu

’on appelle le garbage collector (ramasseur d ’ordures). Qui
s ’exécute automatiquement dès que la mémoire disponible est inférieure à
un certain seuil.

 Tous les objets qui ne sont pas retenus par des handles seront détruits.

 Ce phénomène ralenti parfois le fonctionnement de java.

 Pour signaler au garbage collector que vous voulez détruire un objet d’une
classe, vous pouvez faire appel à la méthode finalize() redéfinie dans la
classe.
 L’encapsulation

 L'encapsulation permet de garder une cohérence

dans la gestion de l'objet, tout en assurant l'intégrité
des données qui ne pourront être accédées qu'au
travers des méthodes visibles.
 L’encapsulation

 Le terme encapsulation désigne le principe consistant à cacher

l’information contenue dans un objet et de ne proposer que des
méthodes de modification/accès à ces propriétés (attributs).

 L’objet est vu de l’extérieur comme une boîte noire ayant certaines

propriétés et ayant un comportement spécifié. La manière, dont le
comportement a été implémenté, est cachée aux utilisateurs de l’objet.

 But: Protéger la structure interne de l’objet contre toute manipulation

non contrôlée, produisant une incohérence.
 Encapsulation : exemple

❑ De point de vue utilisation, un objet est une boite noire qui offre un
certain nombre de méthodes permettant d’interagir avec lui.
❑ Peu importe comment il est construit en interne, la seule chose
nécessaire pour pouvoir utiliser un objet est de savoir ce qu’il peut faire
et surtout comment lui demander.
Exemple: un poste de TV est une « boite noire » ayant pour interface: un écran,
des HP et une télécommande. Pour changer de chaine, il suffit de
changerChaine(int chaine) Peu importe ce qui se passe réellement en
interne.
 L’encapsulation
Accès aux membres d’une classe

❑ En java, les modificateurs d’accès sont utilisés pour

protéger l’accessibilité des variables et des méthodes.
❑ Les accès sont contrôlés en respectant le tableau
suivant:

Une classe a Les classes d’un même

Une classe fille (ou
dérivée) n’a accès
toujours package protègent
qu’aux membres publics
uniquement leurs
accès à ses membres privés (à et protected de la classe
membres. l’intérieur du package) mère.
Modélisation d’un segment
t
 POO vs PPS (Prog. Procédurale Structurée)

❑ La POO inverse cet ordre et place les données au premier

plan avant de déterminer l’algorithme qui sera employé pour
opérer sur ces données.

❑ En POO, chaque objet accomplit quelques tâches associées.

❑ Si un objet dépend d’une tâche qui n’est pas de sa

responsabilité, il doit avoir accès à un autre objet capable
d’accomplir cette tâche.
 POO vs PPS

POO PPS

Principe : On sépare les

Principe : afin d’établir de
données des moyens de
façon stable et robuste
traitement de ces données.
l’architecture d’un système, il
semble raisonnable de
s’organiser autour des données
manipulées.
 Exemple: Gestion d'une bibliothèque

 Approche procédurale : Gérer les

Que doit faire mon programme ? emprunts de
livres

Gérer le
 Approche orientée objet : stock

De quoi doit être composé mon programme ?

Bibliothécaire
Cours C++ Cours Java
RITCHIE Directrice
DELANNOY
Lecteur
 Avantages de la POO

 La construction d’un système va s’axer principalement sur

la détermination des données dans un premier temps et la
réalisation des traitements (de haut-niveau) agissant sur
ces données dans un second temps.

 Cette approche permet de bâtir des systèmes plus

simples à maintenir et à faire évoluer.

 On regroupe dans une même entité informatique, appelée

objet, les structures de données et les moyens de traitement
de ces données.
 Exemple: Gestion d'une bibliothèque

 Approche procédurale : Gérer les

Que doit faire mon programme ? emprunts de
livres

Gérer le
 Approche orientée objet : stock

De quoi doit être composé mon programme ?

Bibliothécaire
Cours C++ Cours Java
RITCHIE Directrice
DELANNOY
 Exemple: un livre à la bibliothèque est caractérisé par:

❑ Un titre
❑ Un auteur
❑ Un numéro d’inventaire
❑ Un numéro de classement
❑ Une quantité (le nombre de livres disponibles à la biblihothèque).
Un objet de type Livre est constitué d’attributs qui caractérisent la
structure de cet objet: private String titre;
private String auteur
private int numInv;
private String numClas;
Static int Qte;

L'objet est manipulé par exemple par les méthodes suivantes:

✓ disponible : Méthode permettant de dire si le livre est disponible à la
bibliothèque
✓qteDisponible: Méthode permettant d’agir sur la quantité disponible
 Notion de classe

 Des objets similaires peuvent être informatiquement

décrits par une même abstraction : une classe
✓ même structure de données et méthodes de traitement
✓ valeurs différentes pour chaque objet
public class Personne
{
private String nom;
private String prenom;
private LocalDate date_nais;
Les champs de la classe sont maintenant
public String getNom() Accessibles depuis l’extérieur grâce à
{ ces méthodes.
return nom;
p.setNom("dupont");
} p.setPrenom("albert");
public void setNom(String n) System.out.println(p.getNom());
{ System.out.println(p.getPrenom())
nom = n.toUpperCase(); ;
}
public String getPrenom()
{
return prenom;
}
public void setPrenom(String p)
{
prenom = p.toLowerCase();
}
}
 Exercice 1
class Compte{
 Voici le texte
int solde = 0;
d’une classe
void deposer(int montant){ représentant de
solde = solde + montant; façon sommaire
} un compte
void retirer(int montant){ bancaire et les
solde = solde - montant; opérations
} bancaires
void virerVers(int montant, Compte destination) courantes.
{
this.retirer(montant);
destination.deposer(montant);
}
void afficher(){
System.out.print("solde: "+ solde);
}
}
 Exercice 1:partie 1

1- Comment fonctionne la méthode virement ? Combien de comptes fait-elle

intervenir ?

2- Créez deux comptes que vous affecterez à deux variables. Ecrivez le code
correspondant aux opérations suivantes :

– dépôt de 500 euros sur le premier compte.

– dépôt de 1000 euros sur le second compte.

– retrait de 10 euros sur le second compte.

– virement de 75 euros du premier compte vers le second.

– affichage des soldes des deux comptes.

Vous mettrez le code java correspondant à cette question dans la méthode main
d’une nouvelle classe appelée TesteCompte. Vous compilerez et testerez ce
programme.
public class TesteCompte {
public static void main(String[] args) {
Compte martin, jean;

martin = new Compte();

jean = new Compte();

// dépôt de 500 euros sur le premier compte.

martin.deposer(500);

// dépôt de 1000 euros sur le second compte.

jean.deposer(1000);

// retrait de 10 euros sur le second compte.

jean.retirer(10);

// virement de 75 euros du premier compte vers le second.

martin.virerVers(75, jean);

// affichage des soldes des deux comptes.

System.out.println("Compte de martin, ");

martin.afficher();
System.out.println("Compte de jean, ");
jean.afficher();}}
 Exercice 1:partie 2

• Créez un tableau de dix comptes. Pour cela, notez bien qu’il

faut d’abord créer le tableau puis créer successivement les dix
comptes à mettre dans les dix cases de ce tableau.

• Dans chaque case, faites un dépôt de 200 euros plus une

somme égale à 100 fois l’indice du compte dans le tableau.

• Ensuite, vous ferez un virement de 20 euros de chaque

compte vers chacun des comptes qui le suivent dans le tableau
(par exemple, du compte d’indice 5, il faut faire des virements
vers les comptes d’indice 6, 7, 8 et 9).

 Enfin, vous afficherez les soldes de tous les comptes.

Ici encore, vous testerez et compilerez le code proposé.
public class TesteCompte {
public static void main(String[] args) {
Compte martin, jean;

Compte[] table = new Compte[10];

martin = new Compte();

jean = new Compte();

// dépôt de 500 euros sur le premier compte.
martin.deposer(500);
// dépôt de 1000 euros sur le second compte.
jean.deposer(1000);
// retrait de 10 euros sur le second compte.
jean.retirer(10);
// virement de 75 euros du premier compte vers le second.
martin.virerVers(75, jean);

// affichage des soldes des deux comptes.

System.out.println("Compte de martin, ");
martin.afficher();

System.out.println("Compte de jean, ");

jean.afficher();
for (int i=0; i<table.length; i++){
table[i] = new Compte();
table[i].deposer(200 + i*100);
}
for (int i=0; i<table.length; i++){

for (int j=i+1; j<table.length; j++){

table[i].virerVers(20, table[j]);
}

}
for (int i=0; i<table.length; i++){
System.out.println("Compte numero "+ i + ", ");
table[i].afficher();

}
}
}
 Exercice 1:partie 3

❑ Complétez la classe Compte avec une information

supplémentaire : le nom du titulaire du compte
(type String).

❑ Vous modifierez la méthode d’affichage pour qu’elle affiche

cette information.

❑ Créez un constructeur pour la classe Compte.

❑ Ce constructeur doit prendre en paramètre le nom
du titulaire du compte.
❑ Donnez le code de création d’un compte qui appelle ce
constructeur.
class Compte{
int solde = 0;
String titulaire;
Compte(String n){
titulaire = n;
}

void deposer(int montant){

solde = solde + montant;
}
void retrait(int montant){
solde = solde -montant;
}
void virement(int montant, Compte autre){
autre.retrait(montant);
this.depot(montant);
}
void afficher(){
System.out.println("Compte de " + titulaire + ", solde: "+ solde);
}
}
public static void main(String[] argv){
Compte unCompte = new Compte("Jean Delacroix");
unCompte.deposer(700);
unCompte.afficher();
}
}
 Exercice 2

 Définir une classe Voiture avec les attributs suivants

: id, marque, vitesse, puissance.
 Définir un constructeur permettant d’initialiser les
attributs d'un objet voiture par des valeurs passées en
paramètre. Sachant que id doit être auto-incrément.
 Définir les accesseurs aux différents attributs de la classe.
 Définir la méthode toString ( ) permettant d’afficher les
informations d'une voiture.
 Écrire un programme testant la classe Voiture.
 public class Voiture {
//Attribut de l'objet
private int id;
private String marque;
private double vitesse;
private int puissance;
//Variable de classe
//Variables dont il n’existe qu’un seul exemplaire
//associé à sa classe de définition
public static int count = 0;
public Voiture(String marque, double vitesse, int
puissance) {
this.id = ++count;
this.marque = marque;
this.vitesse = vitesse;
this.puissance = puissance;
}
@Override
public String toString() {
return "id=" + id + ", marque=" + marque + ", vitesse=" +
vitesse+ ", puissance=" + puissance;
} }
public class TestVoiture {

public static void main(String[] args) {

Voiture[] voitures = new Voiture[3];

voitures[0] = new Voiture("BMW", 220, 8);
voitures[1] = new Voiture("Ford", 200, 6);
voitures[2] = new Voiture("Audi", 240, 8);

for (Voiture s: voitures) {

System.out.println(s);
}

System.out.println("Le nombre des voitures est : " +

Voiture.count);

}
}
 Récupérer ce que vous tapez

//Ceci importe la classe Scanner du package java.util

import java.util.Scanner;
//Ceci importe toutes les classes du package java.util
import java.util.*;
Scanner sc = new Scanner(System.in);
System.out.println("Veuillez saisir un mot :");
String str = sc.nextLine();
System.out.println("Vous avez saisi : " + str);
 Exercice 3

 Définir une classe Livre avec les attributs suivants : id, titre, auteur
(Nom complet), prix.

 Définir les accesseurs aux différents attributs de la classe.

 Définir un constructeur permettant d’initialiser les attributs d'un

objet livre par des valeurs saisies par l’utilisateur. Sachant que
Id doit être auto-incrément.

 Définir la méthode toString ( ) permettant d’afficher les

informations du livre en cours.

 Écrire un programme testant la classe Livre (reportez-vous à

l’affichage de la diapo suivante).
 Exercice 3 (suite)

Donner le titre du livre n° 1 :Langage C

Donner l'auteur du livre n° 1 :XXXXXX
Donner le prix du livre n° 1 :200
Donner le titre du livre n° 2 :Langage JAVA
Donner l'auteur du livre n° 2 :YYYYYYY
Donner le prix du livre n° 2 :300
Donner le titre du livre n° 3 :Langage C#
Donner l'auteur du livre n° 3 :ZZZZZZZ
Donner le prix du livre n° 3 :250
Le prix du livre Langage C de l'auteur XXXXX est :20euros
Le prix du livre Langage JAVA de l'auteur YYYYYY est :30euros
Le prix du livre Langage C# de l'auteur ZZZZZZ est :25 euros
Le nombre de livres est 3
public class Livre {
private int id;
private String titre;
private String auteur;
private int prix;
public static int count;

public Livre(String titre, String auteur, int prix) {

this.id = ++count;
this.titre = titre;
this.auteur = auteur;
this.prix = prix;
}

public int getId() {

return id;
}

public String getTitre() {

return titre;
}
public void setTitre(String titre) {
this.titre = titre;
}

public String getAuteur() {

return auteur;
}

public void setAuteur(String auteur) {

this.auteur = auteur;
}

public int getPrix() {

return prix;
}
public void setPrix(int prix) {
this.prix = prix;
}
@Override
public String toString() {
return "Le prix du livre " + this.titre + " de l'auteur " + this.a
+ " est :" + this.prix + " euros";
}
import java.util.Scanner;
public class TestLivre {
public static void main(String[] args) {
Livre[] livres = new Livre[3];
Scanner sc = null;

for (int i = 0; i < livres.length; i++) {

sc = new Scanner(System.in);
System.out.print("Donner le titre du livre n° " + (i + 1) + "
:");
String titre = sc.nextLine();
System.out.print("Donner l'auteur du livre n° " + (i + 1) + "
:");
String auteur = sc.nextLine();
System.out.print("Donner le prix du livre n° " + (i + 1) + "
:");
int prix = sc.nextInt();
livres[i] = new Livre(titre, auteur, prix);
}
sc.close();
for (Livre l : livres)
System.out.println(l);
System.out.println("Le nombre de livres est " + Livre.count);
}
 Exercice 4

 Définir une classe Rectangle ayant les attributs suivants :

Longueur et Largeur.
 Ajouter un constructeur d’initialisation.
 Définir les accesseurs aux attributs de la classe.
 Ajouter les méthodes suivantes :
 périmètre ( ) : retourne le périmètre du rectangle.
 aire ( ) : retourne l'aire du rectangle.
 isCarre ( ) : vérifie si le rectangle est un carré.
 toString ( ) : expose les caractéristiques d’un rectangle comme
suit :
Longueur : […] - Largeur : […] - Périmètre : […] - Aire : […] -
C'est un carré / Ce n'est pas un carré
public class Rectangle {
private double longueur;
private double largeur;

public Rectangle(double longueur, double largeur) {

this.longueur = longueur;
this.largeur = largeur;
}
public double getLongueur() {
return longueur;
}
public void setLongueur(double longueur) {
this.longueur = longueur;
}
public double getLargeur() {
return largeur;
}
public void setLargeur(double largeur) {
this.largeur = largeur;
}
public double perimetre() {
return (this.longueur + this.largeur) * 2;
}

public double aire() {

return longueur * largeur;
}

public boolean isCarre() {

if (longueur == largeur)
return true;
else
return false;
}
public String toString() {
String etat = null;
if (this.isCarre())
etat = "C'est un carré";
else
etat = "Ce n'est pas un carré";

return "-Longueur : " + this.longueur + " -Largeur : "

+ this.largeur+ " -Perimetre : " + this.perimetre() + " -Aire : "
+ this.aire() + " -" + etat;
}
public class TestRectangle {
public static void main(String[] args) {
Rectangle [] rectangles = new Rectangle[3];
rectangles [0] = new Rectangle(12.6, 5.3);
rectangles [1] = new Rectangle(3, 3);
rectangles [2] = new Rectangle(10.5, 5);
for(Rectangle e: rectangles)
System.out.println(e);//System.out.println(e.toString());
}

}
Créer le code java des
classes suivantes
 Exercice

 Créez une classe appelée « Point ». Cette classe doit avoir

2 entiers (x, y) en tant que membres privés. Le
constructeur doit définir les valeurs de x et y via des
paramètres. La classe doit avoir une méthode publique
appelée « distance ». Cela prend un seul
paramètre(Point) et renvoie la distance entre les 2
points.
 Exercice

Circle

-rayon : double
Créer le code java de la
+Circle() classe suivante
+Circle(rayon:double,
couleur: String)
+setRayon()
+getRayon():double
+getSurface():double
 package test;

 public class Circle {

 private Point centre;
 private double rayon;

 Circle(Point centre, double rayon) {

 this.centre = centre;
 this.rayon = rayon;
 }

 public Point getCentre() {

 return this.centre;
 }

 public double getRayon() {

 return this.rayon;
 }

 public Point setCentre() {

 return this.centre;
 }

 public double setRayon() {

 return this.rayon;
 }

 public double getSurface() {

 double area = Math.PI * rayon * rayon;
 return area;

 }

 public double getPerimetre() {

 double perimeter = Math.PI * (rayon * 2);
 return perimeter;

 }

 public boolean appartient(Point p) {

 return this.centre.distance(p) < this.rayon;
 //un point appartient à un cercle si la distance entre le centre du cercle et le point
 //est < rayon
 }

 public boolean chevauche(Circle c) {

 double d = this.centre.distance(c.getCentre());
 return d < this.rayon + c.getRayon();
 // un cercle peut se chevaucher avec un autre cercle si la distance entre
 //le centre des deux cercles est < à la somme des deux rayons
 }

 }
 Etudiant
Departement
-num: double
-num : double
-nom : String
-nom : String
-Dept:String
+Departement()
+getNum:double
+Etudiant()
+getNom():String
+getNum:double
+getNom():String
+getDept():String
+toString():String

Institut Ecrire le code java associé aux classes

suivantes sachant que
-nomInstitut : double Un institut possède plusieurs
départements
Un département possède plusieurs
+Institut() étudiants
+getNomInstitut():String Après exécution du main, ce dernier doit
+nbTotalEtudiant():double afficher
L’institut Tech comporte 250 étudiants
 int prix=Integer.parseInt(sc.nextLine())