• Objet : les trois piliers de la programmation orienté objet : encapsulation, héritage, polymorphisme
• Niveau requis :

  avisé
• Commentaires : Créer une classe objet, contenant des objets

public class Lire
{
	// Par défaut, la bibliothèque ne lit que les premiers caractères de chaque ligne
    private static boolean filtre = true;
 
 
	// Filtre :
	//  si leFiltre = vrai, seul le premier caractère de chaque ligne
	//  sera lu par la fonction Lire.c() (appel automatique de la fonction Purge)
	// sinon tous les caractères sont lus, y compris les caractères de contrôle 
    public static void Filtre ( boolean leFiltre)
    {
       filtre = leFiltre;
    }   
 
	// Purge : élimine tous les caractères jusqu'à la fin de la ligne
    public static void Purge()
    {      
		try 
		{
			char car ;	// car qui sert de  poubelle
			do
			{
                car = (char) System.in.read ();
			}
			while (car != '\n');
		}	
     	catch (java.io.IOException e)
		{
			System.out.println ("Erreur de saisie");
			System.exit (0);
		}	
    }   
 
	// Lecture d'une chaine terminée par un "RETURN" : saute la fin de ligne
	public static String Chaine()
	{
		char car ;
		String result = "";
 
		try 
		{
			car = (char) System.in.read ();
	        //lecture de la ligne jusqu'au retour charriot (13, 0xD)
 
			// pour unix/linux et windows
			while (car != '\r' && car != '\n')	
			{
				result = result + car;
				car = (char) System.in.read ();
			}
 
            // Saut du fin de ligne (10, 0xA)
			if ( car != '\n')
			System.in.skip (1);// skip = sauter ; 	//"System.in.skip (1)" => idem que la fonction "purge"	
		}
		catch (java.io.IOException e)
		{
			System.out.println ("Erreur de saisie");
			System.exit (0);
		}
		return result;
	}
 
//------------------------- OVERLOAD n°1 de Chaine ------------------------------
	public static String Chaine(String message)
	{
		char car ;
		String result = "";
 
		try 
		{
			System.out.print(message); 
			car = (char) System.in.read ();
	        //lecture de la ligne jusqu'au retour charriot (13, 0xD)
			while (car != '\r')	
			{
				result = result + car;
				car = (char) System.in.read ();
			}
 
            // Saut du fin de ligne (10, 0xA)
			System.in.skip (1);				
		}
		catch (java.io.IOException e)
		{
			System.out.println ("Erreur de saisie");
			// System.exit (0);
		}
		return result;
	}
 
	// Lecture d'un caractère : uniquement le premier caractère de la nouvelle ligne
	//  si filtrage, n'importe quel caractère sinon
	public static char Caractere ()
	{
		char result = 0;
 
		try 
		{
			result = (char) System.in.read ();	       
		}
 
		catch (java.io.IOException e)
		{
			System.out.println ("Erreur de saisie");
			System.exit (0);
		}
 
        if (filtre)
		{
			Purge ();
		}
 
		return result;
	}
 
	public static int Entier ()
	{		
		int result = 0;
 
        try
		{
			result = Integer.parseInt ( Chaine () );						  
        }
 
		catch (NumberFormatException e)
		{
			System.out.println ("Format entier incorrect !");
            System.exit(0);				
		}
 
		return result;
	}
 
	public static short EntierCourt ()
	{
		short  result = 0;
 
		try
		{
			result = Short.parseShort ( Chaine () );			
		}			
 
		catch (NumberFormatException e)
		{
			System.out.println ("Format entier incorrect !");	
            System.exit(0);				
		}
 
		return result;
	}
 
	public static long EntierLong ()
	{
		long result = 0;
 
		try
		{		  
			result = Long.parseLong ( Chaine () );			
		}			
 
		catch (NumberFormatException e)
		{
			System.out.println ("Format entier incorrect !");				
            System.exit(0);	
		}		
 
		return result;
	}
 
	public static float Reel ()
	{		
		float result = 0;
 
		try
		{
			result = Float.valueOf( Chaine() ).floatValue () ;						  
		}			
 
		catch (NumberFormatException e)
		{
			System.out.println ("Format reel incorrect!");				
            System.exit(0);	
		}		
 
		return result;
	}	
 
	public static double ReelDouble ()
	{		
		double result = 0;
 
		try
		{
			result = Double.valueOf( Chaine() ).doubleValue () ;						  
		}			
 
		catch (NumberFormatException e)
		{
			System.out.println ("Format reel incorrect!");				
            System.exit(0);	
		}		
 
		return result;
	}	
 
	// Attente : permet de visualiser les résultats avant la sortie
	//	de l'application. 
    public static void Attente()
    {
		System.out.println ();
        System.out.println ("*** Tapez Entree pour Terminer ***");
        Lire.c();
    }
 
	// Attente : permet de visualiser les résultats avant la suite
	//	de l'application. 
    public static void Suite()
    {
		System.out.println ();
        System.out.println ("*** Tapez Entree pour Continuer ***");
        Lire.c();
    }
 
	public static boolean Question(String msg)
    {
		char reponse ;
 
		do
		{	
	        System.out.print (msg + " (O/N ) ?" );			
			reponse = Lire.c();
		}while ((reponse!='O')&&(reponse!='o')&&(reponse!='n')&&(reponse!='N'));
		// arrêt quand reponse est égal à O,o,N,n
		return (reponse == 'O') || (reponse == 'o') ;
    }
 
// Alias des fonctions
 
 
	public static String S ()
	{
        return Chaine();
    }
 
	public static short s ()
	{
        return EntierCourt();
    }
 
	public static long l ()
	{
        return EntierLong();
    }
 
	public static int i ()
	{
        return Entier();
    }
 
	public static char c ()
	{
        return Caractere();
    }
 
    public static float f ()
	{
        return Reel ();
    }
 
	public static double d ()
	{
        return ReelDouble ();
    }
 
 
// Fonction qui lit un tableau de char et renvoi ce tableau
 
	   public static char[] remplirTableau(String invite, int motSize)
	   {
	       final int MOT_SIZE = motSize ;
	       final char TERMINATEUR = '.';
 
 
	       char mot[] ;
	       char actualCar ;
	       int count ;
	       count = 0 ;
 
	       mot = new char[MOT_SIZE] ;
		   System.out.println(invite);
 
		   Lire.Filtre(false);
			do 
	        {   
					actualCar = Lire.c();
					mot[count] = actualCar ;
					count ++ ;	
 
	        }
	        while(actualCar != '\r' && actualCar != '\n' && actualCar != TERMINATEUR && count < mot.length) ;
 
			if(actualCar != TERMINATEUR)
			{
 
				mot[count - 1] = TERMINATEUR ;
 
			}
			if(actualCar != '\n')
			{
 
				Lire.Purge();
 
			}
			Lire.Filtre(true);
 
			return mot;
 
 
		/* Fonction qui lit un tableau de char sans terminateur et renvoi ce tableau */	
		public static char[] remplirMot(String invite)
		// invite est la chaine affichée à l'écran avant la saisie
		// le tableau retourné est le mot saisi, et sa longueur est la longueur du mot.
	   {
	       char mot[] ;
	       char actualCar ;
	       int count ;
	       count = 0 ;
		   mot = new char[80];
		   System.out.println(invite);
 
		   Lire.Filtre(false);
		   actualCar = Lire.c();
		   while (actualCar != '\r' && actualCar != '\n' && count < mot.length) 
		   {   
					mot[count] = actualCar ;
					count ++ ;
					actualCar = Lire.c();
 
	        }
 
			if(actualCar != '\n')
			{
 
				Lire.Purge();
 
			}
			Lire.Filtre(true);
 
			char [] newMot= new char[count];
			for (int i =0; i<count;i++)
			{
				newMot[i] = mot[i];
			}
			return newMot;
 
	   }
		public static void afficheMot(char[] mot)
		{
			for (int i = 0; i< mot.length; i++)
			{
				System.out.print(mot[i]);
			}
		}
		public static void afficheTableau(char[] mot)
		{
			int i;
			for (i = 0; i< mot.length && mot[i] != '.'; i++)
			{
				System.out.print(mot[i]);
			}
			System.out.print(mot[i]);
		}
}

public class BoiteAOutil
{
	/***
	 * fonction booleanne test entree alphanumerique
	 * @param entree chaine entree
	 * @return vrai
	 */
	public static boolean estAlpha(String entree)
	{
 
 
			if(entree != null && !entree.trim().isEmpty() && entree.matches("^[\\p{L} ]+$"))
					{
						return true;
					}
			else {
				return false;
			}
 
 
 
	}
 
	public static boolean isInteger(String  entree)
	{
 
 
			if(entree != null && !entree.trim().isEmpty() && entree.matches("[0-9]"))
					{
						return true;
					}
			else {
				return false;
			}
 
 
 
	}
 
	/***
	 * fonction booleanne test entree numerique avec 3 chiffres
	 * @param entree
	 * @return vrai
	 */
	public static boolean isEntierNumeroRue(String  entree)
	{
 
 
			if(entree != null && !entree.trim().isEmpty() && entree.matches("[0-9]{3}"))
					{
						return true;
					}
			else {
				return false;
			}
 
 
 
	}
 
	/***
	 * fonction booleanne test entree numerique avec 5 chiffres pour le code postale
	 * @param entree
	 * @return vrai
	 */
 
	public static boolean isEntierCodePostal(String  entree)
	{
 
 
			if(entree != null && !entree.trim().isEmpty() && entree.matches("[0-9]{5}"))
					{
						return true;
					}
			else {
				return false;
			}
 
 
 
	}
 
 
	public static boolean isFloat(String entree)
	{
 
 
			if(entree != null && !entree.trim().isEmpty() && entree.matches("^([+-]?\\d*\\.?\\d*)$"))
					{
						return true;
					}
			else 
			{
				return false;
			}
 
 
 
	}
 
}

L'individu idéal ou primitif, tel que tout type d'individu instanciable en héritera les propriétés.

public abstract class Individu 
{
	private  String m_strNom;
	private  String m_strPrenom;
	private  Adresse m_adresse = new Adresse();
 
 
	//----------------------------------------  CONSTRUCTEUR  ------------------------------------------------
 
 
	/**	
	 * 
	 * @param strNom
	 * @param strPrenom
	 * @param adresse
	 */
	public Individu (String strNom, String strPrenom, Adresse adresse)
	{
		// si les valeurs données ne satisfont pas les "set", alors valeur par défaut :
		if (!setNom( strNom)) 		setNom("mon nom est personne");
		if (!setPrenom( strPrenom)) setPrenom("mon prénom est personne");
		if (adresse == null)
		{
			m_adresse = new Adresse();
		}
		else
		{
			m_adresse = adresse;
		}
	}
 
 
 
	//-------------------------------------- CONSTRUCTEUR PAR DEFAUT -----------------------------------------
 
 
	public Individu ()
	{		
		this("mon nom est personne", "mon prénom est personne,", new Adresse());
	}	
 
	//-----------------------------------  ENCAPSULATION DES PROPRIETES DE L'OBJET ---------------------------
 
	/**	Affecte (si possible) la chaîne donnée à la propriété m_strNom.
	 * 
	 * @param nomSaisi : Chaîne à affecter (doit être alphabétique, plus : espace, tiret, apostrophe).
	 * @return	VRAI si affectation possible.
	 */
 
 
	public boolean setNom(String nomSaisi)
	{
		boolean oK = false;
 
		if (OutilsTests.estAlphaPlus(nomSaisi))
		{
			oK = true;
			m_strNom = nomSaisi.trim();
		}		
 
		return oK;
	}
	//------------------------------------------------------------
	/** Affecte (si possible) la chaîne donnée à la propriété m_strPrenom.
	 * 
	 * @param prenomSaisi : Chaîne à affecter (doit être alphabétique, plus : espace, tiret, apostrophe).
	 * @return VRAI si affectation possible.
	 */
	public boolean setPrenom(String prenomSaisi)
	{
		boolean oK = false;
 
		if (OutilsTests.estAlphaPlus(prenomSaisi))
		{
			oK = true;
			m_strPrenom = prenomSaisi.trim();
		}		
 
		return oK;
 
	}
	//------------------------------------------------------------
	/** Affecte (si possible) la chaîne donnée à la propriété m_adresse.
	 * 
	 * @param adresseSaisie : Chaîne à affecter (voir contrainte de la class Adresse).
	 * @return VRAI si affectation possible.
	 */
	public boolean setAdresse(String adresseSaisie)
	{
		return (m_adresse.setStructAdresse(adresseSaisie));
	}
	//------------------------------------------------------------
	/**	Récupère la propriété m_strNom.
	 * 
	 * @return	 Contenu de m_strNom.
	 */
	public String getNom()
	{		
		return m_strNom;
	}
	//------------------------------------------------------------
	/**	Récupère la propriété m_strPrenom.
	 * 
	 * @return	 Contenu de m_strPrenom.
	 */
	public String getPrenom()
	{		
		return m_strPrenom;
	}
	//------------------------------------------------------------
	/**	Récupère la propriété m_adresse.
	 * 
	 * @return	 Contenu de m_adresse.
	 */
	public String getAdresse()
	{		
		return m_adresse.toString();
	}
	//------------------------------------------------------------
	/**	Acquisition des propriétés de l'individu.
	 * 
	 */
	public void lire()
	{
		String  saisie, invite;
 
		// Acquisition du nom :
			invite = "Donnez un nom  : ";
			do
			{
				saisie = Lire.Chaine(invite);	
 
 
			} while (!(this.setNom(saisie)));	// Arrêt quand la saisie est correcte
 
		// Acquisition du prénom :
			invite = "Donnez un prénom : ";
			do
			{
				saisie = Lire.Chaine(invite);	
 
 
			} while (!(this.setPrenom(saisie)));	// Arrêt quand la saisie est correcte
 
 
		// Acquisition de l'adresse : remarque ! L'adresse se lit elle-même tout comme l'individu se lit lui-même
			m_adresse.lire();  
 
	}
 
 
	//------------------------------------------------------------
	/**	Afficher les propriétés de l'individu.
	 * 
	 */
	public void afficher()
	{
		System.out.println(this.getPrenom() + " " + this.getNom());
		System.out.println(this.getAdresse());		
	}
}