Les bases de Java

Transcription

Les bases de Java

Les bases de Java
Plan
●
Votre machine virtuelle VMWare
●
Les outils de développement
●
Les variables et les opérateurs
●
Lire les entrées clavier
●
Les conditions
●
Les boucles
●
TP Conversion Celsius Fahrenheit
●
Les tableaux
●
Les méthodes de classes.
Les outils de développement
✗
✗
✗
✗
✗
✗
✗
✗
JRE ou JDK / Eclipse
IDE. Eclipse
Votre premier projet Eclipse
Votre premier programme Java
Commentaires
Commentaires Javadoc
Générer la javadoc avec Eclipse
Résumé
JRE / JDK ?
●
JRE ou JDK ?
–
Java RunTime
Environment JRE
contient tout le nécessaire
pour faire en sorte que vos
programmes Java puissent
être exécutés sur votre
machine.
–
Java Development Kit
JDK contient en plus
d’JRE les outils nécessaires
pour compiler, développer,
…
JRE / JDK ?
●
Depuis un terminal :
–
java -version
–
javac
Sous windows, il faut ajouter javac dans la Path
IDE. Eclipse
●
IDE Eclipse
–
Eclipse est un éditeur pour le
développement avec plusieurs
langages :
●
Java, PHP, C++, etc
–
Dernière version 4.7 (juno)
–
Il existe une version
●
Eclipse portable (clé USB)
IDE. Eclipse
●
Eclipse.
●
Depuis un terminal : $$> eclipse &
IDE. Eclipse
●
Changer de perspective :
–
Window → Open perspective → Java
IDE. Eclipse
●
Menu File.
IDE. Eclipse
●
Barre d'outils
New project
Debug
Compilation et exécution
New Class / interface /
Ennum / Annotation
New package
●
File → new →
Java Projet
●
Nouvelle classe.
–
File → new → class
●
Résultat
3
1
2
4
●
●
Pour les petits projets IDE Eclipse est
suffisant.
Pour des projets de taille importante (plus de
dépendance avec d'autres Jar, lib, projets, ...)
–
MAVEN
–
MAVEN / ECLIPSE
votre premier programme Java
public class Test {
/**
* @param args
*/
public static void main(String[] args) {
System.out.print("Hello tii !");
}
}
votre premier programme Java
public class Test {
/**
* @param args
*/
System.out.print("Hello tii !");
}
}
●
Run → run
●
Compilation et exécution depuis un terminal !
●
Terminal
●
–
$$> cd
learning_java/codes/workspace_chapitre_1/votrePremierProgrammeJava/src
–
$$> javac Test.java
–
$$> java Test
–
$$> Hello tii ! $$>....
Eclipse, place le Test.class dans :
–
learning_java/codes/workspace_chapitre_1/.../bin
System.out.print("Hello World !");
System.out.print("Hello World ! \n");
System.out.print("My name is");
System.out.println("My name is");
System.out.print("jenesaispas !");
System.out.println("\n jenesaispas");
Pour obtenir les mêmes résultats
que printf sous C++
\t tabulation
Il faut utiliser
\n nouvelle ligne
–
System.out.format('' la moyenne de la
classe est %2.2f'',mean) ;
\r retour chariot
●
Les programmes java sont pré-compilés par
JVM en Bytecode (IDE ou javac).
●
Bytecode n'est compréhensible que par JVM
●
JVM fait le lien ensuite avec l'OS.
●
JVM dépend d'OS et ne pas de votre code.
Quel que soit l'OS sous lequel a été codé un
programme Java, n'importe quelle machine pourra
l'exécuter si elle dispose d'une JVM !
●
Test.java → code
●
Test.class → bytecode
●
●
●
Tous les programmes Java sont composés d'au
moins une classe « Test.java ».
Elle doit contenir une méthode appelée main : ce
sera le point de démarrage de notre programme.
Une méthode est une suite d'instructions :
–
Un entête. Identité.
–
Un corps
–
Une valeur de retour.
Déboguer avec Eclipse
2
1
Commentaires !
/**
* Ceci est un commentaire Javadoc.
* Il commence par un slash suivis de deux étoiles.
* Chaque ligne doit ensuite commencer par une étoile.
* Enfin, il fini par une étoile suivie d'un slash.
*/
protected Vector<Zero> getVectorAmis(){
// Ceci est un commentaire sur une ligne
Vector<Zero> vector = new Vector<Zero>();
/* Ceci est un commentaire sur
plusieurs lignes */
for (Zero z : listeAmis){
vector.add(z);
}
return vector;
}
Commentaires javadoc
/** Description of MyClass
/** Description of myMethod(int a, String b)
*
*
* @author John Doe
* @author Jane Doe
* @version 6.0z Build 9000 Jan 3, 1970.
*/
* @param a Description of a
* @param b Description of b
public class MyClass
* @return Description of c
{
/** Description of myIntField */
*/
public int myIntField;
/** Description of MyClass()
public Object myMethod(int a, String b)
*
* @throws MyException
Description of myException
*/
{
Object c;
public MyClass() throws myException
{
// Blah Blah Blah...
// Blah Blah Blah...
}
return c;
….
}
}
Commentaires javadoc
●
●
●
@param permet de documenter un paramètre de l'élément
@return permet de fournir une description de la valeur de retour d'une
méthode qui en possède une : inutile donc de l'utiliser sur une méthode qui
retourne void.
@throws
l'élément
permet de préciser une exception qui peut être levée par
●
@author permet de préciser le ou les auteurs de l'élément
●
@version permet de préciser le numéro de version de l'élément
●
@see
documenté
permet de préciser un élément en relation avec l'élément
●
@since
permet de préciser depuis quelle version l'élément a été ajouté
●
@deprecated permet de préciser qu'un élément est déprécié
Commentaires Javadoc
●
Project → generate javadoc
●
Project → generate javadoc
●
Du temps de perdu, du temps gagné !
●
Autre format que HTML → Les doclets.
Résumé
●
La JVM est le cœur de Java.
●
Elle fait fonctionner vos programmes Java, précompilés en byte code.
●
Les fichiers contenant le code source de vos programmes Java ont l'extension .java.
●
●
●
Les fichiers précompilés correspondant à vos codes source Java ont l'extension
.class.
Le byte code est un code intermédiaire entre celui de votre programme et celui que
votre machine peut comprendre.
Un programme Java, codé sous Windows, peut être précompilé sous Mac et enfin
exécuté sous Linux.
●
Votre machine NE PEUT PAS comprendre le byte code, elle a besoin de la JVM.
●
Tous les programmes Java sont composés d'au moins une classe.
●
●
Le point de départ de tout programme Java est la méthode public static void
main(String[] args).
On peut afficher des messages dans la console grâce à ces instructions :
–
System.out.println, qui affiche un message avec un saut de ligne à la fin ;
–
System.out.print, qui affiche un message sans saut de ligne.
Les variables et les opérateurs
✗
✗
✗
✗
✗
Les types de variables
Convention de nommage
Les opérateurs arithmétiques
Les conversions (CAST)
Résumé
●
<Type de la variable> <Nom de la variable> ;
●
En Java, nous avons deux types de variables :
–
des variables de type simple ou « primitif » ;
–
des variables de type complexe ou des « Objets »
Les variables de type numérique
byte temperature;
short vitesseMax;
long anneeLumiere;
temperature = 64;
vitesseMax = 32000;
anneeLumiere =
9460700000000000L;
1 octet
2 octets
8 octets
float pi;
double division;
int temperatureSoleil;
pi = 3.141592653f;
division =
0.3333333333333333333333333
33333333333333333334d;
temperatureSoleil =
15600000; //La température
est exprimée en kelvins
4 octets
8 octets
4 octets
Des variables stockant un caractére
●
Le type char contient un caractère stocké
entre apostrophes (« ' ' »), comme ceci :
char caractere;
caractere = 'A';
Les variables booléen
Le type boolean ne peut contenir que deux
valeurs : true (vrai) ou false (faux).
boolean question;
question = true;
Pas de boolean 0/1 comme C++
Et aussi le type String !
Le type String permet de gérer les chaînes de caractères, c'est-àdire le stockage de texte.
//Première méthode de déclaration
String phrase;
phrase = "Titi et Grosminet";
//Deuxième méthode de déclaration
String str = new String();
str = "Une autre chaîne de caractères";
//Troisième méthode de déclaration
String string = "Une autre chaîne";
//Quatrième méthode de déclaration
String chaine = new String("Et une de plus !");
●
●
●
●
tous vos noms de classes doivent commencer
par une majuscule ;
tous vos noms de variables doivent commencer
par une minuscule ;
si le nom d'une variable est composé de
plusieurs mots, le premier commence par une
minuscule, le ou les autres par une
majuscule, et ce, sans séparation ;
tout ceci sans accentuation !
public class Toto{}
public class Nombre{}
public class TotoEtTiti{}
String chaine;
String chaineDeCaracteres;
int nombre;
int nombrePlusGrand;
2 astuces
Déclaration et d'initialisation en une seule phase.
int entier = 32;
float pi = 3.1416f;
char carac = 'z';
String mot = new String("Coucou");
Plusieurs variables d'un même type → une déclaration
int nbre1 = 2, nbre2 = 3, nbre3 = 0;
●
« + » : permet d'additionner deux variables numériques (mais aussi de
concaténer des chaînes de caractères).
●
« - » : permet de soustraire deux variables numériques.
●
« * » : permet de multiplier deux variables numériques.
●
« / » : permet de diviser deux variables numériques.
●
« % » : permet de renvoyer le reste de la division entière de deux variables de
type numérique ; cet opérateur s'appelle le modulo.
int nbre1, nbre2, nbre3; //Déclaration des variables
nbre1 = 1 + 3;
//nbre1 vaut 4
nbre2 = 2 * 6;
//nbre2 vaut 12
nbre3 = nbre2 / nbre1;
//nbre3 vaut 3
nbre1 = 5 % 2;
//nbre1 vaut 1, car 5 = 2 * 2 + 1
nbre2 = 99 % 8;
//nbre2 vaut 3, car 99 = 8 * 12 + 3
nbre3 = 6 % 3;
//là, nbre3 vaut 0, car il n'y a pas de reste
nbre1 = nbre1 + 1;
nbre1 = nbre1 * 2;
nbre1 += 1;
nbre1 *= 2;
nbre1++;
nbre1 = nbre1 / 2;
++nbre1;
nbre1 /= 2;
nbre1 = nbre1 - 1;
nbre1 -= 1;
nbre1--;
--nbre1;
Remarque :
La différence entre x++ ou ++x se fait
ressentir lorsque l'on combine plusieurs
opérations. Avec x++ on utilise la valeur
de x puis on ajoute 1, alors qu'avec ++x
on ajoute d'abord 1, puis on utilise le
résultat. Il en va de même pour x-- et --x.
On ne peut faire du traitement arithmétique que
sur des variables de même type sous peine de
perdre de la précision lors du calcul.
Conversion (cast)
double nbre1 = 10, nbre2 = 3;
int i = 123;
int resultat = (int)(nbre1 / nbre2);
float j = (float)i;
System.out.println("Le résultat est = "
+ resultat);
int i = 123;
double j = (double)i;
// pas de cast :
int nbre1 = 3, nbre2 = 2;
double i = 1.23;
double resultat = nbre1 / nbre2;
double j = 2.9999999;
+ resultat);
int k = (int)i;
// priorité d'opérations
k = (int)j;
//k vaut 1
//k vaut 2
int nbre1 = 3, nbre2 = 2;
double resultat = (double)(nbre1 /
nbre2);
+ resultat);
Conversion (Cast) autrement !
int i = 12;
String j = new String();
j = j.valueOf(i);
int i = 12;
String j = new String();
j = j.valueOf(i);
int k = Integer.valueOf(j).intValue();
Un bonus. avec Java 7
●
La possibilité de formater vos variables de types
numériques avec un séparateur, l'underscore ( _ )
–
double nombre = 1__000____000___000_000;
Interdit :
●
●
double d = 123_.159; int entier = _123; int entier2 =
123_;
Avant Java 7
–
●
int entier = 255; //Peut s'écrire « int entier = 0xFF; »
Après Java 7
–
int entier = 0b100000000000; //Est équivalent à : « int entier
= 2048; »
Résumé
●
●
●
●
●
●
On affecte une valeur dans une variable avec l'opérateur égal (« = »).
Après avoir affecté une valeur à une variable, l'instruction doit se terminer
par un point-virgule (« ; »).
Vos noms de variables ne doivent contenir ni caractères accentués ni
espaces et doivent, dans la mesure du possible, respecter la convention
de nommage Java.
Lorsque vous effectuez des opérations sur des variables, prenez garde à
leur type : vous pourriez perdre en précision.
Vous pouvez caster un résultat en ajoutant un type devant celui-ci : (int),
(double), etc.
Prenez garde aux priorités lorsque vous castez le résultat d'opérations,
faute de quoi ce dernier risque d'être incorrect.
Lire les entrées Clavier
●
La classe Scanner permet d'analyser dans un
flux les types primitifs java et les chaînes de
caractères en utilisant des expressions
régulières
Scanner sc = new Scanner(System.in);
Scanner se trouve dans : java.util.Scanner
import java.util.Scanner
public class Test {
/**
* @param args line de commande
*/
System.out.println("Veuillez saisir un mot :");
String str = sc.nextLine();
System.out.println("Vous avez saisi : " + str);
}
}
public class Pact {
/**
* @param args line de commande
*/
Récupérer un entier ? (nextInt() ) Récupérer un double (nextDouble() ) ?
Récupérer un char ? Récupérer un caractère
}
}
Exploiter les méthodes
●
Exploiter les
méthodes
–
nextInt()
–
nextDouble()
–
nextLine()
–
nextLong()
–
–
nextByte()
charAt()
pour lire depuis le
clavier : un entier, un
double, un long et un
byte.
pour récupérer un
caractère
Les conditions
✗
✗
✗
La structure if … else …
La structure switch
La condition ternaire
La structure if … else ...
if(//condition)
{
//Exécution des instructions si la condition est remplie
}
else
{
//Exécution des instructions si la condition n'est pas remplie
}
int i = 0;
if (i < 0)
System.out.println("Ce nombre est négatif !");
else if(i > 0)
System.out.println("Ce nombre est positif !");
else
System.out.println("Ce nombre est nul !");
●
« == » : permet de tester l'égalité.
●
« != » : permet de tester l’inégalité.
●
« < » : strictement inférieur.
●
« <= » : inférieur ou égal.
●
« > » : strictement supérieur.
●
« >= » : supérieur ou égal.
●
« && » : l'opérateur ET. Il permet de préciser une condition
●
« || » : le OU. Même combat que le précédent.
●
« ? : » : l'opérateur ternaire.
●
« == » : permet de tester l'égalité.
●
« != » : permet de tester l’inégalité.
●
« < » : strictement inférieur.
●
« <= » : inférieur ou égal.
●
« > » : strictement supérieur.
●
« >= » : supérieur ou égal.
●
« && » : l'opérateur ET. Il permet de préciser une condition
●
« || » : le OU. Même combat que le précédent.
●
« ? : » : l'opérateur ternaire.
La structure switch
switch (/*Variable*/)
{
case /*Argument*/:
/*Action*/;
break;
default:
/*Action*/;
}
La structure switch
int note = 10; //On imagine que la note maximale est 20
switch (note)
{
case 0:
System.out.println("Ouch !");
break;
case 10:
System.out.println("Vous avez juste la moyenne.");
break;
case 20:
System.out.println("Parfait !");
break;
default:
System.out.println("Il faut davantage travailler.");
}
La structure switch
//A partir de JRE 1.7
String chaine = "Bonjour";
switch(chaine) {
case "Bonjour":
System.out.println("Bonjour monsieur !");
break;
case "Bonsoir":
System.out.println("Bonsoir monsieur !");
break;
default:
System.out.println("Bonjoir ! :p");
}
La condition ternaire
Les conditions ternaires sont assez complexes
et relativement peu utilisées.
int x = 10, y = 20;
int max = (x < y) ? y : x ; //Maintenant, max vaut 20
int x = 10, y = 20;
int max = (x < y) ? y * 2 : x * 2 ; //Ici, max vaut 40
int x = 10, y = 20;
int max = (x < y) ? ((y < 10) ? y % 10 : y * 2) : x ; //Max vaut 40
Les boucles
✗
✗
✗
La boucle while
La boucle do … while
La boucle for
La boucle while
while (/* condition */) {
//I nstructionsàrépéter
}
La boucle while
●
Nous allons
afficher Bonjour,
<un prénom>,
prénom qu'il
faudra taper au
clavier ; puis nous
demanderons si
l'on veut
recommencer.
La boucle while
//Une variable vide
String prenom;
//On initialise celle-ci à O pour oui
char reponse = 'O';
//Notre objet Scanner, n'oubliez pas l'import de java.util.Scanner !
//Tant que la réponse donnée est égale à oui…
while (reponse == 'O')
{
//On affiche une instruction
System.out.println("Donnez un prénom : ");
//On récupère le prénom saisi
prenom = sc.nextLine();
//On affiche notre phrase avec le prénom
System.out.println("Bonjour " +prenom+ ", comment vas-tu ?");
//On demande si la personne veut faire un autre essai
System.out.println("Voulez-vous réessayer ? (O/N)");
//On récupère la réponse de l'utilisateur
reponse = sc.nextLine().charAt(0);
}
System.out.println("Au revoir…");
//Fin de la boucle
La boucle do ...while
do {
// instructions
} while (/* condition */)
La boucle do … while ()
●
Refaire avec do … while
La boucle for()
for ( /*déclaration des variables avant la
boucle*/ ; /*initialisation*/ ; /*incrémentation*/ )
{
// Instructions
}
La boucle for ...
La boucle for ...
Cumuler les conditions
for(int i=0, j=2 ; (i < 40 && j <60) ; i++, j+=2)
{
System.out.println("i= " + i + " , j = "+ j );
}
TP Conversion Celsius Fahrenheit
TP conversion Celsius - Fahrenheit
●
Formule Math :
–
F = 9/5 x C + 32
–
C = ((F – 32) x 5) / 9
TP conversion Celsius - Fahrenheit
Les tableaux
✗
✗
✗
Tableau à une dimension
Tableau multidimensionnels
Rechercher dans un tableau
Tableau à une dimension
●
Déclaration
<type du tableau> <nom du tableau> [] = { <contenu du tableau>};
// Avec initialisation
int tableauEntier[] = {0,1,2,3,4,5,6,7,8,9};
double tableauDouble[] = {0.0,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0};
char tableauCaractere[] = {'a','b','c','d','e','f','g'};
String tableauChaine[] = {"chaine1", "chaine2", "chaine3" , "chaine4"};
// Sans initialisation
int tableauEntier[] = new int[6];
//Ou encore
int[] tableauEntier2 = new int[6];
Les tableaux multidimensionnels
●
Déclaration.
int premiersNombres[][] = { {0,2,4,6,8},{1,3,5,7,9} };
Utiliser & rechercher dans un
tableau
Ce que je vous propose, c'est tout simplement d'afficher un des tableaux
présentés ci-dessus dans son intégralité. Sachez qu'il existe une instruction
qui retourne la taille d'un tableau : grâce à elle, nous pourrons arrêter notre
boucle (car oui, nous allons utiliser une boucle). Il s'agit de l'instruction <mon
tableau>.length.
Utiliser et rechercher
●
Maintenant, nous
allons essayer de
faire une recherche
dans un de ces
tableaux. En gros il va
falloir effectuer une
saisie clavier et
regarder si celle-ci est
présente dans le
tableau.
String[] str = new String[10];
//L'instruction suivante va déclencher une exception
//Car vous essayez d'écrire à la case 11 de votre tableau
//Alors que celui-ci n'en contient que 10 (ça commence à 0 !)
str[10] = "Une exception";
String tab[][]={{"toto", "titi", "tutu", "tete", "tata"}, {"1",
"2", "3", "4"}};
int i = 0, j = 0;
for(String sousTab[] : tab)
{
i = 0;
for(String str : sousTab)
{
System.out.println("La valeur de la nouvelle boucle est : "
+ str);
System.out.println("La valeur du tableau à l'indice ["+j+"]
["+i+"] est : " + tab[j][i]);
i++;
}
j++;
}
Résumé
●
●
●
●
●
Un tableau est une variable contenant plusieurs
données d'un même type.
Pour déclarer un tableau, il faut ajouter des crochets [
] à la variable ou à son type de déclaration.
Vous pouvez ajouter autant de dimensions à votre
tableau que vous le souhaitez, ceci en cumulant des
crochets à la déclaration.
Le premier élément d'un tableau est l'élément 0.
Vous pouvez utiliser la syntaxe du JDK 1.5 de la
boucle for pour parcourir vos tableaux : for(String str :
monTableauDeString).
Les méthodes de Classe
✗
Quelques méthodes utiles
✗
Créer sa propre méthode
✗
La surcharge de méthode
✗
Résumé
toLowerCase() /* Classe String */
String chaine = new String("COUCOU TOUT LE MONDE !"), chaine2 = new String();
chaine2 = chaine.toLowerCase(); //Donne "coucou tout le monde !"
toUpperCase() /* Classe String */
String chaine = new String("coucou coucou !"), chaine2 = new String();
chaine2 = chaine.toUpperCase(); //Donne "COUCOU COUCOU !"
String chaine = new String("coucou ! ");
double X = 0.0;
int longueur = 0;
X = Math.random();
longueur = chaine.length(); //Renvoie 9
String str1 = new String("coucou"), str2 = new String("toutou");
//Retourne un nombre aléatoire
//compris entre 0 et 1, comme 0.0001385746329371058
if (str1.equals(str2))
System.out.println("Les deux chaînes sont identiques !");
else
System.out.println("Les deux chaînes sont différentes !");
String nbre = new String("1234567");
char carac = nbre.charAt(4); //Renverra ici le caractère 5
double sin = Math.sin(120);
//La fonction sinus
double cos = Math.cos(120);
//La fonction cosinus
double tan = Math.tan(120);
//La fonction tangente
double abs = Math.abs(-120.25); //La fonction valeur absolue
(retourne le nombre sans le signe)
String chaine = new String("la paix niche"), chaine2 = new String();
double d = 2;
chaine2 = chaine.substring(3,13); //Permet d'extraire "paix niche"
double exp = Math.pow(d, 2);
String mot = new String("anticonstitutionnellement");
//Ici, on initialise la variable exp avec la valeur de d élevée au
carré
int n = 0;
n = mot.indexOf('t');
//n vaut 2
n = mot.lastIndexOf('t');
//n vaut 24
n = mot.indexOf("ti");
//n vaut 2
n = mot.lastIndexOf("ti");
n = mot.indexOf('x');
//n vaut 12
//n vaut -1
//La fonction exposant
//La méthode pow() prend donc une valeur en premier
paramètre, et un exposant en second
public class PACT
{
public static void main(String[] args)
{
String[] tab = {"toto", "tata", "titi", "tete"};
parcourirTableau(tab);
}
static void parcourirTableau(String[] tabBis)
{
for(String str : tabBis)
System.out.println(str);
}
}
public class Pact {
public static void main(String[] args)
{
String[] tab = {"toto", "tata", "titi", "tete"};
parcourirTableau(tab);
System.out.println(toString(tab));
}
static void parcourirTableau(String[] tab)
{
for(String str : tab)
System.out.println(str);
}
static String toString(String[] tab)
{
System.out.println("Méthode toString() !\n----------");
String retour = "";
for(String str : tab)
retour += str + "\n";
return retour;
}
}
La surcharge de méthode
Résumé
●
●
●
●
●
Une méthode est un morceau de code réutilisable qui
effectue une action bien définie.
Les méthodes se définissent dans une classe.
Les méthodes ne peuvent pas être imbriquées. Elles
sont déclarées les unes après les autres.
Une méthode peut être surchargée en modifiant le type
de ses paramètres, leur nombre, ou les deux.
Pour Java, le fait de surcharger une méthode lui indique
qu'il s'agit de deux, trois ou X méthodes différentes, car
les paramètres d'appel sont différents. Par conséquent,
Java ne se trompe jamais d'appel de méthode, puisqu'il
se base sur les paramètres passés à cette dernière.

Les bases de Java

Transcription

Documents pareils

Codification des critères de recherche (I.U.T Clermont 1)

String ouvert Josephine String ouvert en Lycra rouge framboise et

Sensual collection Luxe Lookbook 2015

Maillot de bain string transbronzant violet bleu 36

Ashbury Chord Chart.indd

Diplomatic-Cover - Top Interactive Agencies

Procédure d`installation et d`activation de licence : Télécharger la

Télécharger

DISS. ETI-I NO. 16296 ASPECTS OF - ETH E