JAVA

DÉCLARATION DE VARIABLES
DÉCLARATION DE VARIABLES
LES OPÉRATEURS D'ASSIGNATION ET D'INCRÉMENTATION
LES OPÉRATEURS D'ASSIGNATION ET D'INCRÉMENTATION
LES OPÉRATEURS DE COMPARAISON
LES OPÉRATEURS LOGIQUES
(BOOLÉENS)
LES OPÉRATEURS BIT-À-BIT
LECTURE/ÉCRITURE DANS UNE
VARIABLE
TRAITEMENT CONDITIONNEL
OPÉRATEUR TERNAIRE
CHOIX MULTIPLES: SWITCH
INSTRUCTION RÉPÉTITIVE / WHILE
INSTRUCTION RÉPÉTITIVE / BOUCLE
IMBRIQUÉE
INSTRUCTION RÉPÉTITIVE / DO
INSTRUCTION RÉPÉTITIVE / FOR
INSTRUCTION BREAK
INSTRUCTION CONTINUE
INSTRUCTION CONTINUE
EXERCICES D’APPLICATION

● Écrire un programme JAVA qui déclare deux variables a et b

de type int et qui demande à l’utilisateur de saisir les valeurs
par le clavier. Puis on affiche la somme, la soustraction, la
multiplication et la division de a par b.

● Écrire une méthode qui prend comme arguments 3 variables

de type int et affiche ces variables triées dans l’ordre
croissant.
EXERCICES D’APPLICATION

● On vous demande de reprendre l’exercice précédent

d’application 1. Au lieu d’afficher les 4 opérations à la fois.
● On demande à l’utilisateur de spécifier l’opération à effectuer:
1. Ajouter une variable choix de type byte;
2. Demander à l'utilisateur de choisir l’opération souhaitée
selon le code (1 l’addition; 2 la multiplication; 3 la
soustraction; 4 la division)
TABLEAUX

● TABLEAUX

Un tableau est un ensemble indexé de données d'un même type.

L'utilisation d'un tableau se décompose en trois parties :
● Création du tableau ;
● Remplissage du tableau ;
● Lecture du tableau.
TABLEAUX

● Création d'un tableau

Un tableau se déclare et s'instancie comme une classe :

int monTableau[ ] = new int[10]; ou int [ ] monTableau = new
int[10];

L'opérateur [ ] permet d'indiquer qu'on est en train de déclarer un tableau.

Dans l'instruction précédente, nous déclarons un tableau d'entiers (int, integer) de taille 10, c'est-
à-dire que nous pourrons stocker 10 entiers dans ce tableau.
Si [ ] suit le type, toutes les variables déclarées seront des tableaux, alors que si [ ] suit le nom de la
variable, seule celle-ci est un tableau :
int [] premierTableau, deuxiemeTableau;
float troisiemeTableau[], variable;
TABLEAUX

● Remplissage d'un tableau

Une fois le tableau déclaré et instancié, nous pouvons le remplir :
int [] monTableau = new int[10];

monTableau[5] = 23;

L'indexation démarre à partir de 0, ce qui veut dire que, pour un tableau de N éléments, la numérotation va de 0 à N-1.
Dans l'exemple ci-dessus, la 6ème case contient donc la valeur 23.
Nous pouvons également créer un tableau en énumérant son contenu :
int [] monTableau = {5,8,6,0,7};

Ce tableau contient 5 éléments.

Lorsque la variable est déjà déclarée, nous pouvons lui assigner d'autres valeurs en utilisant l'opérateur new :
monTableau = new int[]{11,13,17,19,23,29};
TABLEAUX

● Lecture d'un tableau

Pour lire ou écrire les valeurs d'un tableau, il faut ajouter l'indice entre crochets ([ et ]) à la suite du nom du tableau :
int [] monTableau = {2,3,5,7,11,23,17};
int nb;

monTableau[5] = 23; // -> 2 3 5 7 11 23 17

nb = monTableau[4]; // 11

L'indice 0 désigne le premier élément du tableau.

L'attribut length d'un tableau donne sa longueur (le nombre d'éléments). Donc pour un tableau nommé monTableau l'indice du
dernier élément est monTableau.length-1.
Ceci est particulièrement utile lorsque nous voulons parcourir les éléments d'un tableau.
for (int i = 0; i < monTableau.length; i++)
{ int élément = monTableau[i];
// traitement
}
TABLEAUX

● Parcours des tableaux

int[] monTableau = {150, 200, 250};
for (int élément : monTableau)
{ // traitement
}

Attention néanmoins, la variable element contient une copie de monTableau[i]. Avec des tableaux contenant des variables
primitives, toute modification de élément n'aura aucun effet sur le contenu du tableau.
// Vaine tentative de remplir tous les éléments du tableau avec la valeur 10
for(int élément : monTableau)
{ élément = 10;
// Ou plus court :
} Arrays.fill(monTableau, 10);
// La bonne méthode :
for(int i=0 ; i<monTableau.length ; i++) Pour éviter de modifier la variable, utilisez le mot-clé final :
{ monTableau[i] = 10;} for (final int élément : monTableau)
{
 TABLEAUX

● Tableaux à plusieurs dimensions

int[][] matrice = new int[5][];
for (int i=0 ; i<matrice.length ; i++)
matrice[i] = new int[6];

Java permet de résumer l'opération précédente en :

int[][] matrice=new int[5][6];

La première version montre qu'il est possible de créer un tableau de tableaux n'ayant pas forcément tous la même dimension.
On peut également remplir le tableau à la déclaration et laisser le compilateur déterminer les dimensions des tableaux, en imbriquant les accolades :
int[][] matrice =
{
{ 0, 1, 4, 3 } , // tableau [0] de int
{ 5, 7, 9, 11, 13, 15, 17 } // tableau [1] de int
};
TABLEAUX

● Tableaux à plusieurs dimensions

Pour déterminer la longueur des tableaux, on utilise également l'attribut length :

matrice.length // 2
matrice[0].length // 4
matrice[1].length // 7

De la même manière que précédement, on peut facilement parcourir tous les éléments d'un tableau :
for (int i=0 ; i<matrice.length ; i++)
{
for (int j=0 ; j<matrice[i].length ; j++)
{
//Action sur matrice[i][j]
}
}
TABLEAUX

● Tableaux à plusieurs dimensions

Pour déterminer la longueur des tableaux, on utilise également l'attribut length :

matrice.length // 2
matrice[0].length // 4
matrice[1].length // 7

De la même manière que précédement, on peut facilement parcourir tous les éléments d'un tableau :
for (int i=0 ; i<matrice.length ; i++)
{
for (int j=0 ; j<matrice[i].length ; j++)
{
//Action sur matrice[i][j]
}
}
POO: La visibilité de vos membres dans une classe

● La visibilité de vos membres dans une classe

La visibilité publique - public
La visibilité protégée - protected
La visibilité « package private »
La visibilité privée - private
● La visibilité de vos membres dans une interface
● Changement de visibilité en cas de redéfinition de méthodes
● La visibilité des vos classes
Les classes publiques
Les classes « package private »
La visibilité des classes internes (inner classes)
POO: La visibilité de vos membres dans une classe

La visibilité publique - public

Si vous définissez un membre (attribut, méthode...) public il sera alors accessible de n'importe
ou dans le programme. La classe aura donc accès à ce membre, mais aussi n'importe quelle
autre classe.
public class Demo {

public int attribute = 10;

public void doSomething() {

System.out.println( "Do something" );
}

}
POO: La visibilité de vos membres dans une classe

La visibilité protégée - protected

Un membre marqué dans une classe comme étant protégé (mot clé protected) peut être
manipulé :

● Dans la classe qui définit ce membre,

● Dans les classes qui dérivent de la classe considérée,
● Et dans toutes les classes (et les types) définies dans le même package que celle qui
définit le membre protégé.
package fr.koor.sample;
import java.awt.Point;

class Shape {
protected Point center = new Point(); // Essayez avec un private => Ko
}
class Circle extends Shape {
public Circle() {
super();
System.out.println( "Center == " + this.center );
}
}
public class Sample {

public static void main( String[] args ) {

Circle c = new Circle();
// TODO
}
}
POO: La visibilité de vos membres dans une classe

La visibilité « package private »

En l'absence de mot clé pour spécifier la visibilité, un membre sera considéré comme étant «
package private » (on peut simplifier en parlant de visibilité package). C'est donc le mode de
visibilité par défaut (absence de mot clé). Cela veut dire que le membre sera accessible par
tout code Java localisé dans le même package. Voici un exemple d'utilisation.
package fr.koor.sample;

public class TestVisibility {

public int attr1 = 10;
protected int attr2 = 20;
int attr3 = 30; // Visibilité package private !
private int attr4 = 40;

}
POO: La visibilité de vos membres dans une classe

Si une autre classe du même package essaye d'utiliser la classe TestVisibility, elle aura
accès aux membres de type « package private » (mais aussi aux membres protégés et
publics). Voici un exemple de code.
package fr.koor.sample;

public class OtherClass {

public static void main( String [] args ) {

TestVisibility test = new TestVisibility();

System.out.println( test.attr1 ); // Tout le monde a accès à un membre public.
System.out.println( test.attr2 ); // On est dans le même package => Ok.
System.out.println( test.attr3 ); // On est dans le même package => Ok.
//System.out.println( test.attr4 ); // Pas possible, car privé.

}
 POO: La visibilité de vos membres dans une classe

La visibilité privée - private

Dans ce dernier cas, seule la classe ayant définit le membre pourra y accéder.

package fr.koor.sample;

public class Demo {

private static int privateAttribute = 10;

public static void main( String [] args ) {

System.out.println( "J'ai accès à l'attribut static privé : " + privateAttribute );

}
}
 POO: La visibilité de vos membres dans une interface

Les règles pour une interface ne sont pas les mêmes que pour les classes. En premier lieu, en l'absence de mot clé,
un membre d'interface est implicitement public. Cela implique de la visibilité « package private » n'est pas possible
pour un membre d'interface. Au passage, la visibilité protected n'est pas supportée non plus.

En conséquence l'interface suivante défini deux méthodes publiques.

package fr.koor.sample;
public interface Demo {
void doSomething(); // Par défaut, visibilité "public"
void doAnother(); // Par défaut, visibilité "public"
}
L'interface ci-dessus est donc strictement équivalente à celle proposée ci-dessous.

package fr.koor.sample;
public interface Demo {
public abstract void doSomething();
public abstract void doAnother();
}
 POO: Changement de visibilité en cas de redéfinition de méthodes

En cas de redéfinition de méthodes (héritage ou implémentation d'interface), il est possible de modifier la visibilité de
ces méthodes. Mais attention, vous devez respecter une règle : vous pouvez ouvrir la visibilité et non pas la
restreindre.

Par exemple, la classe Object définie la méthode clone permettant de cloner un objet : cette méthode est déclarée
comme étant protected. Si vous souhaitez redéfinir cette méthode pour permettre le clonage de vos instances, vous
pouvez « ouvrir » sa visibilité et la rendre publique. Voici un exemple concret.
package fr.koor.sample;
public class Matrix extends Object {

int [][] data;

public Matrix( int lines, int columns ) {
data = new int[lines][];
for( int i=0; i<lines; i++ ) {
data[i] = new int[columns];
for( int j=0; j<columns; j++ ) {data[i][j] = ( int) (Math.random() * 10);}
}}
// Exemple d'ouverture de visibilité de la méthode sur une redéfinition.
// Essayer de changer public par protected (ok) puis par private (ko).
@Override
public Matrix clone() throws CloneNotSupportedException {
int lines = data.length;
int columns = data[0].length;

Matrix copy = new Matrix( lines, columns );

for( int i=0; i<lines; i++ ) {
data[i] = new int[columns];
for( int j=0; j<columns; j++ ) { copy.data[i][j] = this.data[i][j]; }
}
return copy; }

public static void main(String[] args) throws Exception {

Matrix m = new Matrix(3, 3);
Matrix m2 = m.clone();
// La suite ... }}
 POO:La visibilité des vos classes

Les classes publiques

Pour rappel, vous pouvez définir qu'une seule classe publique par fichier. Cette classe publique doit
avoir très exactement le même nom que celui du fichier (sans l'extension, bien entendu) et de
manière « case sensitive ». Une classe publique est accessible en tout point de votre programme
Java. Je ne reviendrais pas plus sur cette possibilité, on en parle déjà depuis le début de ce tutoriel
Java.
 POO:La visibilité des vos classes
Les classes « package private »

Un fichier de code Java peut contenir bien plus qu'une seule définition de classe. Mais, outre la
classe publique, les autres seront considérés comme des classes restreintes au package dans
lequel est placé le fichier. Elles ne devront porter aucun qualificateur de visibilité.

package fr.koor.sample;
// Classe visible uniquement dans le package fr.koor.sample.
class PrivateClass {

public PrivateClass() {
System.out.println( "PrivateClass constructor" );
}}
// Classe publique visible dans tout le projet.
public class Sample {
public Sample() {
PrivateClass obj = new PrivateClass();
// TODO
}}
 POO:La visibilité des vos classes
La visibilité des classes internes (inner classes)

Une classe interne est une classe définie à l'intérieur d'une autre classe. Si elle est définie sous
forme de membre de la classe portante, alors vous pourrez utiliser un des quatre niveaux de
visibilité classiques : public, protected, package private, private. Voici un exemple de définition
d'une classe interne.

package fr.koor.sample;
public class OuterClass {

// Accessible uniquement dans la classe OuterClass.

private class InnerClass {
}
public OuterClass() {
InnerClass inner = new InnerClass();
// TODO
}
}
POO: this and super

super() est utilisé pour appeler le constructeur de la classe de base (classe parent).

class Animal { // Superclass (parent)

public void animalSound() {
System.out.println("The animal makes a sound");
}
}

class Dog extends Animal { // Subclass (child)

public void animalSound() {
super.animalSound(); // Call the superclass method
System.out.println("The dog says: bow wow");
}
}

public class Main {

public static void main(String args[]) {
Animal myDog = new Dog(); // Create a Dog object
myDog.animalSound(); // Call the method on the Dog object
}
POO: this and super

this() est utilisé pour appeler le constructeur de la classe actuelle .

public class Main {

int x;
// Constructor with a parameter
public Main(int x) {
this.x = x;
}
// Call the constructor
public static void main(String[] args) {
Main myObj = new Main(5);
System.out.println("Value of x = " + myObj.x);
}
}
POO: static

static signifie que quelque chose est directement lié à une classe :

● si un champ est static, il appartient à la classe → Attributs de classe

● si une méthode est static (méthode statique), elle appartient à la classe → méthode de classe.

Par conséquent, tu peux utiliser le nom de la classe pour appeler une méthode static ou référencer un champ
static.

Par exemple,

si le champ count est static dans la classe Counter, tu peux référencer la variable avec l'expression suivante :
Counter.count.
POO: static

● Tu ne peux PAS accéder aux membres non static d'une classe dans un contexte static, comme une méthode
ou un bloc static. La compilation du code ci-dessous générera une erreur :

public class Counter {

private int count;
public static void main(String args []) {
System.out.println(count); // Compile time error
}
}
● Les méthodes static ont un avantage pratique en cela qu'il n'y a pas besoin de créer un nouvel objet chaque
fois que tu veux les appeler.
POO: static

● Un autre point important est que vous ne pouvez pas remplacer (@Override) les méthodes statiques. Si
vous déclarez une telle méthode dans une subclass, c'est-à-dire une méthode avec le même nom et la
même signature, vous "cachez" simplement la méthode de la superclass au lieu de la remplacer. Ce
phénomène est connu sous le nom method hiding. Cela signifie que si une méthode static est déclarée à
la fois dans la classe parent et la classe enfant, la méthode appelée sera toujours celle du type de la
variable au moment de la compilation. Contrairement à ce qui arrive avec le remplacement de méthode,
ces méthodes ne seront pas exécutées lors de l'exécution du programme.
Prenons un exemple :
class Vehicle {
public static void kmToMiles(int km) {
System.out.println("Inside the parent class"); public class Demo {
}} public static void main(String args []) {
class Car extends Vehicle { Vehicle v = new Car();
public static void kmToMiles(int km) {
v.kmToMiles(10);
System.out.println("Inside the child class");
}}
}}
 POO: final

Un attribut peut être déclaré comme final. Cela signifie qu’il n’est plus possible d’affecter une valeur à cet attribut une fois qu’il a
été initialisé. Dans cas, le compilateur exige que l’attribut soit initialisé explicitement.

public class Voiture {

public String marque;

public float vitesse;
public final int nombreDeRoues = 4;

final porte sur l’attribut et empêche sa modification. Par contre si l’attribut est du type d’un objet, il est possible de modifier l’état
de cet objet.

public class Facture { Facture facture = new Facture();

facture.voiture.marque = "DeLorean"; // OK
public final Voiture voiture = new
Voiture(); facture.voiture = new Voiture() // ERREUR
DE COMPILATION
}
 POO:Attributs de classe finaux

Pour déclarer un attribut de classe, on utilise le mot-clé static.

public class Voiture {

public static final int nombreDeRoues = 4;

public String marque;
public float vitesse;

}
 POO:Class Object

Java est un langage qui ne supporte que l’héritage simple. L’arborescence d’héritage est un arbre dont la racine est la
classe Object. Si le développeur ne précise pas de classe parente dans la déclaration d’une classe, alors la classe
hérite implicitement de Object.
La classe Object fournit des méthodes communes à toutes les classes. Certaines de ces méthodes doivent être
redéfinies dans les classes filles pour fonctionner correctement.
● La méthode equals: En Java, l’opérateur == sert à comparer les références. Il ne faut donc jamais l’utiliser pour
comparer des objets. La comparaison d’objets se fait grâce à la méthode equals héritée de la classe Object.
● La méthode hashCode:La méthode hashCode est fournie pour l’utilisation de certains algorithmes, notamment pour
l’utilisation de table de hachage. Le principe d’un algorithme de hachage est d’associer un identifiant à un objet. Cet
identifiant doit être le même pour la durée de vie de l’objet. De plus, deux objets égaux doivent avoir le même code de
hachage.
● La méthode toString:La méthode toString est une méthode très utile, notamment pour le débugage et la production de
log. Elle permet d’obtenir une représentation sous forme de chaîne de caractères d’un objet.
● La méthode finalize:La méthode finalize est appelée par le ramasse-miettes avant que l’objet ne soit supprimé et la
mémoire récupérée. Redéfinir cette méthode donne donc l’opportunité au développeur de déclencher un traitement avant
que l’objet ne disparaisse.
● La méthode getClass: La méthode getClass permet d’accéder à l’objet représentant la classe de l’instance.
 POO:Class Object

● La méthode clone:La méthode clone est utilisée pour cloner une instance, c’est-à-dire obtenir une copie d’un objet. Par
défaut, elle est déclarée protected car toutes les classes ne désirent pas permettre de cloner une instance.
Pour qu’un objet soit clonable, sa classe doit implémenter l’interface marqueur Cloneable. L’implémentation par défaut de
la méthode dans Object consiste à jeter une exception CloneNotSupportedException si l’interface Cloneable n’est pas
implémentée. Si l’interface est implémentée, alors la méthode crée une nouvelle instance de la classe et affecte la même
valeur que l’instance d’origine aux attributs de la nouvelle instance. L’implémentation par défaut de clone n’appelle pas les
constructeurs pour créer la nouvelle instance.

RQ:Par défaut, tous les tableaux implémentent l’interface Cloneable et redéfinissent la méthode clone afin de la rendre public.
On peut donc directement cloner des tableaux en Java si on désire en obtenir une copie.

int[] tableau = {1, 2, 3, 4};

int[] tableauClone = tableau.clone();
 POO:String

En Java, les chaînes de caractères sont des instances de la classe String. Les chaînes de caractères
écrites littéralement sont toujours délimitées par des guillemets :

"Hello World"

Contrairement à d’autres langages de programmation, une chaîne de caractères ne peut pas être
traitée comme un tableau. Si on souhaite accéder à un caractère de la chaîne à partir de son
index, il faut utiliser la méthode String.charAt. On peut ainsi parcourir les caractères d’une chaîne

String s = "Hello World";

for (int i = 0; i < s.length(); ++i) {

char c = s.charAt(i);
System.out.println(c);
}
 POO:String

Quelques méthodes utilitaires

String.equals: Compare la chaîne de caractères avec une autre chaînes de caractères.

String.equalsIgnoreCase: Comme la méthode précédente sauf que deux chaînes qui ne diffèrent que par
la casse seront considérées comme identiques.

String.compareTo:Compare la chaîne de caractères avec une autre chaînes de caractères. La comparaison

se fait suivant la taille des chaînes et l’ordre lexicographique des caractères. Cette méthode retourne 0 si les
deux chaînes sont identiques, une valeur négative si la première est inférieure à la seconde et une valeur
positive si la première est plus grande que la seconde.
 POO:String

Quelques méthodes utilitaires

String.compareToIgnoreCase:Comme la méthode précédente sauf que deux chaînes qui ne diffèrent que
par la casse seront considérées comme identiques.

String.concat :Concatène les deux chaînes dans une troisième. Cette méthode est équivalente à l’utilisation
de l’opérateur +.

String.endsWith / String.startsWith: Retourne true si la chaîne se termine / commence par une

chaîne de caractères donnée.

String.isEmpty: Retourne true si la chaîne est la chaîne vide (length() vaut 0)

String.length: Retourne le nombre de caractères dans la chaîne.
 POO:String

Quelques méthodes utilitaires

String.replace: Remplace un caractère par un autre dans une nouvelle chaîne de caractères.Cette méthode
est surchargée pour accepter des chaînes de caractères comme paramètres.

String.substring: Crée une nouvelle sous-chaîne à partir de l’index de début et jusqu’à l’index de fin (non
inclus).

String.toUpperCase / String.toLowerCase: Crée une chaîne de caractères équivalente en

majuscules / minuscules.

String.trim: Crée une nouvelle chaîne de caractères en supprimant les espaces au début et à la fin.
 POO:Les exception

La gestion des cas d’erreur représente un travail important dans la programmation. Les sources d’erreur
peuvent être nombreuses dans un programme. Il peut s’agir :

● d’une défaillance physique ou logiciel de l’environnement d’exécution. Par exemple une erreur
survient lors de l’accès à un fichier ou à la mémoire.
● d’un état atteint par un objet qui ne correspond pas à un cas prévu. Par exemple si une opération
demande à positionner une valeur négative alors que cela n’est normalement pas permis par la
spécification du logiciel.
● d’une erreur de programmation. Par exemple, un appel à une méthode est réalisé sur une variable
dont la valeur est null.
● et bien d’autres cas encore…
 POO:Les exception

Une exception est une classe Java qui représente un état particulier et qui hérite directement ou indirectement de la classe
Exception.

NullPointerException

NumberFormatException

IndexOutOfBoundsException