Programmation Orient Ee Objet Cours 1: Mohamed Nabil Saidi
Programmation Orient Ee Objet Cours 1: Mohamed Nabil Saidi
Programmation Orient Ee Objet Cours 1: Mohamed Nabil Saidi
Cours 1
20 Février 2017
Présentation de Java
Le paradigme objet
Classes
Objets
L’essentiel du langage de Java
Variables
Opérateurs
Commandes basiques
Portable
Les types de données sont indépendants de la plate forme (par
exemple les types numériques sont définis indépendamment du
type de plate forme sur laquelle le byte code sera interprétée).
Multi thread
Une applications peut être décomposée en unités d’exécution
fonctionnant simultanément
Dynamique
Les classes Java peuvent être modifiées sans avoir à modifier le
programme qui les utilise
Politique
Java est actuellement totalement controlé par Oracle.
Java 1.0
8 packages
212 Classes et Interfaces
1545 Méthodes
Java 1.1
23 packages
504 Classes et Interfaces
3 851 Méthodes
Java 1.2
60 packages
1 781 Classes et Interfaces
15 060 Méthodes
Et bien plus encore dans les versions suivantes
Un objet a :
une identité : adresse en mémoire
un état : la valeur de ses attributs
un comportement : ses méthodes
Une définition abstraite selon laquelle les objets sont crées (un
type d’objet)
Ex. : la classe des vélos, la classe des stylos
Exemple : Définir une classe Velo :
Attributs : vitesse
Mthodes : Accélérer, Freiner et ImprimeEtat
Velo.java
class Velo {
int vitesse = 0;
void accelerer(int increment) {
vitesse = vitesse + increment;
}
void freiner(int decrement) {
vitesse = vitesse - decrement;
}
void imprimeEtat() {
System.out.println(”vitesse: ” + vitesse);
}
}
DemoVelo.java
class DemoVelo {
public static void main(String[] args) {
// Genere deux objets differents du type Velo
Velo velo1 = new Velo();
Velo velo2 = new Velo();
// Invoque les methodes
velo1.accelerer(10);
velo1.imprimeEtat();
velo2.accelerer(20);
velo2.imprimeEtat();
}
}
Compilation :
$ javac Velo.java DemoVelo.java
Exécution :
$ java DemoVelo
vitesse: 10
vitesse: 20
Velo v1;
v1 = new Velo();
Velo v2 = new Velo();
Velo v3 = v2;
class Compte
{int numero;
float solde;
public Compte (int num,float s)
{
numero = num ;
solde = s ;
}
}
Compte co1 = new Compte (1234, 1000.00f) ;
Exemple:
class BarreDeProgression
{
float pourcent ;
Velo v1;
v1 = new Velo();
Velo v2 = new Velo();
Velo v3 = v2;
v1.vitesse = 10;
v2.vitesse = 10;
v3.vitesse = v1.vitesse + v2.vitesse;
syntaxe :
nomDeObjet.nomDeMethode(< paramètre effectifs >)
class Velo {
double vitesse = 110.0;
void accelerer(double dx)
{
vitesse += dx;
}
void freiner(double dx){
vitesse -= dx;
}
} //Velo
class Compte {
int numero ;
float solde ;
void initialiser (int n, float s) { numero = n ; solde = s ; }
void deposer (float montant) { solde = solde + montant ; }
void retirer (float montant) { solde = solde - montant ; }
float consulterSolde ( ) { return solde ; }
void afficher()
{ System.out.println (”Compte : ” + numero + ” solde: ” +
solde) ;
}
}
Nombres réels
float simple précision sur 32 bits 1.4032984e-45 3.40282347
e38
double précision sur 64 bits 4.94065645841243544 e-324
1.79769313486231570 e308
Repésentation des réels dans le standard IEEE 754. Un suffixe
” f ” ou ” d ” après une valeur numérique permet de spécifier
le type.
Exemple
double x = 154.56d;
float y = 23.4f;
float f = 23.65; //Erreur
boolean
Valeurs true ou false
Un entier non nul n’est assimilé à true
Un entier nul n’est assimilé à false
char
Une variable de type char peut contenir un seul caractère codé
sur 16 bits (jeu de caractères 16 bits Unicode contenant 34168
caractères)
Des caractères d’échappement existent
\b Backspace \t Tabulation
\n Line Feed \f Form Feed
\r Carriage Return \” Guillemet
\0 Apostrophe \\ BackSlash
\u00xx Caractère Unicode (xx est compris entre 00 et FF)
Chaı̂nes de caractères
Les chaı̂nes de caractères sont manipulées par la classe String
(ce n’est donc pas un type de données).
Exemples :
String str = ”exemple de chaı̂ne de caractères” ;
String chaine = ”Le soleil ” + ”brille” ; //
Opérateur de concaténation
Exemple 2:
DemoTableau.java
class DemoTableau {
public static void main(String[ ] args) {
int[ ] unTableau; // declaration
unTableau = new int[3]; // allocation de memoire
unTableau[0] = 100; // initialisation
unTableau[1] = 200;
unTableau[2] = 300;
System.out.println(” Element 0: ” + unTableau[0]);
System.out.println(” Element 1: ” + unTableau[1]);
System.out.println(” Element 2: ” + unTableau[2]);
}
}
DemoMultiTableau.java
class DemoMultiTableau {
public static void main(String[] args) {
String[][] noms = {{”Mr. ”, ”Mrs. ”, ”Ms. ”},
{”Smith”, ”Jones”}};
System.out.println(noms[0][0] + noms[1][0]);
System.out.println(noms[0][2] + noms[1][1]);
}
}
$ javac DemoMultiTableau.java
$ java DemoMultiTableau
Mr. Smith
Ms. Jones
Quelques remarques :
Opérateur ++ (resp. −−) préfixé évalue l’expression avant
l’incrementation (resp. décrementation)
Opérateurs && et || présentent le “short circuit behaviour” :
le deuxième opérande est évalué seulement si nécessaire.
Opérateur + est utilisé aussi pour la concatenation des
Strings.
DemoInstanceof1.java
class DemoInstanceof1 {
public static void main(String[] args) {
Pere obj = new Pere();
System.out.println(”obj instanceof Pere: ” +
(obj instanceof Pere));
System.out.println(”obj instanceof Fils : ” +
(obj instanceof Fils));
}
}
class Pere {}
class Fils extends Pere {}
$ javac DemoInstanceof1.java
$ java DemoInstanceof1
obj instanceof Pere: true
obj instanceof Fils: false
DemoInstanceof2.java
class DemoInstanceof2 {
public static void main(String[] args) {
Fils obj = new Fils();
System.out.println(”obj instanceof Pere: ” +
(obj instanceof Pere));
System.out.println(”obj instanceof Fils: ” +
(obj instanceof Fils));
}
}
class Pere {}
class Fils extends Pere {}
$ javac DemoInstanceof2.java
$ java DemoInstanceof2
obj instanceof Pere: true
obj instanceof Fils: true
Affectation :
Variable = Expression ;
Bloc de commande :
{ Commande ; Commande ; ... ; }
Contrôle de flux :
if ( Expression ) Commande
if ( Expression ) Commande else Commande
switch ( Expression ) case ExpConstante :
Commande ... [default : Commande] }
while ( Expression ) Commande
do Commande while ( Expression ) ;
for (Commande ; [Expression] ; [Commande])
Commande
Commandes de ramification :
break [Identificateur] ;
continue [Identificateur] ;
return [Expression] ;