46 /∗∗
47 ∗ Lecture d ’un e n t i e r au c l a v i e r . 48 ∗ @param prompt Message a a f f i c h e r 49 ∗ @return L ’ e n t i e r l u
50 ∗ @exception NumberFormatException en cas d ’ erreur 51 ∗/
52 p u b l i c s t a t i c i n t r e a d I n t ( f i n a l S t r i n g prompt )
53 throws NumberFormatException {
54 printPrompt ( prompt ) ;
55 return I n t e g e r . valueOf ( readLine ( ) . trim ( ) ) . i n t V a l u e ( ) ;
56 } 57 /∗∗
58 ∗ Lecture d ’un double au c l a v i e r . 59 ∗ @param prompt Message a a f f i c h e r
60 ∗ @return Le double l u
61 ∗ @exception NumberFormatException en cas d ’ erreur 62 ∗/
63 p u b l i c s t a t i c double readDouble ( f i n a l S t r i n g prompt )
64 throws NumberFormatException {
65 printPrompt ( prompt ) ;
66 return Double . valueOf ( readLine ( ) . trim ( ) ) . doubleValue ( ) ;
67 } 68 } # 27 ' & $ %
2.2 Types Primitifs
pas des classes
short(2 octets), int (4 octets), long (8 octets) float (4 octets), double (8 octets)
boolean (true/false), byte (1 octet), char (2 octets) Variables déclarées n’importe où dans un bloc
Les types primitifs ne sont pas des classes. Ils permettent de définir des variables ou des attributs. Comme nous l’avons dit dans la section précédente, les tailles et domaines de valeurs sont définis strictement. Vous retrouvez les types communs correspondant aux nombres entiers signés du langage C : short, int, long.
Les nombres en virgule flottantes float et double sont conformes à la norme IEEE 754. Le type boolean est nouveau. Il ne peut prendre que les valeurs true ou false.
Le type byte correspond au type char du langage C. C’est un type entier exprimé sur 8 bits en complément à 2 dont la valeur peut varier de -128 à +127.
Le type char quant à lui est utilisé pour contenir un caractère codé sur 16 bits en Unicode.
2 Concepts de bases de Java 2.2 Types Primitifs # 28 ' & $ %
2.2.1 Conversions de type
Conversions sur les types primitifs :
Conversions sûres OK (d’un type vers un type plus complexe)
Conversions non sûres (d’un type vers un type plus pauvre) nécessitent un transtypage (en anglais, cast) explicite
Les conversions entre types primitifs sont plus strictes qu’en langage C. Ainsi, les conversions qui vont d’un type simple vers un type plus complexe sont acceptées. Cependant, celles qui vont d’un type complexe vers un type plus simple doivent être associées à un transtypage explicite.
# 29 ' & $ %
2.2.2 Exemple de conversions
1 p u b l i c c l a s s CastExampleFixed { 2 p u b l i c s t a t i c v o i d main ( f i n a l S t r i n g [ ] a r g s ) { 3 i n t i = 2127272 ; // 0 x002075A8 4 l o n g m; 5 s h o r t s ; 6 b y t e b ; 7 m = i ; // promotion OK 8 // E x p l i c i t c a s t needed 9 i = ( i n t ) m; 10 s = ( s h o r t ) i ; // 0x75A8 11 b = ( byte ) i ; // 0xA8 12 System . out . p r i n t l n ( "m=␣ " + m + " ; ␣ s=␣ " + s + " ; ␣b=␣ " + b ) ; 13 } 14 } Résultat de l’exécution : m= 2127272; s= 30120; b= -88;Introduction au langage de programmation Java 2 Concepts de bases de Java # 30 ' & $ %
2.2.3 Tableaux
Les tableaux sont des objets Leur taille est fixe
Leur taille est allouée dynamiquement par l’utilisation du mot réservé new L’accès aux entrées est identique à celle en langage C une fois l’allocation faite Erreur d’accès en cas de dépassement de taille
Nous avons dit précédemment que les tableaux étaient des objets. Ils n’ont pas la capacité à changer de taille, mais ils doivent être alloués dynamiquement.
Ils sont traités de manière à empêcher les erreurs d’accès relativement au nombre d’entrées qu’ils contiennent. # 31 ' & $ %
2.2.4 Exemple avec un tableau
1 p u b l i c c l a s s ArrayExample { 2 p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) { 3 i n t[ ] a r r a y O f I n t ; // or i n t a r r a y O f I n t [ ] ; // d e c l a r a t i o n de l a v a r i a b l e a r r a y O f I n t 4 a r r a y O f I n t = new i n t [ 4 2 ] ; // c r e a t i o n du t a b l e a u e t a s s o c i a t i o n a a r r a y O f I n t 5 a r r a y O f I n t [ 0 ] = 3 ; // a f f e c t a t i o n d ’ un element du t a b l e a u 6
7 System . out . p r i n t l n ( " Array ␣ l e n g t h ␣ "+ a r r a y O f I n t . l e n g t h ) ; // o b t e n t i o n de l a t a i l l e du t a b l e a u ( 4 2 ) 8 System . out . p r i n t l n ( a r r a y O f I n t [ 4 2 ] ) ; // i m p o s s i b l e l e v e e d ’ un e x c e p t i o n
9 } 10 }
Résultat de l’exécution :
Array length 42
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 42 at ArrayExample.main(ArrayExample.java:8)
Introduction au langage de programmation Java 2 Concepts de bases de Java # 32 ' & $ %
2.3 Tableaux
Déclaration de la référenceint[] arrayOfInt; // or int arrayOfInt[]; Création avec association de taille
arrayOfInt = new int[42]; Taille
int t = arrayOfInt.length; Compatibilité avec C :
int[] primes = {1, 2, 3, 5, 7, 7+4};
Les tableaux sont des objets gérés de manière particulière par l’infrastructure du langage. Les variables de type tableau sont déclarées comme des références et ne sont pas associées à l’espace mémoire correspondant. La création d’un tableau est réalisée par l’appel du mot réservé new. C’est à ce moment que la taille du tableau est fixée et que la référence est associée à l’objet tableau. La taille d’un tableau est connue en accédant à l’attribut en lecture seule length. La syntaxe du langage Java pour accéder à un attribut ou une méthode associée à un objet correspond à celle du langage C pour accéder à un membre d’une structure : le point (« . ») permet de passer de la référence de l’objet à ses attributs ou méthodes. Nous approfondirons ceci dans la section 3.
Pour des raisons de compatibilité ascendantes avec le langage C, les tableaux initialisés sont acceptés lors de la définition de la référence. # 33 ' & $ %
2.4 Méthodes
Nom donné aux opérations
Méthodes associées aux classes (pas de méthode sans classe) Surcharge (en anglais, overloading) des méthodes possible Méthode d’instance
Méthode de classe avec mot réservé static
Prototype de la méthode public static void main(final String []) Passage d’arguments
Par valeur pour les types primitifs
Par référence pour les objets et les tableaux
Ce que vous connaissez sous le concept de fonction en langage C (partie de code, associée à une liste
Introduction au langage de programmation Java 2 Concepts de bases de Java de paramètres et un type de retour) est appelé opération en UML et méthode en Java ainsi que dans de nombreux langages objets.
En Java, les méthodes ne sont pas définies dans un seul espace de nommage comme en langage C. Chaque méthode est définie à l’intérieur d’une classe. Dans une classe les méthodes sont identifiées par leur nom et la liste de leurs paramètres, ce qui donne la possibilité d’avoir plusieurs méthodes dans une classe qui portent le même nom mais qui travaillent sur des paramètres de types différents. Cette possibilité est appelée surcharge de méthodes (overloading en anglais).
Dans le cas le plus courant, les méthodes sont associées aux objets d’une classe. Elles sont utilisées à travers une référence d’objet. Nous approfondirons ceci dans le chapitre 3. Les méthodes de ce type sont appelées méthodes d’instance car elles agissent sur un objet à la fois.
Les méthodes peuvent aussi être associées à la classe lorsqu’elles sont qualifiées de static, comme les méthodes que nous avons vues jusqu’à maintenant, et en particulier la méthode main. Ce type de méthode est dit de classe. Ces méthodes de classe peuvent être utilisées directement en associant le nom de la classe et le nom de la méthode reliés par un point comme dans Math.sqrt(4).
La méthode de classe public static void main(String []) joue un rôle identique à la méthode int main(int argc, char *argv[])du langage C. Elle sert de point d’entrée pour un programme.
Les variables de type primitif sont passées par copie de la valeur. Les variables de type tableau ou objet sont manipulées en Java à travers une référence. Lors du passage d’une référence à une méthode, cette référence permet de manipuler l’objet d’origine. Ainsi toute modification réalisée à travers une référence dans une méthode appelée modifie l’objet qui est référencé de manière visible par la méthode appelante.
# 34
'
&
$
%
2.5 Exemple de passage d’arguments
1 p u b l i c c l a s s EssParm {
2 p r i v a t e s t a t i c v o i d add ( i n t c , f i n a l i n t [ ] as ) {
3 c++; 4 as [ 0 ] ++;
5 System . out . p r i n t l n ( " add␣ : ␣ c=" + c + " , ␣ as [0]= " + as [ 0 ] ) ; 6 } 7 p u b l i c s t a t i c v o i d main ( f i n a l S t r i n g a r g v [ ] ) { 8 i n t i = 0 ; 9 i n t s [ ] = new i n t [ 1 0 ] ; 10 s [ 0 ] = 0 ; 11 add ( i , s ) ;
12 System . out . p r i n t l n ( " main ␣ : ␣ i=" + i + " , ␣ s [0]= " + s [ 0 ] ) ; 13 }
14 }
Résultat de l’exécution : add : c=1, as[0]=1 main : i=0, s[0]=1
Les variables de type primitif sont passées par copie. La modification de la copie c de la variable i dans la méthode add n’a pas de répercussion sur la valeur de la variable i. La variable c est donc bien une variable différente de la variable i. Cette variable a été initialisée avec la valeur de la variable i lors de l’appel.
Dans notre exemple les variables s et as font référence au même tableau. Ainsi, lorsque l’entrée 0 du tableau est modifiée dans la méthode add en utilisant la variable as, l’entrée correspondante vue à travers la variable s paraît modifiée de manière identique.
Introduction au langage de programmation Java 2 Concepts de bases de Java # 35 ' & $ %
Questions sur la syntaxe de base de Java
En Java un fichier source peut-il contenir des méthodes ? Dans un bloc d’instructions (partie entre accolades) :
la ligne suivante est-elle acceptable en C et en Java ? int a = 0, b = 1, c;
la ligne suivante est-elle acceptable en C et en Java ? if ( a = b ) {
c = a; }
L’accès à un élément de tableau est-il réalisé de manière identique en C et en Java ?
3 Classes et objets en Java 3.1 Classe # 36 ' & $ %
3 Classes et objets en Java
3.1 Classe . . . 38
3.2 Objet . . . 42
3.3 Attributs et méthodes de classe . . . 51
3.4 Association entre classes . . . 55
Cette section décrit la syntaxe du langage Java relative à la création des classes et à celle des objets. Elle s’appuie sur la connaissance de base des notations UML relatives aux classes et aux objets.
# 37 ' & $ %
3.1 Classe
Classe Personne en UML
Ce schéma décrit plusieurs notations possibles en UML de la classe Personne du cas d’étude Studs. La partie gauche contient la description des attributs et des opérations. C’est ce schéma que nous traduisons en Java dans la diapositive suivante.
3 Classes et objets en Java 3.1 Classe # 38 ' & $ %
3.1.1 Classe Personne en Java
1 p a c k a g e s t u d s ; 2 p u b l i c c l a s s Personne { 3 p r i v a t e S t r i n g nom , prenom ; 4 p r i v a t e i n t n b P a r t i c i p a t i o n s = 0 , n b O r g a n i s a t i o n s = 0 ; 5 p u b l i c Personne ( f i n a l S t r i n g n , f i n a l S t r i n g p ) { 6 nom = n ; prenom = p ; 7 } 8 p u b l i c v o i d v o t e r ( f i n a l B u l l e t i n b ){ } 9 p u b l i c v o i d c o n s u l t e r R e s u l t a t ( f i n a l S c r u t i n s ) { } 10 p u b l i c v o i d s e R e t i r e r D U n S c r u t i n ( f i n a l S c r u t i n s ) { } 11 @Override 12 p u b l i c S t r i n g t o S t r i n g ( ) {
13 r e t u r n " Personne ␣ " + nom + " , ␣ "+ prenom +" , ␣ "+ n b O r g a n i s a t i o n s + " , ␣ " + n b P a r t i c i p a t i o n s ;
14 } 15 }
Une description de classe commence par une ligne contenant le mot réservé class. Lorsque la classe est publique, le fichier qui contient celle-ci doit porter un nom identique à la classe : dans notre cas, le fichier doit s’appeler Personne.java.
Nous décrivons plus précisément ce qu’est un paquetage qui correspond à la première ligne contenant le mot réservé package dans la section 5.6. De même, nous présentons les possibilités associées à la visibilité par l’utilisation des mots réservés public et private dans la section 5.7.
De manière traditionnelle, une classe commence par la description des attributs. Comme nous l’avons vu en UML, les attributs peuvent être spécifiques à chaque objet. Ce sont des attributs d’instance. Ils peuvent aussi être partagés entre tous les objets de la classe. Ce sont des attributs de classe. Nous détaillons ces points à partir de la section 3.3.
Les attributs peuvent correspondre à des types primitifs ou non. Dans notre cas, la variable nbParticipations est du type primitif int. La variable nom est une référence sur un objet de la classe java.lang.String, que nous approfondirons dans le chapitre 6.
Les attributs d’instance sont le plus souvent initialisés par une méthode appelée constructeur et qui porte le même nom que la classe. Nous en reparlons de manière approfondie dans la section 3.2.1.
Une classe définit les comportements de ses objets à travers des méthodes d’instance. Une méthode d’instance réalise une opération s’appliquant sur les attributs d’un objet. C’est le cas dans notre exemple des méthodes : voter, consulterResultat, et seRetirerDUnScrutin.
3 Classes et objets en Java 3.1 Classe # 39 ' & $ %
3.1.2 Instance de classe en UML
Cette figure représente en UML une instance de la classe Personne. Elle précise les valeurs des attributs. Elle donne aussi la possibilité de nommer l’objet.
# 40
'
&
$
%
3.1.3 Instance de classe en Java
1 i m p o r t s t u d s . Personne ;
2 c l a s s I n i t P e r s o n n e {
3 p u b l i c s t a t i c v o i d main ( f i n a l S t r i n g [ ] a r g s ) {
4 Personne j ; // r e f e r e n c e
5 j = new Personne ( " Dupont " , " J u l i e n " ) ; // i n s t a n c e c r e a t i o n 6 System . out . p r i n t l n ( j ) ;
7 } 8 }
Résultat de l’exécution : studs.Personne@f62373
Cet exemple montre la création d’un objet de la classe Personne. La première ligne du fichier contient une directive import qui permet de nommer plus facilement la classe Personne. Nous approfondissons les explications sur import dans la section 5.
Ce code est contenu dans une classe appelée InitPersonne. Cette classe est dotée d’une méthode pu- blique, statique appelée main et recevant comme argument un tableau de chaînes de caractères. Elle peut servir de point d’entrée à l’exécution du programme.
La ligne 4 définit une variable locale appelée j qui permet de référencer un objet de la classe Personne. L’instance est créée à la ligne 5 par l’appel du mot réservé new suivi d’un appel au constructeur de la classe Personne.
3 Classes et objets en Java 3.2 Objet L’instance est ensuite manipulée à partir de la référence j comme dans l’appel de la méthode println, ligne 6. # 41 ' & $ %
3.2 Objet
Création d’un objet
Disposer d’une référence : Personne p; Créer l’objet : new + appel à un constructeur
I p = new Personne("Dupont", "Julien");
Pour manipuler un objet, il est nécessaire de disposer d’une référence qui correspond à la classe de l’objet. Il faut ensuite créer un objet. Pour ceci, le mot réservé new est suivi d’un appel à l’un des constructeurs de la classe de l’objet. C’est à cet endroit que les paramètres qui servent à initialiser les attributs sont fournis. Une fois créé, l’objet n’est jamais manipulé directement mais toujours à travers une référence.
# 42 ' & $ %
3.2.1 Constructeurs en Java
Méthode particulière : Nom identique à la classe Aucun type de retourAppelé directement à travers new
Si aucun constructeur n’est spécifié, le compilateur en fabrique un par défaut qui initialise les attributs à 0 (correspondant à leur type)
La surcharge des méthodes (overloading) permet à une classe d’avoir plusieurs constructeurs qui diffèrent par le nombre et le type de leurs arguments
Les constructeurs sont des méthodes particulières. Ils portent le même nom que la classe. Ils ne peuvent pas être appelés par un appel de méthode classique. De l’extérieur de la classe, ils sont appelés en utilisant le mot réservé new.
Les constructeurs n’ont pas de type de retour.