Les bases de Java - kamrablog.files.wordpress.com · Le type char contient un caractère stocké...

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

Compilation et exécution

Debug

New project

New package

New Class / interface / Ennum / Annotation

Votre premier projet Eclipse

● File → new → Java Projet


● Nouvelle classe.– File → new → class


● Résultat

1 2

3

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

● 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("My name is");

System.out.print("jenesaispas !");

System.out.print("Hello World ! \n");

System.out.println("My name is");

System.out.println("\n jenesaispas");

\t tabulation

\n nouvelle ligne

\r retour chariot

Pour obtenir les mêmes résultats que printf sous C++

Il faut utiliser – System.out.format('' la moyenne de la

classe est %2.2f'',mean) ;


● 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

1

2

Déboguer avec Eclipse

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

*

* @author John Doe

* @author Jane Doe

* @version 6.0z Build 9000 Jan 3, 1970.

*/

public class MyClass

{

/** Description of myIntField */

public int myIntField;

/** Description of MyClass()

*

* @throws MyException Description of myException

*/

public MyClass() throws myException

{

// Blah Blah Blah...

}

….

}

/** Description of myMethod(int a, String b)

*

* @param a Description of a

* @param b Description of b

* @return Description of c

*/

public Object myMethod(int a, String b)

{

Object c;

// 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 permet de préciser une exception qui peut être levée par l'élément

● @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 permet de préciser un élément en relation avec l'élément documenté

● @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

Générer la javadoc avec Eclipse


● 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é

Les types de variables

● <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 »


byte temperature;

temperature = 64;

short vitesseMax;

vitesseMax = 32000;

long anneeLumiere;

anneeLumiere = 9460700000000000L;

int temperatureSoleil;

temperatureSoleil = 15600000; //La température est exprimée en kelvins

double division;

division = 0.333333333333333333333333333333333333333333334d;

float pi;

pi = 3.141592653f;

1 octet 2 octets 8 octets

4 octets8 octets4 octets

Les variables de type numérique


● Le type char contient un caractère stocké entre apostrophes (« ' ' »), comme ceci :

char caractere;

caractere = 'A';

Des variables stockant un caractére


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++

Les variables booléen


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 !");

Et aussi le type String !

Convention de nommage

● 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 !

Convention de nommage

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;

Les opérateurs arithmétiques

● « + » : 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 += 1;

nbre1++;

++nbre1;

nbre1 = nbre1 * 2;

nbre1 *= 2;

nbre1 = nbre1 / 2;

nbre1 /= 2;

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.

nbre1 = nbre1 - 1;

nbre1 -= 1;

nbre1--;

--nbre1;


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)

int i = 123;

float j = (float)i;

int i = 123;

double j = (double)i;

double i = 1.23;

double j = 2.9999999;

int k = (int)i; //k vaut 1

k = (int)j; //k vaut 2

double nbre1 = 10, nbre2 = 3;

int resultat = (int)(nbre1 / nbre2);

System.out.println("Le résultat est = " + resultat);

// pas de cast :

int nbre1 = 3, nbre2 = 2;

double resultat = nbre1 / nbre2;


// priorité d'opérations

int nbre1 = 3, nbre2 = 2;

double resultat = (double)(nbre1 / nbre2);


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

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– nextInt()

– nextDouble()

– nextLong()

– nextByte()

pour lire depuis le clavier : un entier, un double, un long et un byte.

● Exploiter les méthodes – nextLine()

– charAt()

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.

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é

Quelques méthodes utiles

toLowerCase() /* Classe String */

String chaine = new String("COUCOU TOUT LE MONDE !"), chaine2 = new String();

chaine2 = chaine.toLowerCase(); //Donne "coucou tout le monde !"

Quelques méthodes utiles

toUpperCase() /* Classe String */

String chaine = new String("coucou coucou !"), chaine2 = new String();

chaine2 = chaine.toUpperCase(); //Donne "COUCOU COUCOU !"

Quelques méthodes utilesString chaine = new String("coucou ! ");

int longueur = 0;

longueur = chaine.length(); //Renvoie 9

String str1 = new String("coucou"), str2 = new String("toutou");

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

String chaine = new String("la paix niche"), chaine2 = new String();

chaine2 = chaine.substring(3,13); //Permet d'extraire "paix niche"

String mot = new String("anticonstitutionnellement");

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 vaut 12

n = mot.indexOf('x'); //n vaut -1

double X = 0.0;

X = Math.random();

//Retourne un nombre aléatoire

//compris entre 0 et 1, comme 0.0001385746329371058

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)

double d = 2;

double exp = Math.pow(d, 2); //La fonction exposant

//Ici, on initialise la variable exp avec la valeur de d élevée au carré

//La méthode pow() prend donc une valeur en premier paramètre, et un exposant en second

Créer sa propre méthode

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);

}

}

Créer sa propre méthode

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 - kamrablog.files.wordpress.com · Le type char contient un caractère stocké...

Documents

Transcript of Les bases de Java - kamrablog.files.wordpress.com · Le type char contient un caractère stocké...