Exercice Java

Exercice : Tableau
Demandez à l’utilisateur de saisir un int et dites-lui si ce nombre se trouve dans un tableau t.

import java.util.Scanner;

public class RechercheSequentielle

{
public static void main(String[] args)
{
int[] tab = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
Scanner s = new Scanner(System.in);
System.out.println("Saisissez une valeur");
int r = s.nextInt();
s.close();
boolean trouve = false;
for (int i = 0 ; i < tab.length ; i++)
trouve = trouve || tab[i] == r;
System.out.print(r + " ");
if (trouve)
System.out.print("se trouve");
else
System.out.print("ne se trouve pas");
System.out.println(" dans le tableau.");
}
}

Exercice : Héritage
Définir une classe Point permettant de représenter un point dans R2. Vous utiliserez proprement
les concepts d’encapsulation.

Définir une classe Cercle héritant de de la classe précédente.

public class Point

{
private double abs, ord;

Point(double abs, double ord)

{
this.abs = abs;
this.ord = ord;
}

public double getAbs()

{
return abs;
}

public double getOrd()

{
return ord;
}

public void setAbs(double abs)

 {
this.abs = abs;
}

public void setOrd(double ord)

{
this.ord = ord;
}

// exercice 4

@Override
public String toString()
{
return "(abs = " + abs + " ; ord = " + ord + ")";
}
}

public class Cercle extends Point

{
private double rayon = 0;

public Cercle(double abs, double ord, double rayon)

{
super(abs, ord);
setRayon(rayon);
}

public Cercle(Point centre, double rayon)

{
this(centre.getAbs(), centre.getOrd(), rayon);
}

public double getRayon()

{
return rayon;
}

public void setRayon(double rayon)

{
if (rayon > 0)
this.rayon = rayon;
}

// exercice 4

@Override
public String toString()
{
return "( centre = " + super.toString() +
"; rayon = " + getRayon() + ")";
}

Exercice : Polymorphisme
Adaptez la pile ci-dessous afin qu’elle puisse contenir des objets de n’importe quel type
public class Pile
{
/*
* Tableau contenant les elements de la pile.
*/

private int[] tab;

/********************************************/

/*
* Taille de la pile
*/

private final int taille;

/********************************************/

/*
* Indice du premier element non occupe dans le tableau.
*/

private int firstFree;

/********************************************/

/*
* Constructeur
*/

Pile(int taille)
{
this.taille = taille;
tab = new int[taille];
firstFree = 0;
}
/********************************************/

/*
* Constructeur de copie.
*/

Pile(Pile other)
{
this(other.taille);
firstFree = other.firstFree;
for (int i = 0; i < firstFree; i++)
tab[i] = other.tab[i];
}

/********************************************/

/*
* Retourne vrai si et seulement si la pile est vide
*/

public boolean estVide()

{
return firstFree == 0;
}

/********************************************/

/*
* Retourne vrai si et seulement si la pile est pleine.
*/

public boolean estPleine()

{
return firstFree == taille;
}
/********************************************/

/*
* Retourne l'element se trouvant au sommet de la pile, -1 si la pile est
* vide.
*/

public int sommet()

{
if (estVide())
return -1;
return tab[firstFree - 1];
}

/********************************************/

/*
* Supprime l'element se trouvant au sommet de la pile, ne fait rien si la
* pile est vide.
*/

public void depile()

{
if (!estVide())
firstFree--;
}

/********************************************/

/*
* Ajoute data en haut de la pile, ne fait rien si la pile est pleine.
*/

public void empile(int data)

{
 if (!estPleine())
tab[firstFree++] = data;
}

/********************************************/

/*
* Retourne une representation de la pile au format chaine de caracteres.
*/

public String toString()

{
String res = "[";
for (int i = 0; i < firstFree; i++)
res += " " + tab[i];
return res + " ]";
}

/********************************************/

/*
* Teste le fonctionnement de la pile.
*/

public static void main(String[] args)

{
Pile p = new Pile(30);
int i = 0;
while (!p.estPleine())
p.empile(i++);
System.out.println(p);
while (!p.estVide())
{
System.out.println(p.sommet());
p.depile();
}
 }
}

Solution
import java.util.ArrayList;

public class PileObjets

{
/*
* Liste contenant les elements de la pile.
*/

private ArrayList<Object> array;

/*
* Constructeur
*/

PileObjets()
{
array = new ArrayList<>();
}

/*
* Retourne vrai si et seulement si la pile est vide
*/

public boolean estVide()

{
return array.isEmpty();
}

/*
* Retourne l'element se trouvant au sommet de la pile, -1 si la pile est
* vide.
*/

public Object sommet()

{
if (!estVide())
return array.get(array.size() - 1);
return -1;
}

/*
* Supprime l'element se trouvant au sommet de la pile, ne fait rien si la
* pile est vide.
*/

public void depile()

{
 if (!estVide())
array.remove(array.size() - 1);
}

/*
* Ajoute data en haut de la pile, ne fait rien si la pile est pleine.
*/

public void empile(Object data)

{
array.add(data);
}

/*
* Retourne une representation de la pile au format chaine de caracteres.
*/

@Override
public String toString()
{
return array.toString();
}

/*
* Teste le fonctionnement de la pile.
*/

public static void main(String[] args)

{
int nb = 20;
PileObjets p = new PileObjets();
int i = 1;
while (i <= 20)
p.empile(new Integer(i++));
System.out.println(p);
while (!p.estVide())
{
System.out.println(p.sommet());
p.depile();
}
}
}

Exercice : Redéfinition de méthode

Reprenez les classes Point et Cercle, codez une méthode toString() pour les deux classes
(mère et fille). Vous prendrez soin d’éviter les redondances dans votre code.

public class Point

{
private double abs, ord;

Point(double abs, double ord)

 {
this.abs = abs;
this.ord = ord;
}

public double getAbs()

{
return abs;
}

public double getOrd()

{
return ord;
}

public void setAbs(double abs)

{
this.abs = abs;
}

public void setOrd(double ord)

{
this.ord = ord;
}

// exercice 4

@Override
public String toString()
{
return "(abs = " + abs + " ; ord = " + ord + ")";
}
}

public class Cercle extends Point

{
private double rayon = 0;

public Cercle(double abs, double ord, double rayon)

{
super(abs, ord);
setRayon(rayon);
}

public Cercle(Point centre, double rayon)

{
this(centre.getAbs(), centre.getOrd(), rayon);
}

public double getRayon()

{
return rayon;
}

public void setRayon(double rayon)

 {
if (rayon > 0)
this.rayon = rayon;
}

// exercice 4

@Override
public String toString()
{
return "( centre = " + super.toString() +
"; rayon = " + getRayon() + ")";
}

Exercice : Interface
Complétez ce code source, sachant qu’un chien dit "Ouaf !", un chat "Miaou !" et une vache
"Meuh !".

import java.util.ArrayList;
@SuppressWarnings("unused")

interface Animal
{
// Setter pour le champ nom
public void setNom(String nom);

// Getter pour le champ nom

public String getNom();

// Retourne le cri de l'animal

public String cri();
}

//TODO Décommentez le code ci-dessous pour le compléter

public class ExempleAnimaux

{
// public static void main(String[] args)
// {
// ArrayList<Animal> animaux = new ArrayList<>();
// animaux.add(new Chat("Ronron"));
// animaux.add(new Chien("Médor"));
// animaux.add(new Vache("Huguette"));
// for (Animal animal : animaux)
// System.out.println("Je m'appelle " + animal.getNom()
// + " et je dis " + animal.cri() + "!");
// }
}

//class Chat implements Animal

//{
//}
//
//class Chien implements Animal
//{
//}
//
//class Vache implements Animal
//{
//}

import java.util.ArrayList;

interface Animal
{
// Getter pour le champ nom
public void setNom(String nom);

// Setter pour le champ nom

public String getNom();

// Affiche le cri de l'animal

public String cri();
}

public class ExempleAnimaux

{
public static void main(String[] args)
{
ArrayList<Animal> animaux = new ArrayList<>();
animaux.add(new Chat("Ronron"));
animaux.add(new Chien("MÃ ©dor"));
animaux.add(new Vache("Huguette"));
for (Animal animal : animaux)
System.out.println(animal.cri());
}
}
class Chat implements Animal
{
private String nom;

public Chat(String nom)

{
this.nom = nom;
}

@Override
public void setNom(String nom)
{
this.nom = nom;
}

@Override
public String getNom()
{
return nom;
}

@Override
public String cri()
{
return "Miaou !";
}

class Vache implements Animal

{
private String nom;

public Vache(String nom)

{
this.nom = nom;
}

@Override
public void setNom(String nom)
{
this.nom = nom;
}

@Override
public String getNom()
{
return nom;
}

@Override
public String cri()
{
return "Meuh !";
}
}

class Chien implements Animal

{
private String nom;

public Chien(String nom)

{
this.nom = nom;
}

@Override
public void setNom(String nom)
{
this.nom = nom;
}

@Override
public String getNom()
{
return nom;
}

@Override
public String cri()
{
return "Waf !";
}

Exercice : Exception
Exercice : Exception
Exercice : Exception
Calculez l’âge de l’utilisateur en fonction de son année de naissance. Vous ferez le calcul dans
une fonction qui déclencher à une exception si l’année de naissance n’est pas dans le passé.

import java.io.IOException;
import java.time.LocalDate;
import commandLineMenus.rendering.examples.util.InOut;

class AnneeInvalideException extends Exception

{
@Override
public String toString()
{
return "L'année ne peut pas être dans le futur";
}
}

public class Age

{
public static int calculeAge(int annee) throws AnneeInvalideException
{
int maintenant = LocalDate.now().getYear();
if (annee > maintenant)
 throw new AnneeInvalideException();
return maintenant - annee;
}

public static boolean afficheAge()

{
try
{
System.out.println("Quelle est ton année de naissance ? ");
int annee = InOut.getInt();
System.out.println("Tu as " + calculeAge(annee) + " ans.");
return true;
}
catch (AnneeInvalideException e)
{
System.out.println(e);
}
catch (IOException | NumberFormatException e)
{
System.out.println("Merci de saisir un nombre.");
}
return false;
}

public static void main(String[] args)

{
while(!afficheAge());
}