Java Avancé

Partie 1
Java : notions de base

F.Belabdelli

1
Compétences à acquérir

Connaitre les structures de données et les structures de

traitements
Connaitre les notions de base de la POO :
Classe, instance de classe (objet), les méthodes d’instances et les
méthodes de classes (static)
La surcharge
Initialiser des objets (constructeurs)
Utiliser les entrées/sorties (Scanner)
Maitriser les passages de paramètres (par valeur et par
référence)
Utilisation des tableaux de valeurs de type primitifs et des
tableaux d’objets

2
Organisation

PLANNING
45 46 47 48 49 50 51 52
SE 5 2 1 1 1
TP 15 1 3 3 3 3 2
EI 1 1

3
TIOBE Programming Community Index des langages :
nov 2022

4
Définition de Java

Un langage de programmation orienté objets

Une architecture de Virtual Machine
Un ensemble d'API variées
Un ensemble d'outils (le JDK – Java Development Kit)

5
Les caractéristiques du langage Java

Orienté objet Robuste

Interprété Sécurisé
Portable Multi-threads
Simple Distribué

6
Java est un langage Orienté Objet

Tout est classe (pas de fonctions) sauf les types primitifs ( int,
float, double, ...)
Toutes les classes dérivent de java.lang.Object
Héritage simple pour les classes
Héritage multiple pour les interfaces
Les objets se manipulent via des références
Une API objet standard est fournie
La syntaxe est proche de celle de C

7
Java est portable

Le compilateur Java génère du byte code.

La Java Virtual Machine (JVM) est présente sur Unix, Win32,
Mac, OS/2, Netscape, IE, ...
La taille des types primitifs est indépendante de la plate-forme.
Java supporte un code source écrit en Unicode.
Java est accompagné d'une librairie standard.

8
Java est robuste

A l’origine, c'est un langage pour les applications embarquées.

Gestion de la mémoire par un garbage collector.
Pas d’accès direct à la mémoire.
Mécanisme d'exception.
Accès à une référence null : exception.
compilateur contraignant (erreur si exception non gérée, si
utilisation d’une variable non affectée, ...).
Tableaux = objets (taille connue, débordement ® exception).
Seules les conversions sûres sont automatiques.
Contrôle des cast à l'exécution.

9
Java est multi-thread

Intégrés au langage et aux API :

synchronized
garbage collector dans un thread de basse priorité
java.lang.Thread, java.lang.Runnable

10
Java est distribué

API réseau (java.net.Socket, java.net.URL, ...).

Applet.
Servlet.
Remote Method Invocation.
JavaIDL (CORBA).

11
 Premier exemple

Dans un fichier de nom HelloWorld.java

Règle: toute classe publique doit être dans un fichier qui a le même nom que la classe
Règle: tout code doit être à l'intérieur d'une classe

public class HelloWorld{

/*Un style de commentaire
sur plusieurs lignes.*/
public static void main(String[] args){
//Un commentaire sur une seule ligne
System.out.println("Bonjour à vous les I1 !");
}
}

Ça définit une classe, qui est une unité de compilation

Comme il y a une méthode main, cette classe est « exécutable »
12
Compilation, bytecode et JVM
Compilation du langage source  Exécution du bytecode
Fichier HelloWorld.java Bonjour à vous les I1 !
public class HelloWorld {
/* Un style de commentaire sur plusieurs lignes. */
public static void main(String[] args) { Pile Tas
// Un commentaire sur une seule ligne
System.out.println("Bonjour à vous les CPi2!");
} Linux
}
Java Virtual Machine
Interprétation / exécution
javac HelloWorld.java java HelloWorld (write once, run everywhere)

Fichier HelloWorld.class Bonjour à vous les I1 !

Compilation Compiled from "HelloWorld.java"
public class HelloWorld extends java.lang.Object{
(une seule fois) public HelloWorld(); Pile Tas
Code:
0: aload_0
1: invokespecial
4: return
#1; //Method java/lang/Object."<init>":()V
Windows
public static void main(java.lang.String[]);
Code: Java Virtual Machine
0: getstatic #2; //Field java/lang/System.out:Ljava/io/PrintStream;
3: ldc #3; //String Bonjour à vous les CPi2!
5: invokevirtual #4; //Method java/io/PrintStream.println:(Ljava/lang/String;)V

}
8: return
java HelloWorld

13
Conventions de nommage

pas obligatoires, mais très fortement recommandées (car

important pour la lisibilité du code et sa maintenance)
identificateurs en minuscules, sauf :
majuscule au début des « sous-mots » intérieurs :
• unExempleSimple
début des noms en majuscule pour classes et interfaces (et
elles seules) :
UnNomDeClasse
pour les constantes, majuscules et séparation des mots par _
final int VALEUR_MAX;
pas d'emploi de $ (caractères spéciaux)

14
La nature des variables en java

Les variables locales comme les attributs des classes et des objets
ne peuvent être que de deux natures :
De type « primitif »
Dans ce cas, la déclaration de la variable réserve la place
mémoire pour stocker sa valeur (qui dépend de son type)
int entier; long entier

De type « objet », ou référence

Dans ce cas, la déclaration de la variable ne fait que réserver la place d'une
référence (une sorte de pointeur) qui permettra d'accéder à l'endroit en mémoire
où est effectivement stocké l'objet en lui-même (vaut null si référence inconnue)

# @ class Pixel
Pixel p1;
p1=new #1 1 x=1 objet
Pixel(1,3); référence Y=3

15
Les types primitifs
Types entiers signés (représentation en complément à 2)
byte (octet) sur 8 bits: [-128 .. 127]
short sur 16 bits [-32768 .. 32767]
int sur 32 bits [-2147483648 .. 2147483647] (défaut pour entiers)
long sur 64 bits [-9223372036854775808 .. 9223372036854775807]
Type caractère non signé (unités de code UTF-16)
char sur 16 bits ['\u0000' .. '\uffff']
Types à virgule flottante (représentation IEEE 754)
float sur 32 bits
double sur 64 bits (défaut pour flottants)
Type booléen : boolean (true ou false)

16
Promotion entière et flottants spéciaux

Pour la plupart des opérations, les valeurs entières sont transformés en des « int »
(promotion entière):
short s = 4;
s = s+s; // Type mismatch: cannot convert int to short
s = (short) (s+s); // cast nécessaire

Les débordements ou cas d'erreurs sont prévus pour les flottants (Infinity et Not-a-
Number):
double d = 1e308; System.out.println(d*10);
// affiche: Infinity

d = 0.0/0.0;
System.out.println(d); // affiche: NaN

17
Tous les autres types sont objets et se manipulent par une
référence
soit des types définis dans les APIs
java.lang.Object, java.lang.String, java.util.Scanner, etc.
String chaine = "toto"; # @class String
#1
1 #2
...
En plus, les String sont constantes
soit des types « cachés » #2 t o t o \n

Tableau de types primitifs ou d'autres types « objets »

#1 @class int[]
int[] tab = {3, 5, 7, 9}; #1 length = 4
String[] args; null #2 @class Pixel[] 3
Pixel[] array = new Pixel[2]; #2 length = 2 5
null 7
soit des types définis par l'utilisateur
null 9
Pixel p = new Pixel(0,0);
21

18
Types java et passage de paramètres

Lors des appels de méthode, les arguments sont toujours

passés par valeur
Dans le cas des types primitifs, c'est la valeur de l'argument
qui est recopiée dans le paramètre de la méthode
Les modifications sur le paramètre de la méthode sont sans effet
sur l'argument
Dans le cas des types « objet », c'est la valeur de la variable,
(la référence à l'objet) qui est transmise à la méthode
Les modifications effectuées en suivant cette référence (e.g.
modification d'un attribut de l'objet) sont répercutés dans la mémoire
et sont donc visibles sur l'argument
En revanche, la modification de la référence elle-même est sans
effet sur l'argument (c'en est une copie)

19
 Passage de paramètres : type primitif

Dans le cas des types primitifs, c'est la valeur de l'argument qui est recopiée dans le
paramètre de la méthode
Les modifications sur le paramètre de la méthode sont sans effet sur l'argument

public static void m1(int i) { i 5 6

i++;
}

public static void main(String[] args) {

int entier = 5;
m1(entier); entier 5
System.out.println(entier); // 5
}

20
Passage de paramètres : type référence
Dans le cas des types « objet », c'est la valeur de la variable, (la référence à l'objet)
qui est transmise à la méthode
Les modifications effectuées en suivant cette référence (e.g. modification d'un attribut
de l'objet) sont répercutés dans la mémoire et sont donc visibles sur l'argument

# 1 @class Box
public static void m2(Box b) { b #1 field = 5
b.field++;
}
6
public static void main(String[] args) {
Box box = new Box(); #1
box
box.field = 5;
M2(box); class Box {
System.out.println(box.field); //6 int field;
} }

21
Passage de paramètres : type référence
Dans le cas des types « objet », c'est la valeur de la variable, (la référence à l'objet)
qui est transmise à la méthode
En revanche, la modification de la référence elle-même est sans effet sur l'argument
(c'en est une copie) @class Box
#2
field = 6
tmp #2
public static void m3(Box b) {
Box tmp = new Box();
tmp.field = b.field+1; b #1 #2 #1 @class Box
b = tmp; field = 5
}
public static void main( String[] args){
Box box = new Box(); #1
box
box.field = 5;
m3(box); class Box {
System.out.println(box.field);// 5 int field;
} }

22
Type référence et valeur null

Lorsqu'on déclare une variable de type objet, seule la place de

la référence est réservée sur la pile d'exécution (registre)
4 octets, 32 bits, et ce quelque soit le type de l'objet référencé
Par défaut, cette référence vaut une valeur particulière, null.
Il est interdit de tenter d'y accéder, de la déréférencer
Le compilateur vérifie ce qu'il peut
public static void main(String[] args) {
Box b;
System.out.println(b.field); // Variable b might not have been initialized
}

On peut « forcer » pour que ça compile => lève une exception

public static void main(String[] args) {
Box b = null;
System.out.println(b.field); // lève NullPointerException

23
Allocation mémoire

Pour qu'une variable objet prenne une autre valeur que null, il
faut être capable d'y affecter une référence
Elle peut être produite (retournée) par l'opérateur d'allocation new
Cet opérateur a besoin de connaître la taille de l'objet qu'il doit réserver en mémoire
• Le nom du type / de la classe suit immédiatement l'opérateur

new Box(); // j'ai besoin de stocker 1 int (field)

new int[10]; // stocker 10 int + la taille du tableau
• La zone mémoire allouée doit être initialisée (affectation des valeurs)

new Pixel(1,3); // utilise un « constructeur »

• Ce que retourne l'opérateur new est la référence qui permet d'accéder à l'objet alloué en
mémoire

24
Désallocation mémoire

Elle n'est pas gérée par le programmeur, mais par un GC

(Garbage Collector)
Les objets qui ne sont plus référencés peuvent être « récupérés »
par le GC, pour « recycler » l'espace mémoire qu'ils occupent
Un même objet peut être référencé par plusieurs variables
Il faut qu'aucune variable ne référence plus un objet pour qu'il
soit réclamé
Les variables cessent de référencer un objet
Quand on leur affecte une autre valeur, ou null
Quand on quitte le bloc où elles ont été définies: elles meurent,
disparaissent... (sur la pile)

25
Références et Garbage collector

La quantié de mémoire disponible dans le tas de la VM est fixé

à l'avance (paramétrable): java -Xms<size> MyAppli
C'est le gestionnaire de la mémoire qui se charge de
L'allocation des nouveaux objets
• Demandée par l'opérateur new
La récupération de la place occupée par les objets morts (devenus
inaccessibles)
• Lorsqu'il y a besoin de place supplémentaire ou quand il le décide
De la manière d'organiser les objets
• Pour éviter une « fragmentation « de la mémoire, il « déplace » les objets en
mémoire (zone des « vieux » des « récents », etc.)
• Les références ne sont pas des adresses (indirection)

26
Classes et objets

Une classe Toto représente plusieurs choses :

Une unité de compilation
• La compilation d'un programme qui contient une classe Toto produira un fichier
Toto.class
La définition du type Toto
• Il peut servir à déclarer des variables comme Toto
Un moule pour la création d'objets de type Toto
• Cela nécessite en général la définition d'un ensemble d’attributs (fields, champs,
variables) décrivant l'état d'un objet de ce type et d'un ensemble de méthodes
définissant son comportement ou ses fonctionnalités
Chaque objet de la classe Toto
• Dispose de son propre état (la valeur de ses attributs)
• Répond au même comportement (via les méthodes de la classe)

27
Exemple
public class Pixel {
public final static int ORIGIN = 0;
Constante
private int x;
private int y;
public Pixel(int x, int y) {
Attributs
this.x = x;
this.y = y;
} Constructeur
public void reset() {
x = ORIGIN;
y = ORIGIN; Méthodes
} d’instances
public void printOnScreen() {
System.out.println("("+x+","+y+")");
}
public static boolean same(Pixel p1, Pixel p2) {
return (p1.x==p2.x) && (p1.y==p2.y); Méthode de classe
}
public static void main(String[] args) {
Pixel p0 = new Pixel(0,0); // (0,0)
Pixel p1 = new Pixel(1,3);// (1,3) Variables locales à
p1.printOnScreen(); la méthode main
System.out.println(same(p0,p1));//false et objets de la
p1.reset();
System.out.println(same(p0,p1));//true
classe Pixel
}
}

28
Les objets sont manipulés via une référence
Classe Pixel
Lorsque la méthode
#s ORIGIN = 0
p1.reset();

Chaque objet connait sa classe

constructeur
est appelée, le code de la
méthode définie dans la méthodes
classe comme main

public void reset() {

x = ORIGIN;
y = ORIGIN; Pixel p1 #1
} #1 @ class Pixel

Pixel p2 #2 x=1 0
est exécuté sur la pile avec les
y=3 0
références #1 à la place de p1
et #s à la place de ORIGIN #2 @ class Pixel

public void reset() { x=0

#1.x = #s; Ce qui a pour effet de y=0
#1.y = #s;
} mettre p1.x et p1.y à 0

29
Les tableaux

Fournissent des collections ordonnées d'éléments

Composants d'un tableau peuvent être
des variables des types de base (int, byte, short, long, boolean, double,
float, char)
des références sur des objets (tableaux d’objets)
Les tableaux = objets en java (et pas seulement une suite
d'emplacements mémoire comme en C/C++)

30
Les tableaux : déclaration

Déclaration
typeDesElements [ ] nomDuTableau;

typeDesElements un des types de base du langage JAVA (char, int, float,

double...) ou un nom de classe

nomDuTableau : l’identificateur pour désigner le tableau la déclaration

typeDesElements nomDuTableau[]; est aussi possible mais des deux

formes de déclaration on préférera la première car elle place la déclaration de
type en un seul endroit.

31
Tableaux : création des éléments
typeDesElements [ ] nomDuTableau;
définit (déclare) un identificateur nomDuTableau qui permettra de désigner (référencer)
un tableau du type déclaré ("tableau d'éléments de type typeDesElements").
mais ne crée pas de tableau en mémoire. (nomDuTableau == null)
Pour utiliser un tableau, après la déclaration d’un identificateur permettant de le désigner,
il faut ensuite explicitement "créer" ce tableau en mémoire.
la "création" s’effectue à l’aide de l’opérateur new (utilisé pour créer des objets, les
tableaux sont des objets).
nomDuTableau = new typeDesElements[taille]

recherche, tri, etc. : voir fonctions utilitaires de la classe Arrays (cf java.util)

32
Tableaux : création des éléments

La création d’un tableau par new

alloue la mémoire nécessaire en fonction
du type du tableau
de la taille spécifiée
initialise le contenu du tableau
type simple : 0
type complexe (classe) : null

33
Tableaux : index d’un élément

accès à un élément d'un tableau s'effectue à l'aide d'une expression

de la forme :
nomDuTableau[expression1]
expression1 est une expression entière qui définit l’index dans le tableau de
l’élément considéré
Java vérifie automatiquement l'indice lors de l'accès (comparaison
avec la borne)
Si hors limites : ArrayIndexOutOfBoundsException
Evite des bugs !
nomDuTableau.length donne la taille du tableau nomDuTableau
int[] tabEntiers = new int[10]
tabEntiers.length 10 taille du tableau
tabEntiers.length -1 indice max de tabEntiers

34
Tableaux : autres déclarations

Une autre manière de créer des tableaux :

en donnant explicitement la liste de ses éléments à la
déclaration (liste de valeurs entre accolades)
exemples :
int[] t1 = { 1, 2 ,3, 4, 5};
char[] codes = { 'A', 'a', 'B', 'z' };
l’allocation mémoire (équivalent de l’utilisation de new) est
prise en charge par le compilateur

35
Tableaux d’objets

Des tableaux contenant des (références à des) objets d’une classe

donnée peuvent être déclarés et créés pour toute classe (prédéfinie
ou bien écrite par le programmeur).
Par exemple, un tableau de chaînes de caractères (classe String) se
déclare et se dimensionne ainsi :
String[] tabChaines;
tabChaines = new String[2];
ATTENTION : le dimensionnement d’un tableau d’objets crée
uniquement des « cases » pour stocker des références aux objets,
mais pas les objets eux-mêmes. Ces références valent initialement
null, et il faut donc les faire ensuite pointer vers les objets voulus par
des affectations.
Par exemple, une suite possible des instructions précédentes est :
tabChaines[0] = "OUI";
tabChaines[1] = "NON";

36
Entrées/Sorties

//écriture :
float z=1.732f;
System.out.print("z=");
System.out.print(z);
System.out.println(",2z=" + (2*z));
//lecture :
// Lecture d'un caractère à la fois
int car = System.in.read();
// Lecture de 10 caractères
byte buf[] = new byte[10];
int nbLus = System.in.read(buf);

37
Lecture formatée

Il existe une méthode nextXyz() et une méthode

hasNextXyz() pour chaque type primitif xyz import java.util.Scanner;
//…
Lance InputMismatchException si l’élément Scanner sc = new Scanner(System.in);
suivant n’est pas convertible dans le type String ch = sc.next();
demandé int k = sc.nextInt();
double val;
Possibilité de choisir un séparateur avec if ( sc.hasNextDouble() )
val = sc.nextDouble();
useDelimiter(Pattern) String ligne = sc.nextLine();
ATTENTION :
utilise, par défaut, le format « local » des nombres (par
exemple en français : 2,5 et pas 2.5) ;
possibilité de choisir une« localisation » avec la
méthode useLocale()

38
Classe et Objet

Définition
Constructeurs
Variables de classe ou Attributs
Méthodes de classe
La référence this
Constantes
Le main()
Initialiseur statique
Destructeur et Finalisation

39
Exemple de programme

// Début du fichier : les « import »

import java.util.Scanner;
// Toutes les autres instructions sont dans une
// (ou plusieurs) classe(s)
public class MonProgramme {
// Un programme « ordinaire » contient toujours une
// fonction principale (main) comme ci-dessous :
public static void main(String[] args){
System.out.print("Entrez un int : ");
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
for (int i=0; i<n; i++) {
System.out.println(i);
} // fin de la boucle for
} // fin de la fonction main
} // fin de la définition de la classe

40
La référence this

possibilité dans les méthodes de désigner explicitement

l'instance courante :
pour accéder à un attribut « masqué » par un paramètre :
class Cercle {
double rayon=0;

// ...
double comparerA(double rayon){
return this.rayon-rayon; class Cercle {
} } void dessinerSur(Ecran e){

// ...
pour appeler une fonction (ou méthode) }
}
avec l'instance courante en paramètre : class Ecran {
// ...
void tracer(Cercle c){
c.dessinerSur(this);
}
}

41
L’encapsulation

cacher le détail d'implantation, et ne laisser voir que l'interface

fonctionnelle
pour chaque attribut et méthode, visibilité possible :
public
private
protected
par défaut, accès « package » class Cercle {
private double rayon;
public double calculerSurface() {
encapsulation « usuelle » : attributs return Math.PI*rayon*rayon;
}
privés, et méthodes publiques
// ...
(sauf celles à usage interne) : }

42
Encapsulation des membres

class c1 { Package P1 Package P2

public int A;
protected int B; class c4 extends c1 {
int C; ...
private int D; }
}

class c3
class c2 extends c1 class c5 {
{
{ ...
...
... }
}
}

A B C D
Accessible par c2 o o o -
Accessible par c3 o - o -
Accessible par c4 o o - -
Accessible par c5 o - - -

43
Le constructeur

Contient les instructions à exécuter à la création des instances (en

particulier : l’initialisation des attributs)

class Cercle {
private double rayon;
public double calculerSurface(){
return Math.PI*rayon*rayon;
}
public Cercle(double r) {
rayon = r;
}

Est appelé à chaque création d'instance (par new) :

Cercle c = new Cercle(2.5);
NOTA-BENE : jamais de type de retour (ce n’est pas une méthode)

44
Le constructeur

Il peut y avoir plusieurs constructeurs (mais les signatures

doivent être différentes)
On peut invoquer un constructeur depuis un autre avec this(...) :
class Cercle {
// ...
public Cercle(double r) {
rayon = r;
}
public Cercle() {
this(0); // invoque Cercle(0)
}
}
Conseils :
écrire un constructeur « complet » avec tous les paramètres possibles ;
ensuite, faire en sorte que tous les autres constructeurs (en général un
constructeur sans argument et un pour construire par recopie d'un
objet de même type) appellent le constructeur « complet »

45
Le destructeur

appelé par le « ramasse-miettes » (garbage collector ou GC) avant de

supprimer l'objet
donc habituellement jamais appelé explicitement
utile essentiellement pour fermer des fichiers associés à l'instance et
susceptibles d'être encore ouverts à sa disparition
protected void finalize() {...}
appelé une seule fois par instance (donc pas ré-appelée par le GC si
appelé « à la main » avant)

46
Attribut et méthode static

Les variables static sont communes à toutes les instances de la

classe.
Il n'est pas nécessaire d'instancier une classe pour accéder à
un de ses membres statiques.
Les méthodes statiques ne peuvent pas accéder à this.

47
Exemples de méthodes et d’attributs
public class Circle {
public static int count = 0;
public static final double PI = 3.14; // final pour éviter
//Circle.PI = 4;
public double x, y, r;

public Circle(double r) {
this.r = r;
count++;
}
public Circle bigger(Circle c) {
if (c.r > r) return c;
else return this;
}
public static Circle bigger(Circle c1, Circle c2) {
if (c1.r > c2.r) return c1;
else return c2;
}
}
public static void main(String[] args) {
Circle c1 = new Circle(10); Circle c2 = new Circle(20);
n = Circle.count; // n = 2;
Circle c3 = c1.bigger(c2); // c3 = c2;
Circle c4 = Circle.bigger(c1, c2); // c4 = c2
}
48
Cas particulier de classe

Classe ayant un nombre FINI d’instances, toutes prédéfinies

Mot-clef : enum (au lieu de class) enum Jeune {
Exemple d’énumération « simple » BEBE("Bebe", 0, 3),
ENFANT ("Enfant", 3, 12),
et « élaboré » : ADO("Adolescent", 12, 18);
private String type;
private int ageMin;
private int ageMax;
enum Reponse {
Jeune(String type, int ageMin, int ageMax){
OUI, NON, PEUT_ETRE
this.type = type;
}
this.ageMin = ageMin;
//…
this.ageMax = ageMax;
Reponse r1 = Reponse.OUI;
}

public String getType(){ return type; }

public int getAgeMin(){ return ageMin; }
public int getAgeMax(){ return ageMax; }
}
if ( age < Jeune.BEBE.getAgeMax() ) {
Jeune j1 = Jeune.BEBE;

49
Les packages

entité de structuration regroupant plusieurs classes (et/ou

interfaces) et/ou sous-paquetages
Un package regroupe un ensemble de classes sous un même
espace de 'nommage'.
Les noms des packages suivent le schéma : name.subname ...
Une classe Watch appartenant au package time.clock doit se
trouver dans le fichier time/clock/Watch.class
Les packages permettent au compilateur et à la JVM de
localiser les fichiers contenant les classes à charger.
L'instruction package indique à quel package appartient la ou
les classe(s) de l'unité de compilation (le fichier).

50
Les packages

Les répertoires contenant les packages doivent être présents

dans la variable d'environnement CLASSPATH
En dehors du package, les noms des classes sont :
packageName.className
L'instruction import packageName permet d'utiliser des classes
sans les préfixer par leur nom de package.
Les API sont organisées en package (java.lang, java.io, ...)

51
Les packages
CLASSPATH =
$JAVA_HOME/lib/classes.zip;$HOME/classes

~dedieu/classes/graph/2D/Circle.java ~dedieu/classes/graph/3D/Sphere.java
package graph.2D; package graph.3D;
public class Circle public class Sphere
{ ... } { ... }

~dedieu/classes/paintShop/MainClass.java__________________________________
package paintShop;
import graph.2D.*;
public class MainClass
{
public static void main(String[] args) {
graph.2D.Circle c1 = new graph.2D.Circle(50)
Circle c2 = new Circle(70);
graph.3D.Sphere s1 = new graph.3D.Sphere(100);
Sphere s2 = new Sphere(40); // error: class paintShop.Sphere not found
}

52
Packages JAVA

Package Description
java.applet Classes nécessaires à la création d’applets
java.awt Abstract Windowing Toolkit  Interfaces graphiques, événements…
java.beans Pour le développement de composants JavaBeans
java.io Pour la gestion des IO systèmes (système de fichiers, etc.)
java.lang Classes fondamentales du langage (toujours importées par défaut)
java.math Pour les traitements arithmétiques demandant une grand précision
java.net Pour les connexions et la gestion réseau
java.nio Définit des tampons
java.rmi Toutes les classes liées au package RMI (Remote Method Invokation)
java.security Classes et interfaces du framework de sécurité Java
java.sql Pour l’accès et la gestion des bases de données  JDBC
java.text Pour la manipulation de texte, dates, nombres et messages
java.util Collections, modèle événementiel, dates/heures, internationalisation
Packages JAVAX

Package Description
javax.accessibility Définit un contrat entre l’U.I. et une technologie d’assistance
javax.crypto Pour les opérations liées à la cryptographie
javax.imageio Pour la gestion des IO liées aux images
javax.naming Pour la gestion de la Java Naming and Directory Interface (JNDI)
javax.net Pour les connexions et la gestion réseau
javax.print Pour les services liés à l’impression
javax.rmi Toutes les classes liées au package RMI (Remote Method Invokation)
javax.security Classes et interfaces du framework de sécurité Java
javax.sound Pour le développement d’application gérant le son (Midi / Sampled)
javax.sql Pour l’accès et la gestion des bases de données  JDBC
javax.swing Interfaces graphiques « légères », identiques sur toutes plateformes
javax.transaction Exceptions liées à la gestion des transactions
javax.xml Parseurs et autres classes liées au format XML