Upload
fouad-root
View
92
Download
0
Embed Size (px)
DESCRIPTION
Introduction Java
Citation preview
COURS JAVA
Rappel
Réalisé par Mme LAKHROUIT Jihane
20.06.2014
Objectifs
Comprendre la structure d’une classe Java : attributs et méthodes
Les variables et les types primitifs
Les Constantes
Les instructions et les Expressions
Les Opérateurs Les tests
Les boucles
20.06.2014
Java : Sun
« Java : a simple, object-oriented, distributed, robust, secure, architecture neutral, portable, high-performance, multithreaded, and dynamic language »
Parmi les caractéristiques qui ont contribué au succès de Java :
1 Java est Portable (grâce à JVM)
2 Java est simple (pas de pointeurs, héritage multiple)
3 Fortement typé
4 Gestion automatique de la mémoire (GC)
5 Java est Sûr
6 Multitâche
20.06.2014
Pour Commencer Vous avez besoins de :
Compilateur Java
Une machine virtuelle Java
API Java
documentation API Java
un editor pour composer vos programmes Java
1+2+3 = JDK SE disponible sur le site de Sun http://java.sun.com/javase/downloads/index.jsp
Pour Commencer
20.06.2014
Un premier Programme Java
5 public class Bienvenue 6 { 7 // méthode main point d’entrée pour l’exécution d’une application Java 8 public static void main( String args[] ) 9 { 10 System.out.println(" Bienvenue à la programmation Java!" ); 11 12 } // Fin méthode main 13 14 } // Fin class Bienvenue
Bienvenue à la programmation Java!
20.06.2014
Bienvenue.java modifié
5 public class Bienvenue 6 {
7 // méthode main point d’entrée pour l’exécution d’une application Java 8 public static void main( String args[] ) 9 {
10 System.out.print(" Bienvenue\n à la\t programmation\n Java!\n" ); 11 12 } // Fin méthode main 13 14 } // Fin class Bienvenue
Bienvenue
à la programmation
Java!
20.06.2014
Séquences d’échappement
SE Description
\n Retour à la ligne. Positionne le curseur au début de la ligne suivante.
\t Tabulation horizontale. Déplace le curseur par une tabulation.
\r Retour Chariot. Positionne le curseur au début de la ligne courante. Chaque caractère affiché après le retour chariot va écraser les caractères affichés préalablement dans cette ligne.
\\ Antislash. Utilisé pour afficher le caractère antislash.
\" Pour afficher les deux guillemets par exemple System.out.println( "\" entre guillemets \"" ); affiche " entre guillemets "
20.06.2014
Printf
Printf permet d’afficher les résultats dans un format bien précis, par exemple :
afficher un nombre réel avec 4 chiffres après la virgule
Printf prend en Paramètres une chaîne de caractères format et une liste d’arguments
20.06.2014
Bienvenue.java modifié
5 public class Bienvenue 6 {
7 // méthode main point d’entrée pour l’exécution d’une application Java 8 public static void main( String args[] ) 9 {
10 System.out.printf("%s\n%s\n", " Bienvenue", "à la programmation Java! ");
11 12 } // Fin méthode main 13 14 } // Fin class Bienvenue
Bienvenue
à la programmation Java!
20.06.2014
1. // Listing 4: Addition.java 2. // Programme d’addition qui affiche la somme de 2 entier 3. import java.util.Scanner; //importer la classe Scanner
4. public class Addition { 5. // méthode main point d’entrée pour l’exécution d’une application Java 6. public static void main(String args[ ]) { 7. // créer un Scanner pour lire sur l’entrée standard 8. Scanner input = new Scanner(System.in);
9. int number1; // premier nombre 10. int number2; // second nombre 11. int sum; // somme des deux nombres
12. System.out.print("Entrer le premier entier : "); /* inciter l’utilisateur à
saisir un entier*/ 13. number1 = input.nextInt(); // lire le premier nombre
14. System.out.print("Entrer le second entier: "); /* inciter l’utilisateur à saisir
un entier*/
Addition.java
20.06.2014
15. number2 = input.nextInt(); // lire le second nombre 15. sum = number1 + number2; // sommer les deux entiers.
16. System.out.printf(" La somme est %d\n", sum); // afficher la somme 17. } // fin méthode main
18. } // fin classe Addition
Addition.java
CONCEPTS DE BASE DU LANGAGE JAVA
20.06.2014
Objectifs
Comprendre la structure d’une classe Java : attributs et méthodes
Les variables et les types primitifs
Les Constantes
Les instructions et les Expressions
Les Opérateurs
Les tests
Les boucles
20.06.2014
Variables
Définition : une variable est un élément de données nommé par un identificateur
Vous devez explicitement donner un nom et un type à chaque variable utilisée dans votre
programme.
En plus du nom et type une variable à une portée = la section du code où on peut appeler
la variable par son nom simple.
La déclaration de variables
Pour pouvoir utiliser une variable, il faut la définir, c'est-à-dire lui donner un nom, mais surtout un type de donnée à stocker afin qu'un espace mémoire conforme au type de donnée qu'elle contient lui soit réservé.
Une variable se déclare de la façon suivante :
type nomDeVariable;
Ou bien s'il y a plusieurs variables du même type :
type nomDeVariable1, nom_de_variable2;
Java impose que les variables soient impérativement déclarées avant d'être utilisée.
Java permet de définir une variable à n'importe quel endroit du code.
Affectation d'une donnée à une variable
La déclaration d'une variable réserve un emplacement mémoire où stocker la variable, et une valeur par défaut (généralement 0, null ou false), pour modifier cette valeur par défaut, il faut faire une affectation, c'est-à-dire préciser la donnée qui va être stockée à l'emplacement mémoire qui a été réservé.
Pour cela on utilise l'opérateur d'affectation "=" :
nomDeVariable = valeur;
Il est aussi possible d'initialiser les valeurs lors de leurs déclarations.
type nomDeVariable = valeur;
Exemple : Pour stocker le caractère B dans une variable que l'on a appellera caractere, il faudrait écrire :
char caractere = 'B';
Ce qui signifie "stocker la valeur de la lettre B dans la variable nommée 'caractere'".
20.06.2014
Variables / type
Le type d’une variable détermine les valeurs qu’une variable peut contenir et les
opération qu’elle supporte.
Java manipule deux sortes de types de variables : les primitifs et les références.
Une variable primitive contient une seule valeur d’une taille et format bien précises
par son type. Ex: short, int, float..
Java fixe la taille de chacun des types primitifs. Ces tailles ne changent pas d'une
architecture de machine à une autre, comme c'est le cas dans la plupart des langages.
L'invariance de la taille de ces types est l'une des raisons pour lesquelles Java est si
portable.
les types primitifs :
20.06.2014
les types primitifs
Type primitif
Taille Minimum Maximum Type wrapper
boolean - - - Boolean
char 16-bit Unicode 0 Unicode 216- 1
Character
byte 8-bit -128 +127 Byte
short 16-bit -215 +215-1 Short
int 32-bit -231 +231-1 Integer
long 64-bit -263 +263-1 Long
float 32-bit IEEE754 IEEE754 Float
double 64-bit IEEE754 IEEE754 Double
20.06.2014
Nom d’une Variable
Un programme se réfère à une valeur d’une variable par le nom de la variable. Un nom
d’une variable doit être :
Commençant par une lettre
Différent des mots réservés java
Doit être unique dans sa portée.
Par convention : le nom de variable commence par une minuscule et le nom de classe
commence par une majuscule. Si le nom est composé de plusieurs mots, il convient
de concaténer les mot en commençant chaque mot par une majuscule ex :
int tailleMemoireTotale ;
Public class RoseBlue { … }
20.06.2014
Liste des mots réservés JAVA
abstract double int strictfp
boolean else interface super
break extends long switch
byte final native synchronized
case finally new this
catch float package throw
char for private throws
class goto protected transient
const if public try
continue implements return void
default import short volatile
do instanceof static while
Portée (visibilité) des variables
Selon l'endroit où on déclare une variable, celle-ci pourra être accessible (visible) de partout dans le code ou bien que dans une portion confinée de celui-ci (à l'intérieur d'une méthode par exemple), on parle de portée d'une variable.
Lorsqu'une variable est déclarée directement dans la classe, c'est-à-dire à l'extérieur de toute méthode, elle sera accessible dans toute la classe. On parle alors de champ de la classe (fields, en anglais). Elle représente l'état de l'objet courant (ou avec le mot clé static, l'état de la classe elle même).
Lorsque l'on déclare une variable à l'intérieur d'un bloc d'instructions (entre des accolades), sa portée se restreint à l'intérieur de ce bloc (dans les lignes qui suit sa déclaration), on parle alors de variable locale.
Il est interdit d'avoir deux variables de même nom si elles ont un portée commune. Il serait alors impossible de les distinguer...
20.06.2014
Portée
En Java en définit quatre niveaux de portée des variables : Variable membre Variable locale
paramètre d’une méthode
Paramètre de gestion des exceptions
20.06.2014
Portée
Une variable membre est une variable membre d’une classe ou objet. Elle est
déclarée au sein d’une classe mais en dehors de toute méthode ou
constructeur, elle est visible dans la classe entière.
Une variable locale est déclarée au sein d’un bloc {….}, elle est reconnue
seulement dans ce bloc.
Un paramètre d’une méthode ou constructeur est un argument formel utilisé
pour passer les valeurs à une méthode ou constructeur, il est reconnu dans
la méthode entière
Un paramètre de gestion des exceptions est similaire à un paramètre de
méthode, il est reconnu dans le bloc de gestion des exceptions.
20.06.2014
Objectifs
Les variables et les types primitifs
Les Constantes
Les instructions et les Expressions
Les Opérateurs Arithmétiques
Les Opérateurs Logique
Les tests
Les boucles
Constante
Une constante est une donnée dont la valeur est inchangeable lors de l'exécution d'un programme. Le mot clé final permet de faire cela. Toutefois on ne peut véritablement parler de constantes en Java que pour les types primitifs, car pour un objet le mot clé final impose seulement que la référence de l'objet n'est pas modifiable, mais les champs de l'objets peuvent être modifiés malgré tout. Par convention, et pour les distinguer des variables, les constantes sont écrites entièrement en majuscules, et le caractère _ peut être utilisé pour séparer deux mots.
final int MA_CONSTANTE = 12
aura pour effet de définir une variable de type int possèdant la valeur 12 et ne pouvant pas être modifiée dans la suite du code, auquel cas le compilateur générera une erre
20.06.2014
Variable final
Vous pouvez déclarer une variable dans n’importe quelle portée en tant que final pur
qu’elle demeure inchangée dans tout le programme, c’est l’équivalent des constantes
en C et C++.
final int aFinalVar = 0;
Une fois une variable final à été initialisée, elle ne peut être changée, chaque tentative
de lui affecter une valeur va conduire à une erreur de compilation.
20.06.2014
Objectifs
Les variables et les types primitifs
Les Constantes
Les Opérateurs
Les tests
Les boucles
20.06.2014
Opérateurs
Il y’a plusieurs type d’opérateur en Java :
Opérateurs arithmétiques
Opérateurs conditionnels et relationnels
Opérateur logiques et de décalage.
Opérateurs d’affectation
Autres opérateurs
20.06.2014
Opérateurs arithmétiques
Opérateur Utilisation Description
+ op1 + op2 Ajoute de op1 à op2
- op1 - op2 Soustrait op2 de op1
* op1 * op2 Multiplie op1 par op2
/ op1 / op2 divise op1 par op2
% op1 % op2 Calcul le reste de la division de op1 par op2
20.06.2014
public class ArithmeticDemo
{ public static void main(String[] args)
{ //a few numbers int i = 37; int j = 42; double x = 27.475; double y =
7.22;
//adding numbers
System.out.println(“ Adding...");
System.out.println(" i + j = " + (i + j));
//subtracting numbers
System.out.println(“ Subtracting...");
System.out.println(" i - j = " + (i - j));
//multiplying numbers
System.out.println(“ Multiplying...");
20.06.2014
System.out.println(" i * j = " + (i * j));
//dividing numbers
System.out.println("Dividing...");
System.out.println(" i / j = " + (i / j));
//computing the remainder resulting from dividing numbers System.out.println("Computing the remainder...");
System.out.println(" i % j = " + (i % j));
//mixing types
System.out.println("Mixing types...");
System.out.println(" j + y = " + (j + y));
System.out.println(" i * x = " + (i * x));
}
}
20.06.2014
Opérateurs unaires
Opérateur Utilisation
Description
+ +op Change le type de op à int si c’était un byte, short, ou char
- -op Négation arithmétique de op
Opérateur Utilisation
Description
++ op++ Incrément op par 1; il est évalué par la valeur de op avant incrémentation .
++ ++op Incrément op par 1; il est évalué par la valeur de op après incrémentation .
-- op-- Décrément op par 1; il est évalué par la valeur de op avant décrémentation .
-- --op décrément op par 1; il est évalué par la valeur de op après décrémentation .
20.06.2014
Opérateurs relationnels
Un opérateur relationnel compare deux opérandes et détermine la relation entre eux
Opérateur Utilisation Retourne true si
> op1 > op2 op1 est plus grand que op2
>= op1 >= op2 op1 est plus grand ou égal à op2
< op1 < op2 op1 est inférieur à op2
<= op1 <= op2 op1 est inférieur ou égal à op2
== op1 == op2 op1 et op2 sont égaux
!= op1 != op2 op1 et op2 sont différents
20.06.2014
Opérateurs conditionnels
Opérateur
Utilisation Retourne true si
&& op1 && op2 op1 et op2 sont vrai tous les deux, l’évaluation de op2 est conditionnelle
|| op1 || op2 L’un des opérandes op1 ou op2 est vrai, l’évaluation de op2 est conditionnelle
! ! op op est faux
& op1 & op2 op1 et op2 sont vrai tous les deux, l’évaluation de op2 et op1 est nécessaire
| op1 | op2 L’un des opérandes op1 ou op2 est vrai, l’évaluation de op2 et op1 est nécessaire
^ op1 ^ op2 Si op1 et op2 sont différents
20.06.2014
Opérateurs d’affectation
Opérateur Utilisation Equivalece
+= op1 += op2 op1 = op1 + op2
-= op1 -= op2 op1 = op1 - op2
*= op1 *= op2 op1 = op1 * op2
/= op1 /= op2 op1 = op1 / op2
%= op1 %= op2 op1 = op1 % op2
&= op1 &= op2 op1 = op1 & op2
|= op1 |= op2 op1 = op1 | op2
^= op1 ^= op2 op1 = op1 ^ op2
20.06.2014
Objectifs
Les variables et les types primitifs
Les Constantes
Les instructions et les Expressions
Les Opérateurs
Transtypage
Les tests
Les boucles
Instructions de contrôle : L'instruction conditionnelle if -
else
La syntaxe générale :
if (expression booléenne) {
bloc1 }
else {
bloc2
}
La condition doit être évaluable en true ou false et elle est obligatoirement
entourée de parenthèses. La partie commençant par else est facultative.
Si un bloc ne comporte qu'une seule instruction, les accolades qui
l'entourent peuvent être omises.
Instructions de contrôle : L'instruction conditionnelle if -
else
// EX1 les entiers a, b, c sont définis et affectés
System.out.print("Le plus petit entre "+a+" et "+b +" est : ");
if (b <a ) {
// écrire l'échange des variables a et b
c= a - b;
} else
c= a + b ;
}
Exemple d'opérateur ternaire : on reprend le même exemple précédent. System.out.println( (b < a) ? b : a ); c = (b < a) ? a-b : b-a ;
L'instruction de choix multiples switch( )
En cas de tests multiples, il est préférable d’utiliser l’instruction switch plutôt qu’une série de if imbriqués. Cette instruction se comporte comme un aiguillage qui exécute des instruction différentes (case) selon le résultat d’une expression logique. A l'entrée dans la structure, cette expression est évaluée et son résultat est comparé à chaque valeur des instructions case.
En cas d’égalité, les instructions de cette clause sont exécutées jusqu’à la rencontre d’une instruction break qui entraîne la sortie de la structure switch.
La clause (optionnelle) default est exécutée lorsque la valeur de l'expression d'aiguillage n'est égale à aucun des cas.
D’un point de vue logique, les clauses case sont considérées comme des étiquettes (label) : elles sont donc suivies du caractère « : ».
L'instruction de choix multiples switch( )
La syntaxe générale :
switch (expr entière ou caractère) {
case i:
case j:
[bloc d'intructions]
break;
case k :
........
default:
.......
}
Rq: Le type de la variable d'une instruction case doit être char, byte, short ou int.
20.06.2014 Nejeoui Abderrazzak
Instructions itératives : Boucle while
L'itération while
while (expression) {
bloc
}
Elle permet de répéter un bloc d'instructions TANT QUE la condition est
vraie. La sortie de boucle est effectuée aussitôt que la condition est
évalué fausse. Le test de cette condition est vérifié au début de chaque
boucle, si bien que le bloc peut ne pas être exécuté.
Boucle do-while
Cette structure est très proche de la structure while. Sa syntaxe est :
do{
instructions;}
while (condition);
Dans cette boucle faire_tant_que, la condition est évaluée après
l’exécution du corps de la boucle. Elle est au minimum exécutée une fois
même si la condition à tester est fausse au départ
int i = 100, j = 0, somme = 0 ;
do{
somme += j;
j++;}
while (j <= i); //Si oublié génère une erreur de compilation
A la sortie de la boucle, la variable somme contient la somme des 100 premiers
entiers.
L'itération contrôlée for ( ..;..;..)
for ( expression1; expression2 ; expression3){
bloc
}
C'est la boucle contrôlée, utilisée pour répéter N fois un même bloc
d'instructions
expression1 précise la valeur initiale de la variable de contrôle (ou compteur)
expression2, la condition à satisfaire pour rester dans la boucle
expression3, une action à réaliser à la fin de chaque boucle (en général, l'actualisation du compteur).
int somme = 0, max = 100; for (int i =0 ; i <= max ; i++ ) { somme += i; }
Boucle for
Remarques :
* exp1 et exp3 peuvent contenir plusieurs instructions qui sont alors
séparées par des virgules.
Exemple :
for (int i=0,j=10; i<=100; i++,j--)
instructions;
* La boucle : for ( ; ; ;) {instructions;} correspond à la boucle :
while (true){instructions;}
Instructions de rupture de boucle
Il existe des moyens de sortir ou d'effectuer des "sauts" en rompant le
cours normal d'une itération. Avec les instructions
break :on quitte définitivement le bloc courant (et on passe à la suite).
continue : on saute les instructions du bloc situé à la suite (et on passe à
l'itération suivante).
Si on indique break , ou continue , où label est une étiquette qui marque un
endroit dans le code, le saut s'effectue relativement au bloc marqué par
l'étiquette.
20.06.2014 Nejeoui Abderrazzak