Embed Size (px)
Citation preview
2
Introduction
- Java est un langage de programmation orientée objet (POO)
- Un programme Java est une série de classes
- Chaque Classe contient un ensemble de déclaration et de méthodes
- Que contient une méthode* en-tête* corps
3
Structure d'un programme Java
- Tout programme Java commence par une méthode particulière :
public static void main(String[] args) {// instructions
}- Les types primitifs en Java :
4
Un premier exemple
Comment résoudre (afficher les solutions de) l'équation du second degré :
– avec une approche traditionnelle (langage impératif ou fonctionnel) ;– avec une approche objet.
Remarque : On se limite au cas général d’une équation avec deux racines réelles.
5
1 class EquationTraditionnelle {2 public static void main (String[] args) {3 double a, b, c; // coefficients de l’équation45 // Initialiser les coefficients6 a = 1;7 b = 5;8 c = 6;910 // Calculer le discriminant11 double delta = (b * b - 4 * a * c);1213 // Calculer les racines (sans contrôle de cohérence)14 double x1 = (-b + Math.sqrt(delta)) / 2 / a;15 double x2 = (-b - Math.sqrt(delta)) / 2 / a;1617 // Afficher les résultats18 System.out.println("Racine 1 : " + x1);19 System.out.println("Racine 2 : " + x2);20 }21 }
Approche classique
6
Approche objet
Principe : Pour pouvoir penser une solution informatique, il faut substituer à la notion de PROGRAMME la notion d’ORGANISME, ensemble d’objets pouvant communiquer entre eux.
« Les systèmes logiciels sont caractérisés au premier chef par les objets qu’ils manipulent, non pas par la fonction qu’ils assurent. Ne demandez pas CE QUE FAIT LE SYSTÈME. Demandez À QUI IL LE FAIT ! »
O2O3
O1 O4O5
Membres d'un objet:
* des champs qui définissent ses données
* des méthodes qui manipule les données
7
Un objet (le bien) évolue dans un monde cerné par le mal (les autres)Cependant, il doit faire du commerce avec les autres.Un objet protège son intégrité des autres objets, il n'expose que des fonctionnalités.
Approche objet
Données de l'objet
Fonctionnalité
Objet
questionréponse
Le mal
class Point { void translate(int dx,int dy) { x+=dx; y+=dy; } int x; int y;}
class AutreClass { void autreMethod(Point p) { System.out.println(p.x); System.out.println(p.x); p.translate(2,3); }}
a b
mb.m(arg1)
8
1 /** Modélisation d'une équation du second degré et de sa résolution.2 * @author Xavier Crégut3 * @version 1.34 */5 class Équation {67 /** Coefficients de l’équation */8 double coeffA, coeffB, coeffC;910 /** Solutions de l’équation */11 double x1, x2;1213 /** Déterminer les racines de l’équation du second degré. */14 void résoudre() {15 double delta = // variable locale à la méthode résoudre16 this.coeffB * this.coeffB - 4 * this.coeffA * this.coeffC;17 this.x1 = (- this.coeffB + Math.sqrt(delta)) / 2 / this.coeffA;18 this.x2 = (- this.coeffB - Math.sqrt(delta)) / 2 / this.coeffA;19 }20 }
Approche objet
9
Une équation est caractérisée par ses coefficients, ses racines et le fait que la résoudre consiste à calculer ses racines en fonction de ses coefficients.On en déduit :– les attributs : l’état d’un objet Équation (les coefficients et les racines) ;– les méthodes : les « actions » qui peuvent être réalisées sur un objet detype Equation (résoudre l’équation).
Remarque : On ne s’intéresse qu’au cas général (deux solutions) del’équation du second degré à coefficients et valeurs dans les réels.
Approche objet
10
1 class ResolutionEquation {23 /** Résoudre une équation du second degré. */4 public static void main (String[] args) {5 Équation eq; // une poignée sur une Équation6 eq = new Équation(); // création d’un objet Équation78 // Initialiser les coefficients9 eq.coeffA = 1;10 eq.coeffB = 5;11 eq.coeffC = 6;1213 // Calculer les racines de l’équation14 eq.résoudre();1516 // Afficher les résultats17 System.out.println(" Racine 1 : " + eq.x1);18 System.out.println(" Racine 2 : " + eq.x2);19 }20 }
Approche objet
11
Définition d'une méthode
- La définition (ou déclaration) d'une méthode se compose d'un en-tête et d'un corps.
- L'en-tête permet de définir le type de retour, le nom et les paramètres de la méthode
* une liste de descripteurs de la méthode
- Le corps comprend les traitements que la méthode effectue* une liste d'instructions
- structureen-tête {
corps;}
12
En-tête d'une méthode
- Syntaxevisibilité nature type nom (type param, type param, ...)
- Elle se compose de* visibilité
• public, private...* nature
• static, final...* type de la valeur retournée par la méthode
• un type primitif (int, double, ...), un nom de classe ou void* le nom de la méthode
• un identificateur* la liste des paramètres
• une liste de variables précédées de leurs types
13
Corps d'une méthode
- Une séquence d'instructions décrivant un scénario de traitement
- Une instruction peut être* déclaration
* création d'objet
* affectation
* appel d‘une méthode
* structure de contrôle
* spéciale
14
Déclaration
- Une variable locale
- type variable = valeur;
- exemples* int n;* String s = "Alain";* double d = 2.3;* Personne p = new Personne();
Affectation
- Une manière de mettre une valeur dans une variable est l’affectation
- l’opération d’affectation est représentée par le symbole =
- Syntaxevariable = expression;
- Le type de la variable doit être compatible avec le type de l’expression
15
Exemple
16
Trouver les erreurs d'affectation
17
Exemple
18
Exemple d'affectation
19
Opérateurs
1. Arithmétiques s'appliquant aux valeurs numériques() , +, -, *, /, %
2. Logiques s'appliquant aux valeurs logiques(), &&, ||, !
3. De concaténation s'appliquant aux chaînes de caractères+
• Opérateurs binaires– >>, <<, &, |
20
Expressions
- Une expression sert à effectuer un calcul
- Une expression peut être* arithmétique* logique* de chaîne de caractère
21
Expression arithmétique simple
- Valeur littérale (ou constante)* c = 123;* f = 12.5;* n = 0;
- Variable ou appel de méthode* m = c; age = personne.getAge();
- Deux opérandes liés par un opérateur arithmétique. Un opérande peut être une constante ou une variable
f = 9 * c;n = 32 + 1;f = f / 2.0;
22
Expression arithmétique complexe
- Plusieurs expressions arithmétiques simples, éventuellement encadrées par des (), liées par des opérateurs arithmétiques
* f = (9*c)/5+32;* prod = (x+y)*(u-v);
* sompro = c1*n1+c2*n2+c3*n3;
23
Opérateurs arithmétiques et leurs priorités
24
Expression logique
-Une expression logique est constituée par des opérandes et des opérateurs logiques.
- Elle peut aussi être* simple ou* composée
25
Expression logique simple
- Valeur littérale (ou constante) fin = true; vide = false;a = vide; b = compte.getSuspendu();
- Deux expressions arithmétiques liées par un opérateur de comparaison
Exemples :- fin = c < 0;- trop = (a+b) > 3 ;- diff = x != y;
26
Expression logique complexe
- Plusieurs expressions logiques simples, éventuellement encadrées par des (), liées par des opérateurs logiques &&, ||, !
* inclus = (c>0) && (c<9);* arret = c==1 || fin ;
27
Opérateurs logiques
28
Exercices
1) Soit n un nombre entier. Écrire l'expression logique qui serait vraie quand n est– dans l'intervalle [0, a[– négatif– positif– dans l'intervalle [a, b[ ou ]c, d]
2) Soit n et m deux nombres entiers relatifs. Écrire l'expression (sans effectuer decalcul arithmétique) qui serait vraie quand le produit de n * m est positif
3) Soit C un caractère. Écrire une expression qui serait vraie quand C est– 'd', 'e', 'f'
29
Expression de chaîne de caractères
- On peut former une chaîne de caractères longue en concaténant plusieurs chaînes élémentaires
- Cela se fait avec l'opérateur de concaténation +* Chaîne nom;
* nom = LIRE (); //"Alain"
* salut = "Bonjour " + nom + " !"* Est équivalent à: salut = "Bonjour Alain !";
- Avec Java, on peut aussi concaténer des chaînes de caractères avec des valeurs numériques
* n = 10;* Parite = n + " est pair!"; //"10 est pair!"
30
Commentaires
- Texte explicatif ajouté au code
- Il est fortement recommandé d'ajouter des commentaires à tous les niveaux de vos algorithmes et programmes
- Tout texte suivant // et finissant à la fin de la ligne// commentaire jusqu'à la fin de la ligne
- Tout texte compris entre /* et */; peut composé de plusieurs lignes/* ligne 1ligne 2...ligne n*/
- Les commentaires ne font pas partie de l'algorithme, ils sont destinés au lecteur pour comprendre la logique de l'algorithme
- Il est fortement recommandé d'ajouter des commentaires à tous les niveaux de vos algorithmes et programmes
31
Appels de méthodes
- Les appels des méthodes (void ou non) peuvent être des instructions à part entière
- Méthodes d’objets* objet.méthode(paramètres)
- Méthode statiques* Classe.méthode(paramètres)
32
Structures de contrôle
- Alternatives- Itératives
Alternatives :- Dans certains cas, les instructions ne doivent pas toutes être exécutées en séquence.
* on doit choisir parmi deux ou plusieurs séquences
- Dans le cas d'un choix entre 2 séquences* on utilise la structure if (le contrôle se fait à l'aide du test d'une condition)
- Dans le cas d'un choix entre plusieurs séquences* on utilise la structure switch (la sélection se fait à l'aide d'une expression arithmétique)
33
Syntaxe de l'alternative : IF
- Une condition est une expression logique simple ou composée
34
Exercices
- Écrire un programme qui lit un nombre et calcule sa racine carrée en utilisant la méthode Math.sqrt().
- Écrire un programme qui lit deux entiers n et m et affiche le signe de leur produit sans effectuer de calcul
- Écrire un programme qui génère un caractère aléatoire et vérifie son type et affiche voyelle, consonne ou non alphabétique.
35
Exemple : l'algorithme de la racine carrée en JAVA
class Racine{public static void main ( String[] args ){
/*Entrée : un réel rSortie : le réel straitement : calcule et imprime la racine carrée s de r*/
System.out.println("Lit un réel et affiche sa racine carree");
System.out.println("Entrer un nombre réel (double) : ");
double d = Clavier.lireDouble();
if(d<0)
System.out.println("Nombre négatif, il n'a pas de racine carrée réelle");
else
System.out.println("Le racine carree de "+d+" est " + Math.sqrt(d));
}
}
36
Expression conditionnelle
- L'instructionv = (condition ? expression1 : expression2)
équivaut àif(condition)v = expression 1;elsev = expression 2;
Exemple :
boolean parite;int n;...parite = (n%2 == 0? true : false);String signe = (n>=0 ? "Positif" : "Négatif");
37
Exercices
- Écrire en java une application (une classe) qui* lit un entier* affiche la parité du nombre
- Écrire en java une application (une classe) qui* lit les coefficients, calcule et affiche les solutions de n'importe quelle équation de second degré.
38
Structure alternative switch
- L'instruction SI offre le choix entre deux séquences - L'instruction switch permet de choisir parmi plusieurs séquences en fonction de la valeur d'une expression arithmétique entière
Syntaxe :
switch (expression entière) {case valeur : //une ou plusieurs fois cas valeur:séquence ; //pas besoin de mettre entre {}break;...[default : séquence;]
}
- l'instruction break arrête l'exécution du bloc en cours (alternative ou boucle)
39
Exercices
Écrire le programme qui :- lit un entier ;- affiche l'entier suivi de son rang en anglais
* st (pour first, si l'entier se termine par 1 sauf 11).* nd (pour second, si l'entier se termine par 2 sauf 12)* rd (pour third, si l'entier se termine par 3 sauf 13)* th (pour tout autre nombre)
- le programme donnerait* 1st, 2nd, 3rd, ou 4th, 5th, 11th, 21st, 32nd, 83rd, 99th …
Méthodes utiles :String.valueOf(in);str.length();str.charAt(index)
40
Structures itératives
- Permettent de décrire une séquence qui se répète plusieurs fois
- Plusieurs formes* Nombre de répétitions connu
• La structure for* Nombre de répétitions inconnus pouvant être nul
• La structure while* Nombre de répétitions inconnus mais supérieur à 1
• La structure do ... while
41
Structures itératives
FOR :for(initialisation;condition;instruction de pas){
séquence;}- Le compteur de la boucle peut être déclaré en local int n = Clavier.lireInt();for(int i=n+1;i<=n+10;i++){System.out.println((i + ", ");}
WHILE:while (condition){séquence;}
DO WHILE:do{séquence;}while (condition);
42
Exercices
- Écrire un programme qui lit dix nombres et affiche leur maximum
- Écrire un programme qui lit un entier n, lit n nombres et affiche leur minimum
- Écrire un programme qui lit un entier n et affiche n fois alternativementrougevertbleu
43
Exercices
1) Écrire l'algorithme et le programme Java qui* Lit un réel N* Calcule par approximation itérative la racine carrée (e
n) de ce nombre
• Considérer une valeur très petite• Commencer par e
0=1
• Utiliser la valeur approchée ei = N/(2*e
i-1) + e
i-1/2 à chaque itération
• Arrêter les itérations quand |N/ ei
2 –1|< epsilone
* Afficher la racine calculée et le nombre d'itérations
2) Écrire un convertisseur multidirectionnel de températures de la manière suivante* le programme affiche un menu en 3 entrées
• C: Celsius vers Fahrenheit,• F: Fahrenheit vers Celsius,• Q: Quit
* traite le choix de l'utilisateur• C :lit les Celsius, convertit en fahrenheit, affiche le résultat, et réaffiche le menu• F: lit les Fahrenheit, convertit en Celsius, affiche le résultat, et réaffiche le menu• Q : termine l'exécution• autrement : réaffiche le menu
44
Break et continue
Exemple 1 : Imaginons que l'on veuille imprimer pour x allant de 1 à 10 la valeur de 1/(x-7). Il est évident que pour x=7 il y aura une erreur. Grâce à l'instruction continue il est possible de traiter cette valeur à part puis de continuer la boucle.x=1;for (int x=0; x<=10; x++) { if (x == 7) { System.out.println("Division par zéro!"); continue; } double a = 1.0/(x-7); System.out.println(a);}
Exemple 2 : Dans l'exemple précédente, si l'on ne savait pas à quel moment le dénominateur (x-7) s'annule, il serait possible de faire arrêter la boucle en cas d'annulation du dénominateur, pour éviter une division par zéro.for (int x=1; x<=10; x++) { a = x-7; if (a == 0) { System.out.println("division par 0"); break; } System.out.println(1.0/a);}
45
Comparatif
46
Exercice :
Nous allons concevoir et créer une classe AnimalFamilier. - Tout d’abord, nous devons décider quelles actions notre animal familier sera capable d’effectuer (manger, dormir,...) Nous allons programmer ces actions dans les méthodes de la classe AnimalFamilier.
- Nous allons aussi donner à notre animal les attributs suivants : âge, taille, poids et couleur.
- Commençons par créer une nouvelle classe Java nommée AnimalFamilier.
- Nous sommes maintenant prêts à déclarer les attributs et les méthodes de la classe AnimalFamilier. Le corps des méthodes et des classes Java est délimité par des accolades. A chaque accolade ouvrante doit correspondre une accolade fermante :
class AnimalFamilier {}
47
public class AnimalFamilier {int âge;float poids;float taille;String couleur;
public void dormir() {System.out.println("Bonne nuit, à
demain");}
public void manger() {System.out.println("J'ai si faim... Donne-moi un
biscuit !");}
public String dire(String unMot) {String réponseAnimal = "OK !! OK !! " + unMot;return réponseAnimal;
}
}
48
Classe appelante ...
public class MaîtreAnimal {
public static void main(String[] args) {String réactionAnimal;AnimalFamilier monAnimal = new AnimalFamilier();monAnimal.manger();réactionAnimal = monAnimal.dire("Cui !! Cui !!");System.out.println(réactionAnimal);monAnimal.dormir();
}}
49
Héritage :
- Dans la vie réelle, chaque personne hérite des caractéristiques de l’un ou l’autre de ses parents.
- De la même façon, dans le monde Java, on peut, à partir d’une classe, en créer une nouvelle.
- La classe AnimalFamilier possède un comportement et des attributs partagés par de nombreux animaux familiers : ils mangent, dorment, certains d’entre eux émettent des bruits,...
- Il est donc plus facile de créer une classe Poisson qui héritera certains comportements et attributs communs de la classe AnimalFamilier.
class Poisson extends AnimalFamilier {
}
50
51
- Tous les animaux ne sont pas capables de plonger, mais il est certain que les poissons le peuvent. Ajoutons maintenant une nouvelle méthode plonger() à la classe Poisson.
public class Poisson extends AnimalFamilier {
int profondeurCourante = 0;
public int plonger(int combienDePlus){profondeurCourante = profondeurCourante +CombienDePlus;
System.out.println("Plongée de " +combienDePlus + " mètres");
System.out.println("Je suis à " +profondeurCourante +" mètres sous le niveau de la mer");
return profondeurCourante;}
}
52
Pour tester...
public class MaîtrePoisson {public static void main(String[] args) {
Poisson monPoisson = new Poisson();monPoisson.plonger(2);monPoisson.plonger(3);monPoisson.dormir();
}}
53
Surcharge:
- Les poissons ne parlent pas. Mais notre classe Poisson hérite de la classe AnimalFamilier qui possède la méthode dire(). Ceci signifie que rien ne nous empêche d’écrire quelque chose comme
monPoisson.dire("Un poisson qui parle !");
→ notre poisson a commencé à parler...
- Pour éviter que cela se produise, il faut que la classe Poisson surcharge (override) la méthode dire() de la classe AnimalFamilier.
- Si on déclare une méthode avec exactement la même signature dans la sous-classe que dans la superclasse, la méthode de la sous-classe sera utilisée à la place de celle de la superclasse.
public String dire(String unMot) {return "Ne sais-tu pas que les poissons ne parlent pas ?";
}
Si la signature d’une méthode inclut le mot-clé final, elle ne peut pas être surchargée. Par exemple: final public void dormir(){...}
54
Méthodes particulières
- Java utilise l'opérateur new (nouveau) pour créer des instances d'objets en mémoire. Par exemple :Poisson monPoisson = new Poisson();
- Les parenthèses après le mot Poisson signifient que cette classe a une méthode nommée Poisson(). Il y a des méthodes spéciales appelées constructeurs (constructors), qui ont les caractéristiques suivantes :
* Les constructeurs ne sont appelés qu'une fois au cours de la construction d'un objet en mémoire.
* Ils doivent avoir le même nom que la classe elle-même.
* Ils ne retournent pas de valeur ; il n'est même pas nécessaire d'utiliser le mot-clé void dans la signature d'un constructeur.
* Toute classe peut avoir plusieurs constructeurs
* Si aucun constructeur n'est créé, Java crée automatiquement un constructeur par défaut sans aucun argument.
55
Méthodes particulières
- En général, les constructeurs sont utilisés pour affecter des valeurs initiales aux variables membres d'une classe. Par exemple, la version suivante de la classe Poisson a un constructeur mono-argument qui se contente d'affecter la valeur de l'argument à la variable d'instance profondeurCourante pour une utilisation ultérieure.
public class Poisson extends AnimalFamilier {int profondeurCourante;Poisson(int positionDépart) {
profondeurCourante = positionDépart;}
}
- Maintenant, la classe MaîtrePoisson peut créer une instance de Poisson et affecter la position initiale du poisson. L'exemple suivant crée une instance de Poisson "submergée" sous 20 mètres d'eau :Poisson monPoisson = new Poisson(20);
56
Exercice:
1) Créer une nouvelle classe Voiture possédant les méthodes suivantes :public void démarrer()public void arrêter()public int rouler(int durée)
La méthode rouler() doit renvoyer la distance totale parcourue par la voiture pendant un temps donné. Utiliser la formule suivante pour calculer la distance :distance = durée * 60;
2) Écrire une autre classe, PropriétaireVoiture, qui crée une instance de l’objet Voiture et appelle ses méthodes. Le résultat de chaque appel de méthode doit être affiché à l’aide de System.out.println().
3) Créer une sous-classe de Voiture nommée VoitureJamesBond et surcharger la méthode rouler(). Utilise la formule suivante pour calculer la distance :distance = durée*180;
57
Le mot-clé this
- Le mot-clé this est utile lorsqu'on a besoin de se référer à l'instance de l'objet dans laquelle tu te trouves. class Poisson {
int profondeurCourante ;Poisson(int profondeurCourante) {
this.profondeurCourante = profondeurCourante;}
}
- Le mot-clé this permet d'éviter les conflits de nom.
- Par exemple, this.profondeurCourante fait référence à la variable membre profondeurCourante, alors que profondeurCourante fait référence à la valeur de l'argument.
- En d'autres termes, l'instance de l'objet Poisson pointe sur elle-même.
58
Exercice
- Créer une nouvelle classe nommée ConvertisseurTempératures dont une méthode a la signature suivante :public String convertirTempérature(int température, char convertirEn)
- Si la valeur de l'argument convertirEn est F, la température doit être convertie en degrés Fahrenheit ; si c'est C, en degrés Celsius. Quand on appelle cette méthode, on met la valeur de l'argument de type char entre apostrophes.
