Memo Java

De Avided.info
Aller à : navigation, rechercher


La JVM est le cœur de Java. Elle fait fonctionner vos programmes Java, pré-compilé 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 sauf si vous ajouter les caractères d’échappements ex: \n.

constuction d'un appel de methode: c'est termes sont toujours utilisé : classe.objet.methode

Compilation et Execution

Les outils d'aide au developpement comme Eclipse represente souvent la comilation par un engrenage et l'execution avec un bouton |> comme les boutons play.

En ligne de commande

Compilation

Cette commande crée un fichier Code_Source.class. Il contient les information que la JVM (Java Virtual Machine) comprend.

javac Code_Source.java

Execution

Attention on ne mais aucune extension, même si le binaire en a une.

java Code_Source

Type de variables

Type primitive

// 1 octet  -128 à +127
byte temperature = 30;  
// 2 octets                 
short vitesseMax 32000 ;    
// 4 octets - de -2*109 à 2*109. Le type int (4 octets) va de -2*109 à 2*109             
int temperatureSoleil = = 15600000;   
// 8 octets - de -9*10^18 à 9*10^18. Le type long (8 octets) peut aller de -9*10^18 à 9*10^18. Il doit finir par L   
long anneeLumiere = 9460700000000000L ; 

// 4 octets - Le type float est utilisé pour les nombres avec une virgule flottante. 
float nombre = 2.0f;      
// 8 octets - Le type double est utilisé pour les nombres avec une virgule flottante,               
double division = 0.333333333333333333333333333333333333333333334d; 

//Le type char contient un caractère stocké entre apostrophes (« ' ' »),
char caractere = 'A'; 

// Le type boolean ne peut contenir que 2 valeurs true(vrai) ou false(faux) 
question = true;

Type évolué

Il est possible de construire dans des classes ses propres type de données. Le type String fait partie de ces types de variable. Même si il fait partie de classe integré à Java.

// Le type String permet de gérer les chaines de caractères. Ce type est un peux spécial, on remarque qu'il commence par une majuscule String String phrase = "Une chaine de caractere"; </pre>

Voir les class pour plus de détails

Les opérateurs arithmétiques

Ils ne peuvent pas être surchargé sauf le + pour les String

« + » : permet d'additionner deux variables numériques, mais aussi de concaténer des chaînes de caractère.
« - » : permet de soustraire deux variables numériques.
« * » : permet de multiplier deux variables numériques.
« / » : permet de diviser deux variables numériques (mais je crois que vous aviez deviné).
« % » : permet de renvoyer le reste de la division entière de deux variables de type numérique ; cet opérateur s'appelle le modulo.

Raccourcie : Dans tous ces cas, le résultat sera le même. Seul une différence de comportement entre les 2 dernières méthodes

nbre1 = nbre1 + 1;
nbre1 += 1;
nbre1++;
++nbre1;

Celui-ci ajoute 2

nbre1 += 2;

les conversions

Aussi appeler caste en java Pour passer d'un type de variable à un autres

int i = 123;
float j = (float)i;

Sur un calcul Dans ce cas, le calcul est fait avant le caste. Donc les arrondit sont déjà effectué. Il faut caster chaque chiffre avant calcul pour avoir un calcul plus juste

double nbre1 = 10, nbre2 = 3;
int resultat = (int)(nbre1 / nbre2);
System.out.println("Le résultat est = " + resultat);

Meme vers une chaine, c'est possible !

int i = 12;
String j = new String();
j = j.valueOf(i); // a cette endroit, "j" vaux la chaîne de caractère 12
int k = Integer.valueOf(j).intValue(); // "k" retrouve un valeur numérique ) à 12 ici 


Toutes les conversions sont possible, mais attention à la perte de précision.

Formatage

Il est possible d’écrire une valeur de différente façon. La valeur sera interprété de la même façon. Dans ce domaine beaucoup d’amélioration depuis la version 7 de java.

Mais a quoi cela peut-il bien servir.

-Une relecture plus facile -une valeurs récupérer dans un des formats utilisable

ex: 1000000000 peux s'ecrire

1__000___000_000 => ici nous avons ajouter des _ afin que le lecteur puisse compter les 0 facilement. Le nombre de _ n'est pas important

0x3B9ACA00 => hexadecimal commence par 0x 

0b111011100110101100101000000000 => binaire commence par 0b

Les valeurs des caractères

Codage unicode sur 16 bites ~ 65000 caractères
'a' 'c' '3' '\n' '\t' …
'\uxxxxx ou xxxxx est hexadécimal de '\u0000' à '\uffff'

ASCII '\u0000' à '\u00ff'

Utilisation de classe

Il y a un certain nombre de classe automatiquement chargé avec Java.
Il existe des classes externes spécialisés pour certaine taches qui peuvent être utilisé.
Ces classe sont réunis par famille dans des packages.
Pour utiliser une classe, il est nécessaire de la charger.
Il faudra pour cela indique le chemin du package et la classe a charger.
Si vous utilisez beaucoup de classes d'un même package, il est possible de charger tous les classe d'un package.

Le package java.util contient entre autre la classe scanner qui permet de récupérer des informations depuis l'entrée standard.
Pour utiliser cette classe, il faut l'importer (charger).

Importer une classe

//Ceci importe la classe Scanner du package java.util
import java.util.Scanner; 
//Ceci importe toutes les classes du package java.util
import java.util.*;

Utiliser une classe

Pour utiliser cette classe, il y à plusieurs étapes.
Il faut instancier la classe

Le type de variable de str mais aussi nextInt nous l'indique. Si vous modifier le type de variable et remplacer nextInt par nextXxx pour récupérer d'autre type ex: "String str = sc.nextLine();"

Scanner sc = new Scanner(System.in);
System.out.println("Veuillez saisir un nombre :");
int str = sc.nextInt();
System.out.println("Vous avez saisi le nombre : " + str);
  • La lecture des entrées clavier se fait via l'objet Scanner.
  • Ce dernier se trouve dans le package java.util que vous devrez importer.
  • Pour pouvoir récupérer ce que vous allez taper à la console, vous devrez initialiser l'objet Scanner avec l'entrée standard, System.in.
  • Il y a une méthode de récupération de données pour chaque type (sauf les char) : nextLine() pour les String, nextInt() pour les int ...
  • Une astuce pour récupérer qu'un seul caractère :
String str = sc.nextLine();
char carac = str.charAt(0);

Les conditions

Les opérateurs logiques

  • « == » : 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. Pour celui-ci, vous comprendrez mieux avec un exemple qui sera donné vers la fin de ce chapitre.

IF

  • La syntaxe
if(//condition)
{
  //Exécution des instructions si la condition est remplie
}
else if(//autre condition)
}
  // execution des instruction si la 1er condition n'est pas remplie, mais que la 2eme l'est
}
else
{
  //Exécution des instructions si aucune condition n'est remplie
}
    • Condition multiple
if(i < 100 && i > 50) 

SWITCH

switch (/*Variable*/)
{
  case /*Argument*/:
    /*Action*/;
    break;        
  default:
    /*Action*/;             
}

le switch peux comparer des chaines de caractères depuis la version 7

  • Exemple :
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.");
}

TERNAIRE

int x = 10, y = 20;
int max = (x < y) ? y * 2 : x * 2 ; //Ici, max vaut 2 * 20 donc 40

ternaire imbriqué

int x = 10, y = 20;
 
int max = (x < y) ? (y < 10) ? y % 10 : y * 2 : x ; //Max vaut 40
 
//Pas très facile à lire…
//Vous pouvez entourer votre deuxième instruction ternaire par des parenthèses pour mieux voir :
 
max = (x < y) ? ((y < 10) ? y % 10 : y * 2) : x ; //Max vaut 40

les boucles

while

Répété le bloque d'instruction jusqu’à ce que la condition soit vrai

  • syntaxe :
while (/* Condition */)
{
  //Instructions à répéter
}

do

Répété le bloc d'instruction jusqu'a ce que l'instruction soit vrai, mais la condition est testé après avoir exécuter le bloc d'instruction. Donc le code est exécute au moins une fois

  • syntaxe :
do{
  //Instructions
}while(a < b);

for

Cette boucle est spécial, elle prend tous ces attributs dans sa condition

  • La déclaration des variables qui ne seront initialiser qu'une fois avant l’exécution de la boucle
  • La condition a remplir
  • Incrémentation de la variable a chaque tour de boucle

Syntaxe : dans cette exemple il y a 2 compteurs i et j

for(int i = 0, j = 2; (i < 10 && j < 6); i++, j+=2){
  System.out.println("i = " + i + ", j = " + j);
}

Les tableaux

Un tableau contient toujours le même type d'information. Il est typé.

A une dimension

  • 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"};
  • lire
for(int i = 0; i < tableauCaractere.length; i++)
{
  System.out.println("À l'emplacement " + i +" du tableau nous avons = " + tableauCaractere[i]);
}

Une autre manière de l’écrire depuis JAVA 1.7, plus simple, mais ne nous permet pas d'avoir l'indice sans ajouter de compteur

for(int valeur : tableauCaractere)
  System.out.println(valeur);

Multi-dimension

Le nombre de couple [] indique le nombre de dimension. La règle de type dans un tableau est toujours vrai. On ne peux pas mélanger les types de données dans un mmême tableau. Même dans des dimension différente.

  • initialisation
int Nombres[][] = { {0,1,2,3,4},{10,20,30,40} };
  • lire

Remarquez que les nombre sont vue comme des String car ils sont entre ' " '

Syntaxe a partir de JAVA 1.7

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


Lire les entrées

nécessite l'import d'une classe

 import java.util.Scanner;
Scanner entre = new Scanner(System.in);
System.out.println("Saisiser une entree : ");
String recup = entre.nextLine();
System.out.println("Votre entree est : "+recup); 

En fonction du type a récupérer

int i = sc.nextInt();
double d = sc.nextDouble();
long l = sc.nextLong();
byte b = sc.nextByte();
</prer>

== Sources d'informations ==

[http://www.siteduzero.com/informatique/tutoriels/apprenez-a-programmer-en-java[[http://www.siteduzero.com/informatique/tutoriels/apprenez-a-programmer-en-java]]]