Java

Préparationde l' examen

Comment repérer une classe ?
Une classe commence toujours par une majuscule:

Dans notre exemple, il s' agit de la classe

Histo

Il existe également  des classes déjà définis dans Java: // Liste des classes Math.random //classe Math System.out.print(i+":") //classe System Il y a aussi les classes: Object,  Math

Comment repérer une méthode ?
Une méthode commence toujours par une minuscule et se etrmine par des parenthèses. Par exemple:

afficheNotes

Méthode d'instance
Une méthode s'utilise comme suit: // objet. methode : il s' agit d'une méthode d'instance hist1. afficheNotes Il existe également  des méthodes prédéfinis dans Java: toString

Méthode de classe
Mais il y a d'autres cas de figure, par exemple : // Classe.methode : il s' agit d'une méthode statique Math.random La particularité d'une méthode de Classe c'est qu'elle est propre à la classe. Par exemple:

chien.crier //(aboie) et lion.crier //(rugir) cheval.crier //(hennir) // n' est pas une méthode de classe,elle donne des résultats distincts mais : cheval.nombresAnimaux;Animal.nombresAnimaux//caractérise la classe on peut aussi utiliser

Surcharge d' une méthode: le polymorphisme
C'est lorsque l' on souhaite donner le même nom de méthode mais avec une signature distincte

Exemple:  la classe additionner

Si l' on souhaite définir l' addition ( par exemple pour les vecteurs et  les matrices). Bien que les objets ne soient pas identiques, l' analogie de cette opération  nous améne à souhaiter donner le même nom de méthode. :

additionner //par exemple ).

Afin que Java fasse bien la différence, la signature n' est pas la même: additioner(matrice m1,matrice m2) // même nom de méthode additioner(vecteur v1,vecteur v2) // pas les mêmes arguments d' entrée


 * même nom de méthode mais arguments distincts (pas la même signature)

mais avec un argument

Redéfinition des méthodes: dans le cadre de l' héritage
Hériter d'une classe c'est posséder toutes ses propriétés: ses variables d' instances et ses méthodes.

Ainsi une classe fille (par exemple Lion) hérite des propriétés de  ses classes mères (donc de Carnivore (sa classe mère directe) et de Animal )
 * Animal: superclasse
 * Lion:sous classe de Carnivore
 * Carnivore classe mère de Lion

Définir une sous classe
On le fait grâce au mot clé extends: public class Carnivore extends Animal { // Corps de la classe }

En Java, toute classe qui n'étend pas une autre en utilisant le mot réservé extends étend implicitement la classe Object (qui se trouve dans le package java.lang). Ainsi, toutes les classes Java ont comme premier ancêtre la classe Object. Ainsi on aurait du mettre : class Animal extends Object{ //... }

La classe toString: cette méthode permet d'obtenir une représentation de l'objet sous forme d'une chaine de caractère Lorsque l' on redéfinit une méthode on doit conserver la signature de la méthode originel (dans le cas de toString: public string toString donc public, type de retour string, sans paramètres)

Si l' on écris System.out.println(m1)  sans utiliser de méthode après l' objet, Java va automatiquement effectuer la méthode toString définis dans Java Dans le cas ou l' on écris :

System.out.println(new Chien("milou") // System.out.println(m1) // ou m1 représente un objet

Utiliser les méthodes/variables d'instances héritées
A l'aide du mot-clé super, il est possible de manipuler les variables d' instance  et les méthodes de la superclasse.

Dans le cas d'une méthode de classe redéfinie:

Cette nouvelle méthode doit posséder non seulement le même nom que la méthode de la classe ascendante, mais également la même signature (même nombre d’arguments et même types) et le même type de valeur de retour. De plus, contrairement à la surcharge, la redéfinition ne concerne pas les constructeurs.

Mot clé static
Ce mot clé est utilisé lorsque les variables ou méthodes static sont propres à la classse et non à un objet en particulier. l' on considère des mthodes de classe (donc qui concerne toute la classe)

Pour les variables Pour les mthodes :
 * cpt: compteur qui est incrémenté dans le constructeur
 * variables au pluriel:
 * getCpt

Mot clé pulic /private /protected
Ici c'est pou définir les droits des utilisateurs

public: tout le monde peut avoir accès aux variables d'instances sans recourir aux accesseurs et les modifiés sans recourir aux modifieurs

private:

protected: dans le cas d' héritage c'est le mot clé qui permet aux classes filles de réutiliser les méthodess et variables d'instnce de la classe mère

Mot clé final
Lorsque l' on veut définir une constante que personne ne peut modifier on met ce mot clé.

Mot clé abstract
Il peut arriver qu'on veuille empécher la création d'objets, ou l'utilisation d'une méthode dans

Quand une méthode est déclarée abstract alors la classe est elle aussi déclarée abstract. On ne peut instancier une classe déclarée abstract (on ne peut créer d'objet).

Encapsulation
En POO, on réalise une "encapsulation des données": c'est à dire que'il n' est pas possible d' agir directement sur les données d'un objet,lorsque celles ci sont déclarées private. Il est nécessaire de passer par ses méthodes (par exemple les accesseurs/modifieurs). il est généralement souhaitable que les utilisateurs de la classe se servent de celle-ci de la manière de laquelle le concepteur a prévu qu'elle le soit.

Le concept d'accessibilité (généralement appelé encapsulation) définit donc la possibilité qu'a le concepteur d'une classe de restreindre l'accès à certaines données, ou plus généralement à certains éléments (méthodes, classes, ...).il est généralement souhaitable que les utilisateurs de la classe se servent de celle-ci de la manière de laquelle le concepteur a prévu qu'elle le soit.

Java définit quatre niveaux d'accès pour les variables d'instances (données membres) et les méthodes :


 * public : un élément public est accessible de partout et sans aucune restriction. Certaines classes (comme la classe principale main) doivent obligatoirement être déclarées publiques (pour pouvoir exécuter l'application...)
 * protected : un élément protected (protégé) est accessible uniquement aux classes d'un package et à ses classes filles
 * private : un élément private (privé) est accessible uniquement au sein de la classe dans laquelle il est déclaré (il n'est même pas accessible par ses classes filles). Ces éléments ne peuvent être manipulés qu'à l'aide de méthode spécifiques I les accesseurs/modifieurs
 * "friendly" : un élément est friendly par défaut (lorsque rien n' est spécifié :class Mouton...) est accessible uniquement aux classes d'un package et à ses classes filles.

Rmq on pourraient les mettres en public mais ca poserait de nombreux qoucis, car "tout le monsde pourrait les modifier" public class Animal { //public heureusement car on veut pouvoir ultérieurementvréutiliser cette classe private String nom ;// Les variables d'instances sont quasiment toujours private, si dans une autre classe (TestAnimal par exemple) on crée un Animal: Animal a = new Animal (zebre) et que l'on écris a.nom=cheval, on aura une erreur à la compilation car c'est private. //On ne veut pas que nom soit modifier même par les classes filles, une fois passé au constructeur le nom de l' animal ne peut être modifié protected int taille; Ici heureusement que c'est protected sinon on ne pourrait le réutiliser dans les classes filles public Animal (String nom){ //les constructeurs sont toujs public, heureusementsinon on ne pourrait rien créer comme objet this.nom=nom; }    public String toString{ //public car pour une redéfinition on utilise la même signatureon doit return ( nom +"taille"+taille); //le rôlr de la méthode to String est de retourner  une chaine de caractère (sortie)ne l' affiche pason } } public class Mouton

Types simples /primitifs
On les distingues des objets, puisqu'il s' agit de : int,double, float,char,... Ce sont les nombres entiers, les nombres flottants, les caractè

Déclaration d'un tableau
Exemple 1: double [] td; // Déclaration d'un tableau de double à une dimension On remarque que la taille du tableau n' est pas vraiment définis, on sait qu'il a une dimension, mais on ne sait pas combien de cases le définissent.

Création  d'un tableau
Création de l' objet  tableau puis(int i=0;i<5;i++
 * En deux temps,

Initialisation des cases du tableau

On crée un tableau comme on crée un objet (opérateur new) :

td=new double[3]; // Définition de la taille du tableau td[0]=4.2;td[1]=4.2;td[2]=4.2;// Initialisation des valeurs du tableauu

La première instruction alloue l' emplacement mémoire nécessaire à un tableau de 3 éléments de type double.Les 3 éléments sont initialisés par défault à 0.

La seconde ligne réinitialise les données (on remarque qu'un tableau commence au rang 0)

Déclarationet & création d'un tableau
int [][]pascal

On peut le faire en une fois: double [] td={4.2,8.3,2.9}; double [] td=new double[]{4.2,8.3,2.9};; Attention: double [] td; td={4.2,8.3,2.9}; // Erreur, l'initialisation des valeurs dutableau avec {} ne peut se faire qu'en même temps que la déclaration du tableau

double td =new double[3]{4.2,8.3,2.9} []

Attention si l'on affecte trop de valeurs à un tableau, dont la dimension a déjà été fixée, il y a déclenchement d'une exception ArrayInexOutBoundsException. Ca passe à la compilation mais pas à l' execution

Si l' excetion n' est pas interceptée/capturée, il y a arrêt de l' execution du programme et un message d 'erreur informantsu (ArrayInexOutBoundsException)

Pour avoir la taille on fait

td.lengthTableaux de types primitifs ou tableaux d'objets

Exceptions
Par exemple, considérons une classe Point,munie d'un contrucyeur (à deux arguments) et d'une méthode affiche. Supposons que l' on ne souhaite manipuler que des points à coordonnés positives (non négatives). Nous poiuvons donc vérifier au sein du constructeur la validité des paramètres fournis
 * Données saisies par l' utulisateur incorrectes: imaginons que l' on souhaite que les utilisateurs du programme utilisent le programme comme on l' a prévu pour.

Nous pouvons: Créer une classe Exception class Errconst extends Exception { } // Création (un peub artificielle) d'une classe Lever une exception throw new
 * Déclencher  (lancer/lever) une exception à l' aide du mot clé throw
 * Créer une classe dérivée (qui hérite) de la classe Exception
 * Déléguer une Exception à l'aide du mot clé throws


 * Rencontre d'une fin de Tazbleau prématurée

Variables d'instances
Dans un programme il faut les Lors de la déclaration on  donne le type puis le nom de la variable.
 * déclarer: int n;
 * initialiser: n=15;

Attention :

Dans le main, une variable pas initialisé provoque une erreur à la compilation: // Dans le main int n; System.out.println("n="+n);// Erreur de compilation: car la valeur de n n'est pas définie ici En revanche les champs des objets sont implicitements initialisés par défault: Par exemple:
 * à 0 pour les nombres
 * à null pour les objets

Priorité des types simples
Conversions légales double>float>long>int>short>byte // double>float>long>int>char String>double>float>long>int>char / Conversion illégales:Cast

int n,p; (double)(n/p);// Conversion (int)(Math.random*3)// Convertit en entier

Cast/Transtypage
public class MesAnimaux { //Classe private Animal [] animaux = new Animal [5]; private int indiceSuivant = 0; public void add ( Animal a ) { ... } //  public Animal get ( int i ) { return animaux [ i ]; } } public TestMesAnimaux { public static void main ( String [] args ) { MesAnimaux list = new MesAnimaux ; Chien c = new Chien ; list. add ( c ); c = list. get (0); // ne fonctionne pas } }                  Pourquoi cela ne fonctionne pas ?

Constructeur
C'est une méthode  particulière qui crée un objet et initialise ses variables d'instances. Il est appelé lors d'un new.

Sa signature impose: public class AdresseWeb { private String protocole;// Variables d'instance private String domaine; private String chemin; public AdresseWeb (String protocole,  String domaine, String chemin){ // 1er constructeur this.protocole=protocole; //Les paramètres du constructeur ont le même nom que les variables d'instances donc this.domaine=domaine; // donc on utilise le mot this qui permet de spécifier à java que l' on fait référence à l' objet courant this.chemin=chemin; }    public AdresseWeb (String domaine, String chemin){ //surcharge de constructeur (donc  pas la même signature) this("http",domaine,chemin); //appel du constructeur précédent }    public AdresseWeb (String domaine){ this(domaine,""); // appel au second constructeur }    public String toString{ //Redéfinition de la méthode toString héritée de la classe Object return(protocole+"://www."+domaine+chemin); } } Java créé automatiquemet un constructeur par défault
 * même nom que la classe, (avec une majuscule par conséquent c'est la seule,méthode avec une majuscule)
 * pas de type de retpur (pas même void)
 * this doit être la première instruction dans un constructeur

a3=null; détruit l'  objet car il n' a plus de handle (ramasse miette)

Classe abstraite
Nous savons que nous pouvons écrire :

Loup unLoup = new Loup ;// //Ainsi que : Animal unLoup = new Loup ;

Mais que peut bien signier l'instruction suivante :

Animal a = new Animal ; // Quelles sont les valeurs des variables d'instance ? //Quel sont les caractéristique de a: son pelage, sa couleur sa taille, // si nous ne somme pas avec un animal spévcifique on ne peut rien dire

La classe Animal est indispensable pour les besoins de l'héritage (permet de regrouper les objets analogues, notion de concept ), mais cela n'a pas de sens de créer des objets Animal. Il faut donc empêcher l'instanciation de la classe Animal. Pour cela il suffitt de déclarer la classe Animal abstract.:

public abstract class Animal { ... }

Dès lors le compilateur interdira de créer une instance de ce type. Il reste cependant possible d'utiliser des classes abstraites comme superclasse ou avec le polymorphisme.

Une classe abstraite ne sert à rien à moins d'être étendue !

Par ailleurs autre chose est intéressant, c'est la possibilité de déclarer les méthodes:

public abstract class Astre { //On peut peut trouver classiquement des méthodes et des champs dont toutes les classes dérivées hériteront protected String nom; private static int nbAstres=0;//variable statique donnant le nombre d' astres créés depuis le début //Constructeur, même si l'on s' attend a ce qu'il n' yen ai pas du fait de l' interdiction de l' instantiation de cette classe les besoins de l' héritage le necessitent public Astre(String nom) { nbAstres++;    // A chaque création d'un Astre particulier (voir classes dérivées) il y a incrmentation du compteur this.nom=nom; }       public Astre(int numAstre) { // On remarque que le num n' est pas déclarée comme variable d'instance this("A"+numAstre); //Appel au premier constructeur } // methode abstract:  On se dispense de préciser le corp de la   méthode (qui le sera ulterieurement dans une classe concrète), on ne spécifieque la signature public abstract void info; //Methode toString public String toString { return this.nom; }        //accesseurs public static int getNbAstres{ return(nbAstres); } }


 * mot clé abstract
 * pas d'instanciation possible
 * s'utilisent dans le contexte de l' héritage.
 * peut contenir/ou pas, des méthodes abstraites. Dans ce dernier cas la classe est automatiquement abstraite

public abstract public abstract class Figure{ // Pas de constructeur puisqu'il s' agit d'une classe abstraite donc pas d'instanciation possible public abstract double surface; // On se dispense de préciser le corp de la méthode //seule la signature de la meth.abstraite est présente public String toString{ // redéfinition de la méthode toString return "Je suis une figure"; } } Dans une classe abstraite (utiliser en contexte héritage), on peut trouver classiquement des méthodes et des champs dont toutes les classes dérivées hériteront
 * Une méthode abstraite doit être déclarée public, logique puisque sa vocation est d'être redéfinie dans une classe dérivée

Methodologie

 * Création de la classe mère
 * public [abstract] class  Mere
 * private(public,protected) [static] Type(Object,String, boolean,double,...) champ1 ; //Définition des champs
 * public Mere (Type paramètre1 ,...)
 * public Mere (Type paramètre1 ,...)



Héritage
public class Poules {

Lexique

 * Variables d' instance= champs, données, données membres,


 * Paramètres de méthode; //dans les de la signature d'une méthode


 * Variables locales à une méthode
 * Heritage, classe dérivée

Couleurs utilisée

 * Classe
 * methode


 * static
 * final