Post on 25-May-2020
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
Votre premier projet Eclipse
Votre premier projet Eclipse
● Nouvelle classe.– File → new → class
Votre premier projet Eclipse
● Résultat
1 2
3
4
Votre premier projet Eclipse
● 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
*/
public static void main(String[] args) {
System.out.print("Hello tii !");
}
}
Votre premier programme Java
● Run → run
Votre premier programme Java
● 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
Votre premier programme Java
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) ;
Votre premier programme Java
● 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 !
Votre premier programme Java
● 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.
Votre premier programme Java
Déboguer avec Eclipse
1
2
Déboguer avec Eclipse
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
● Project → generate javadoc
Générer la javadoc avec Eclipse
Générer la javadoc avec Eclipse
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 »
Les types de variables
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
Les types de variables
● Le type char contient un caractère stocké entre apostrophes (« ' ' »), comme ceci :
char caractere;
caractere = 'A';
Des variables stockant un caractére
Les types de variables
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
Les types de variables
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
Les opérateurs arithmétiques
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;
Les opérateurs arithmétiques
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;
System.out.println("Le résultat est = " + resultat);
// priorité d'opérations
int nbre1 = 3, nbre2 = 2;
double resultat = (double)(nbre1 / nbre2);
System.out.println("Le résultat est = " + 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
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
Lire les entrées clavier
import java.util.Scanner
public class Test {
/**
* @param args line de commande
*/
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("Veuillez saisir un mot :");
String str = sc.nextLine();
System.out.println("Vous avez saisi : " + str);
}
}
Lire les entrées clavier
public class Pact {
/**
* @param args line de commande
*/
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
Récupérer un entier ? (nextInt() ) Récupérer un double (nextDouble() ) ?
Récupérer un char ? Récupérer un caractère
}
}
Lire les entrées clavier
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
}
La structure if … else ...
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 !");
La structure if … else ...
● « == » : 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 if … else ...
● « == » : 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 !
Scanner sc = new Scanner(System.in);
//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.
Utiliser et rechercher
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";
Utiliser et rechercher
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.