Cheat to Sheet - Java
LES VARIABLES
// --------- TYPES NUMERIQUES ------------- //
byte temperature; // -128 +127
temperature = 64;
short vitesseMax; // -32768 +32767
vitesseMax = 32000;
int temperatureSoleil; // -2*109 +2*109
temperatureSoleil = 15600000; // kelvins
long anneeLumiere; // -9*10^18 +9*10^18
anneeLumiere = 9460700000000000L; // L à la fin
float pi;
pi = 3.141592653f;
float nombre; // Nombre rond = x.Of
nombre = 2.0f;
double division; // Pareil que Float, sauf que + de chiffres après la virgule
division = 0.333333333333333333333333333333333333333333334d;
// --------- TYPES CARACTERE ------------- //
char caractere;
caractere = 'A';
// --------- TYPES BOOLEEN ------------- //
boolean question;
question = true;
// --------- TYPES STRING ------------- //
String phrase;
phrase = "Titi et Grosminet";
// OU
String str = new String();
str = "Une autre chaîne de caractères";
// OU
String string = "Une autre chaîne";
// OU
String chaine = new String("Et une de plus !");
// --------------------- CONVERSION ------------------------------ //
int i = 123;
float j = (float)i;
int a = 123;
double b = (double)i;
double c = 1.23;
double d = 2.9999999;
int k = (int)c; //k vaut 1
k = (int)d; //k vaut 2
// ------------------------------------------------------ //
// ----------------- ENTREE CLAVIER --------------------- //
// ------------------------------------------------------ //
Scanner sc = new Scanner(System.in);
System.out.println("Veuillez saisir un mot :");
String saisi = sc.nextLine();
System.out.println("Vous avez saisi : " + saisi);
Scanner test = new Scanner(System.in);
int a1 = sc.nextInt();
double b1 = sc.nextDouble();
long c1 = sc.nextLong();
byte d1 = sc.nextByte();
//Etc.
LES CONDITIONS
// --------------------------------------------------- //
// ------------------ OPERATEURS --------------------- //
// --------------------------------------------------- //
« == » : 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.
// --------------------------------------------------- //
// ------------------ CONDITIONS --------------------- //
// --------------------------------------------------- //
// -------- IF > ELSE || IF > ELSE 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; // Initialisaton de i à 0
if (i < 0) // Si i inférieur à 0
System.out.println("Ce nombre est négatif !");
else if(i > 0) // Sinon si i supérieur à 0
System.out.println("Ce nombre est positif !");
else // Sinon
System.out.println("Ce nombre est nul !");
// IF AVEC OPERATEURS
int j = 58;
if(j > 50 && j < 100)
System.out.println("Le nombre est bien dans l'intervalle.");
else
System.out.println("Le nombre n'est pas dans l'intervalle.");
// --------------------- SWITCH --------------------//
int note = 0; //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.");
}
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");
}
// ---------- CONDITION TERNAIRE ---------------- //
int x = 10, y = 20;
int max = (x < y) ? y : x ; //Maintenant, max vaut 20
// Si condition renvoie true, la condition "? y" est affectée, sinon, ": x" est affectée.
LES BOUCLES
//-------------------------------------------------------------------------------//
//------------------------------ WHILE ------------------------------------------//
//-------------------------------------------------------------------------------//
String prenom; // Une variable vide
char reponse = 'O'; // On initialise celle-ci à O pour oui
Scanner sc = new Scanner(System.in); // Notre objet Scanner, n'oubliez pas l'import de java.util.Scanner !
while (reponse == 'O') // Tant que la réponse donnée est égale à oui…
{
System.out.println("Donnez un prénom : "); // On affiche une instruction
prenom = sc.nextLine(); // On récupère le prénom saisi
System.out.println("Bonjour " +prenom+ ", comment vas-tu ?"); // On affiche notre phrase avec le prénom
System.out.println("Voulez-vous réessayer ? (O/N)"); // On demande si la personne veut faire un autre essai
reponse = sc.nextLine().charAt(0); // On récupère la réponse de l'utilisateur
}
System.out.println("Au revoir…");
// Fin de la boucle
// On peut observer dans cette exemple que si l'on ne rentre pas "O" pour oui, celui ci sort de la boucle
//----------------------------- WHILE IMBRIQUE ----------------------------------//
String prenom;
char reponse = 'O'; // Besoin d'initialiser pour rentrer dans la boucle
Scanner sc = new Scanner(System.in);
while (reponse == 'O')
{
System.out.println("Donnez un prénom : ");
prenom = sc.nextLine();
System.out.println("Bonjour " +prenom+ ", comment vas-tu ?");
reponse = ' '; // Sans ça, nous n'entrerions pas dans la deuxième boucle
while(reponse != 'O' && reponse != 'N') // Tant que la réponse n'est pas O ou N, on repose la question
{
System.out.println("Voulez-vous réessayer ? (O/N)"); // On demande si la personne veut faire un autre essai
reponse = sc.nextLine().charAt(0);
}
}
System.out.println("Au revoir…");
// On peut utiliser la boucle DO... While (); pour ne pas avoir à reinitialiser réponse1.
//-------------------------------------------------------------------------------//
//----------------------------------DO WHILE-------------------------------------//
//-------------------------------------------------------------------------------//
String prenom = new String();
char reponse = ' '; //Pas besoin d'initialiser : on entre au moins une fois dans la boucle !
Scanner sc = new Scanner(System.in);
do{ // FAIT BOUCLE 1 (entrée dans la première boucle)
System.out.println("Donnez un prénom : ");
prenom = sc.nextLine();
System.out.println("Bonjour " +prenom+ ", comment vas-tu ?");
do{ // FAIT BOUCLE 2 (entrée dans la deuxieme boucle)
System.out.println("Voulez-vous réessayer ? (O/N)");
reponse = sc.nextLine().charAt(0);
}while(reponse != 'O' && reponse != 'N'); // TANT QUE BOUCLE 2 (fin de la deuxieme boucle)
}while (reponse == 'O'); // TANT QUE BOUCLE 1 (fin de la première boucle)
System.out.println("Au revoir…");
//-------------------------------------------------------------------------------//
//-------------------------------------FOR---------------------------------------//
//-------------------------------------------------------------------------------//
for(int i = 0, j = 2; (i < 10 && j < 6); i++, j+=2){ // Pour i = 0 et j = 2, tant que i < 10 et j > 6 alors, i+1 et J+2
System.out.println("i = " + i + ", j = " + j);
}
//-------------------------------------------------------------------------------//
//----------------------------PRIORITE OPERATEUR---------------------------------//
//-------------------------------------------------------------------------------//
int a = 1, b = 15;
while (a++ < b)
System.out.println("coucou " +a+ " fois !!"); // Affiche 15 fois "coucou x fois!"
System.out.println("FIN");
int c = 1, d = 15;
while (++c < d)
System.out.println("coucou " +c+ " fois !!"); // Affiche 14 fois "coucou x fois!"
// a < b à la priorité sur l'opérateur a++
// ++c à la priorité sur l'opérateur c < d
LES TABLEAUX
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};
int tableauEntier1[] = new int[6]; // Tableau vide
//Ou encore
int[] tableauEntier2 = new int[6];
String tableauChaine[] = {"chaine1", "chaine2", "chaine3" , "chaine4"};
// -------------------------------------------------------------- //
char tableauCaractere[] = {'a','b','c','d','e','f','g'};
for(int i = 0; i < tableauCaractere.length; i++)
{
System.out.println("À l'emplacement " + i +" du tableau nous avons = " + tableauCaractere[i]);
}
// -------------------------------------------------------------- //
int premiersNombres[][] = { {0,2,4,6,8},{1,3,5,7,9} }, i = 0, j = 0;
// premiersNombres [0][2] = 4
// premiersNombres [1][1] = 3
System.out.println("La valeur du tableau est " + premiersNombres[0][2]+".");
while (i < 2) //P1// i = [O] //P2// i = [1]
{
j = 0;
while(j < 5) //P1// [i][j] = [0][0,1,2,3,4] //P2// [i][j] = [1][0,1,2,3,4]
{
System.out.print(premiersNombres[i][j]); //P1// 02468 //P2// 13579
j++;
}
System.out.println("");
i++;
}
// Pareil avec for
for(int i = 0; i < 2; i++)
{
for(int j = 0; j < 5; j++)
{
System.out.print(premiersNombres[i][j]);
}
System.out.println("");
}
// -------------------------------------------------------------- //
String tab[] = {"toto", "titi", "tutu", "tete", "tata"};
for(String str : tab)
System.out.println(str);
String tab[][]={{"toto", "titi", "tutu", "tete", "tata"}, {"1", "2", "3", "4"}};
int i = 0, j = 0;
for(String sousTab[] : tab) // La valeur de tab est mise dans sousTab
{
j = 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 ["+i+"]["+j+"] est : " + tab1[i][j]);
j++;
}
i++;
LES METHODES
Par convention, les métodes s'ecrive avec un miniscule au départ, et majuscule ensuite, ex: getDate
On peut appeler une méthode d'instance pour un objet instancié d'une classe.
ex:
Voiture voiture1 = new Voiture(); // (Création d'une instance de la classe Voiture)
voiture1.getCouleur // On appelle la méthode getCouleur (qui est aussi un accesseur)
public static int somme(int nombre1, int nombre2) //somme est une méthode
{return (nombre1 + nombre2);
}
LA PORTEE
- Aucun mot cle: accessible par les classes du même paquetage ou package.
- Public: accessible par toutes les classes.
- Protected: accessibles par toutes les classes héritées et les classes du même paquetage, inaccessible aux autres.
- Private: inaccessible par toutes les autres classes.
- Static:
- Abstract:
CLASSES ET OBJETS
Par conventions les classes ont une majuscules.
Les variables de classes sont inchangeable, d'ou le static.
public class Point{
public static double dimension = 2; //VARIABLE DE CLASSE
private double x; //VARIABLE D'INSTANCE
private double y; //VARIABLE D'INSTANCE
public Point(){ //CONSTRUCTEUR PAR DEFAULT
this(0,0);
}
public Point(double x, double y){ //CONSTRUCTEUR AVEC ARGUMENT
this.setX(x);
this.setY(y);
}
public double getX(){ //ACCESSEURS X (METHODE)
return this.x;
}
public double setX(double x){ //Point.setX(3) donne x = 3
this.x = x;
}
public double getY(){ //ACCESSEURS Y (METHODE)
return this.x;
}
public double setY(double y){ //Point.setY(6) donne y = 6
this.y = y;
}
}Cheat to Sheet - Summary
Cheat to Sheet - Java #1JAVA LES VARIABLES // --------- TYPES NUMERIQUES ------------- // byte temperature; // -128 +127 temperature = 64; short vitesseMax; // -32768 +32767 vitesseMax = 32000; int temperatureSoleil; // -2*109 +2*109 temperatureSoleil = 15600000; // kelvins long annee…
Bertrand jve