TP1 : Classes et objets

Exercice 1 :

Soit la classe Point ainsi définie :

class Point
{ public Point (int abs, int ord) { x = abs ; y = ord ; }
public void affiche ()
{ System.out.println ("Coordonnees " + x + " " + y) ;
}
private double x ; // abscisse
private double y ; // ordonnee
}
Lui ajouter une méthode plusLoin déterminant parmi deux points lequel est le plus éloigné
de l’origine et le fournissant en valeur de retour. On donnera deux solutions :
• plusLoin est une méthode statique de Point,
• plusLoin est une méthode usuelle de Point.

Exercice 2 :

On dispose de la classe Point suivante permettant de manipuler des points d’un plan.
class Point
{ public Point (double x, double y) { this.x = x ; this.y = y ; }
public void deplace (double dx, double dy) { x += dx ; y += dy ; }
public void affiche ()
{ System.out.println ("coordonnees = " + x + " " + y ) ;
}
private double x, y ;
}
En ajoutant les fonctionnalités nécessaires à la classe Point, réaliser une classe Segment permettant de manipuler des
segments d’un plan et disposant des méthodes suivantes :

segment (Point origine, Point extremite)

segment (double xOr, double yOr, double xExt, double yExt)
double longueur() ;
void deplaceOrigine (double dx, double dy)
void deplaceExtremite (double dx, double dy)
void affiche()

Exercice 3 :

Écrire une classe utilitaire UtilTab disposant des méthodes statiques suivantes :

• somme qui fournit la somme des valeurs d’un tableau de réels (double) de taille quelconque,

• incre qui incrémente d’une valeur donnée toutes les valeurs d’un tableau de réels (double).

Écrire un programme de test. Pour faciliter les choses, on pourra également doter la
classe UtilTab d’une méthode d’affichage des valeurs d’un tableau de réels.

Exercice 4 :

Écrire une classe utilitaire UtilTab disposant des méthodes statiques suivantes :
• genere qui fournit en retour un tableau des n premiers nombres impairs, la valeur de n
étant fournie en argument
• somme qui reçoit en argument deux vecteurs d’entiers de même taille et qui fournit en
retour un tableau représentant la somme de ces deux vecteurs.
Écrire un petit programme d’essai. Pour faciliter les choses, on pourra également doter la
classe UtilTab d’une méthode d’affichage des valeurs d’un tableau de réels.

Exercice 5 :

Réaliser une classe Vecteur permettant de manipuler des vecteurs ayant un nombre quelconque
de composantes de type double. On y prévoira :
• un constructeur Vecteur (int n), n représentant le nombre de composantes qui seront
alors initialisées à zéro,
• un constructeur Vecteur (int n, double x), n représentant le nombre de composantes qui
seront alors toutes initialisées à la valeur x,
• un constructeur Vecteur (double [ ] v) qui créera un vecteur par recopie du tableau v,
• une méthode (non statique) prod_scal fournissant le produit scalaire de deux
vecteurs (ici, si les deux vecteurs ne sont pas de même taille, on se contentera de
fournir la valeur zéro),
• une méthode (statique) somme fournissant la somme de deux vecteurs ; s’ils n’ont pas
la même taille, on renverra une référence "nulle",
• une méthode affiche affichant les composantes d’un vecteur.
Écrire un petit programme d’utilisation.

Exercice 6 :

Il existe une méthode de détermination de tous les nombres premiers compris entre 1 et n,
connue sous le nom de "crible d’Eratosthène". Elle consiste à dresser une liste de tous les
nombres entiers considérés et à y "rayer" tous les multiples d’autres entiers. Plus précisément,
on procéde ainsi :
• on raye le 1 (qui, par définition, n’est pas un nombre premier),
• on recherche, à partir du dernier nombre premier considéré (la première fois, on convient
qu’il s’agit du 1), le premier nombre non rayé (on peut montrer qu’il est premier). Il
devient, à son tour, le dernier nombre premier considéré et on raye tous ses multiples.

• On répète le traitement précédent jusqu’à ce que le nombre premier considéré soit

supérieur à la racine carrée de n. On peut alors démontrer que tous les nombres non
premiers ont été rayés de la liste.
Écrire un programme exploitant cette méthode pour rechercher tous les nombres premiers
compris entre 1 et une valeur fournie en donnée.