Sun Certified Java Programmer (SCJP)

Sun Certified Java Programmer (SCJP) 1
Chapitre 1
Déclarations et contrôle d’accès
Rappel
Ecrire un programme en JAVA
Ecrire le programme suivant en utilisant bloc-notes de Windows et l’enregistrer sous le nom :
RobotManager.java
public class RobotManager {
public static void main(String[] args) {
Robot robot;
int nargs=args.length;
if(nargs <= 1){
System.out.println("There must be at least two arguments in the
command!");
System.out.println("Example: java RobotManager Mary Kaan");
System.exit(0);
}else {
for(int i=1; i<nargs; i++){
robot = new Robot();
robot.setName(args[i]);
robot.sayHelloTo(args[0]);}
}}}
class Robot {
private String myName = "nobody";
public void setName(String name) {
myName = name;}
public void sayHelloTo(String name) {
System.out.println("Hello " + name + "!");
System.out.println("I'm Robo" + myName + ".");
}}
Dans un fichier contenant plusieurs classes, une seule classe peut être déclarée public. Le nom du fichier
java doit avoir le nom de la classe déclarée public.
Les noms de classes sont sensibles à la casse : RobotManager et robotManager ne sont pas les mêmes.
Compiler un programme écrit en JAVA
En Java le compilateur compile le programme pour fournir un code en bytecode, qui n’est pas un code
exécutable. Le bytecode est quelque part entre le code source et l’exécutable.
Par exemple, pour créer les fichiers bytecode du fichier source RobotManager.java, exécuter le
compilateur Java en utilisant la commande javac comme suit :
javac NomProg.java
Exemple : javac RobotManager.java
Le compilateur crée deux fichiers bytecode avec l’extension .class :
Robot.class et RobotManager.class
Exécuter un programme écrit en JAVA
Un programme java est exécuté en utilisant la commande java comme suit :
java NomProg

Sun Certified Java Programmer (SCJP) 2
Exemple : exécuter le programme RobotManager en invoquant deux valeurs (arguments) : Ginny, 420
Ceci génère les sorties suivantes :
Hello Ginny!
I'm Robo420
Le bytecode dans les fichiers class est interprété par machine virtuelle (Java Virtual Machine (JVM))
quand le programme est exécuté. Le JVM est utilisé suivant la plateforme comme Windows, Solaris, ou
Linux
Figure 1. Le compilateur Java compile le code source en bytecode qui peut être interprété par différents
JVMs installés en différents types de machines. D’où le principe“write once, run anywhere”
1 Eléments d’un programme Java
Un programme Java est composé de classes, une classe consiste de méthodes et des variables.
 classe (class): un modèle à partir du quel les objets sont crées, il décrit l’état et le comportement des
objets de son type.
 Objet (object): Lors de l’exécution, quand Java Virtual Machine (JVM) rencontre le mot clé new, il
utilise la classe appropriée pour créer un objet qui est une instance de la classe. L’objet aura ses
propres variables et l’accès à toutes les méthodes définies par sa classe. Le processus de création
d’un objet est appelé instanciation
 Etat (variables d’instance (state)): chaque objet (instance d’une classe) aura son unique ensemble
de variables instances comme sont définies dans la classe. Les valeurs assignées à une instance de
variables de l’objet créent l’état de l’objet
 Comportement (méthodes (behavior)): Les méthodes instaurent la logique de la classe. C’est où
les algorithmes sont programmés et les données sont manipulées pour déterminer le comportement
de l’objet
2 Identificateurs et mots clés
Classes, variables et méthodes possèdent des noms qui sont appelés identificateurs qui doivent être
différents des mots clés utilisés par le langage Java
Héritage (Inheritance)
L’héritage permet à réutiliser le code d’une classe dans d’autres classes. En Java, il est possible de
définir une superclasse générale (abstraite) et l’étendre (extends) avec des sous-classes plus spécifiques.

Sun Certified Java Programmer (SCJP) 3
La superclasse ne connaît rien des classes qui l’héritent, mais toutes les sous-classes doivent déclarer le
type d’héritage. Une sous-classe qui hérite d’une superclasse aura automatiquement l’accès aux variables
d’instance et aux méthodes définies par la superclasse. Mais aussi il est possible de modifier (override)
les méthodes de la superclasse pour définir un comportement plus spécifique.
Par example, une superclasse voiture doit définir des méthodes communes générales mais une sous-
classe Ferrari doit override la méthode accelerer().
Interfaces
Elles sont comme les superclasses abstraites qui définissent les méthodes qu’une classe doit supporter
mais non comment elles doivent être supportées.
Par exemple : une interface Animal peut déclarer une méthode manger() mais sans fournir une logique
pour la méthode.
Identificateurs
 Identificateurs légaux : doivent se composer des caractères unicodes nombres, symboles ($, £) et
caractères de connexion « _ »
- peuvent commencer par $ , _ ou £ et ne doit pas commencer par un chiffre. Le premier caractère
est suivie par des lettres, chiffres ou $, ou £
- ils sont sensibles à la casse
- ne doivent pas être un mot clé Java
Exemple : mettre une croix devant les identificateurs qui ne sont pas légaux :
x int .f; int _a; int $c; x int :b; x int -d;
x int e#; int ______2_w; x int 7g; int _$;
 Classes et interfaces : La première lettre doit être majuscule. Si l’identificateur se compose de plus
d’un mot, les mots doivent être collés et la première lettre de chaque mot doit être majuscule.
Les noms des classes doivent être typiquement des noms comme : Voiture, Imprimante,
CompteBancaire
Les noms des interfaces doivent être typiquement des adjectifs comme : Runnable, Serializable,
Executable
 Méthodes : La première lettre du premier mot doit être minuscule, les mots doivent être typiquement
des paires de verbes-nom, le deuxième mot doit commencer par majuscule comme : getName,
setBalance, faireClacul
 Variables : Comme les méthodes, doivent commencer par minuscule, s’il se compose plus d’un mot,
les mots qui suivent doivent commencer par majuscule. Exemples : largeurBouton, compteBalance,
maChaine
 Constantes : Les constantes sont créées en les marquant static et final tout en majuscule, les mots
sont séparés par _ ; Exemples : MIN__HAUTEUR
Les standards JavaBeans
Les méthodes qui peuvent changer les valeurs de propriétés sont appelées : setter methods
Les méthodes qui récupèrent les valeurs de propriétés sont appelées : getter methods
 Les règles d’appellation des propriétés en JavaBeans :
- si la propriété n’est pas booléenne, le préfixe de méthodes getter doivent être get. Par exemple,
getSize() est un getter nom valide pour la propriété appelée "size”. Il n’ya pas besoin d’avoir une
propriété “size” le nom de la propriété est inféré à partir de getters et setters et non pas à travers
les variables dans la classe
- si la propriété est booléenne, le préfixe de la méthode getter est ou bien « is » ou « get ». Par
exemple, getStopped() ou isStopped()
- les préfixes des méthodes setter doivent être set. Par exemple setSize()
- les méthodes setter doivent être marquées public avec un type de retour void (void return) et un
argument qui représente le type de propriété

Sun Certified Java Programmer (SCJP) 4
- les méthodes getter doivent être marquées public, sans arguments et ont un type de retour (return
type) qui convient au type de l’argument de la méthode setter pour cette propriété
 Les règles d’appellation de JavaBean Listener
JavaBeans supporte les événements permettant les composants de se notifier mutuellement. Le modèle
d’événement est utilisé dans l’interface GUI. Les objets qui reçoivent l’information sont appelés
listeners. Pour l’examen, il faut savoir l’appellation des méthodes utilisées pour ajouter ou supprimer des
listeners pour un événement.
- Pour enregistrer un listener avec une source d’événement, le préfixe ajouté doit être add suivi du
type du Listener. Par exemple, addActionlistener() est un nom valide de méthode qui permet
l’enregistrement des événements Action.
- Pour supprimer un listener Listener, le nom de la méthode doit utiliser le préfixe remove, suivi
du type du listener
- Le type du listener à ajouter ou à supprimer doit être passé comme argument de la méthode.
Exemples de méthodes valides en JavaBean :
public void setMyValue(int v)
public int getMyvalue()
public boolean isMyStatus()
public void addMyListener(MyListener m)
public void removeMyListener(MyListener m)
Exemples de signatures de méthodes invalides JavaBean :
void setCustomerName(String s) // must be public
public void modifyMyValue(int v) // can't use 'modify'
public void addXListener(MyListener m) // listener type mismatch
Déclaration de classes
Règles de déclaration de fichiers source
 Un fichier code source contient une seule classe déclarée public et plus qu’une classe non déclarée
public. Le nom du fichier (.java) doit être le nom de cette classe déclarée public
 Un fichier qui ne contient pas de classes déclarées public peut avoir un nom qui ne convient pas aux
noms de classes du fichier
 Si la classe fait partie d’un package, une instruction package doit être la première ligne dans le fichier
code source, avant les instructions import s’il y’en a.
 Il n’est pas possible de déclarer plusieurs classes de différents packages dans un même fichier puis
faire des différents import pour les classes
Les modificateurs (Modifiers)
La déclaration suivante est correcte :
class MyClass { }
Mais on peut ajouter des modificateurs avant la déclaration class.
 Modificateurs d’accès: public, protected, private.
 Modificateurs de Non-accès : strictfp, final, abstract
Il y’a quatre niveaux de contrôle d’accès et trois modificateurs d’accès. Le quatrième niveau de contrôle
d’accès est obtenu lorsqu’il n’y a pas utilisation d’un modificateur d’accès dans ce cas le mode d’accès
est dit : par défaut. Chaque, classe, méthode et variables d’instance déclarés ont un contrôle d’accès.
Les modificateurs d’accès utilisés pour une classe sont public et default, les deux autres modificateurs
d’accès n’ont pas de sens pour une classe.
Accès à une classe

Sun Certified Java Programmer (SCJP) 5
Une classe A as un accès à une classe B veut dire elle peut:
 Créer une instance de la classe B
 Hériter (extend) de la classe B (devenir une sous classe de la classe B).
 Accéder en tenant compte du contrôle d’accès à certaines méthodes et variables de la classe B
Accès veux dire visibilité. Si une classe A ne peux pas voir une classe B, le niveau d’accès n’aura pas
d’effet.
Accès par défaut : (pas de modificateur)
 Le niveau d’accès est uniquement au niveau de celui du package
 elle ne peut être vue que par une classe du même package
Si une classe A et une classe B sont dans des packages différents, et A a un accès par défaut, alors:
- la classe B ne pourrait pas être capable de créer une instance de la classe A
- la classe B ne peut pas déclarer une variable ou un type de fonction (return type) de classe A.
Pour B la classe A n’existe même pas
Exemple : - soit une classe d’accès par défaut Beverage crée dans le package cert
package cert;
class Beverage { }
- soit une classe Tea qui hérite de Beverage crée dans le package exam.stuff,
package exam.stuff;
import cert.Beverage;
class Tea extends Beverage { }
Compiler les deux classes, qu’est ce que vous constatez?
=> La classe Beverage compiles bien, mais à la compilation de la classe Tea il s’affiche le message
suivant:
Can't access class cert.Beverage. Class or interface must be
public, in same package, or an accessible member class.
import cert.Beverage;
=> pour que Tea compile il faut:
- mettre les deux classes dans un même package
- declarer Beverage comme public
Accès public
Une classe d’accès public sera accessible à partir de tous les packages. Cependant il faut tenir compte, si
la classe public à utiliser n’est pas dans le même package de la classe en cours de développement, il faut
l’importer.
Exemple : marquer la classe Beverage public, et compiler la classe Tea
 la compilation est effectuée sans problème
Modificateurs de non accès à la classes
Il est possible de modifier la déclaration de classe en ajoutant l’un des modificateurs : final, abstract, ou
strictfp. Ces modificateurs peuvent être en addition au modificateur de contrôle d’accès utilisé, donc, par
exemple, une classe peut être déclaré à la fois public et final. La combinaison des modificateurs n’est pas
toujours possible, strictfp peut être utilisé avec final mais jamais final avec abstract.
- strictfp : est un mot clé qui peut être utilise pour une classe ou une méthode mais jamais une variable.
Marquer une classe strictfp signifie que les méthodes de la classe seront conforme avec les règles
standards IEEE 754 pour les points flottants. Si la classe n’est pas déclarée strictfp, les méthodes
peuvent avoir le comportement (behavior) strictfp chaque méthode sera déclaré à part.
- final : le mot clé final signifie que la classe ne peut pas être héritée (can not be inherited). Une tentation
d’utiliser extends pour hériter d’une classe final, provoque une erreur de compilation.