 |
|
2) Tout est ? objet ? |
|
|
|
|
| Texte original |
|
Traducteur : Raczy |
|
|
|
|
|
Ce chapitre contient 4 pages
1
2
3
4
|
|
|
|
|
|
|
|
|
|
|
|
28.04.2001 - version 1.2 [Armel]
- Remise en forme du code html (DIR et PRE en blockquote et pre),
Ajout des tags de s?aration de pages pour le site (Armel).
Suppression des balises TIJ.
02.02.2001 - version 1.1 [Raczy]
- Tags + html nettoye
27.06.2000 - version 1.0 [Raczy]
- Derni?e modification : 27 juin 2000
Traducteur :
- Raczy
Texte original :
-Thinking in Java, 2nd edition, Revision 10
? 2000 by Bruce Eckel
|
|
|
|
|
2: Everythingis an Object
|
|
2 : Tout est Objet
|
|
|
|
|
Although it is based on C++, Java
is more of a “pure” object-oriented language.
|
|
Bien qu'il soit bas sur C++, Java est un langage orient objet
plus ? pur ?.
|
|
|
|
|
Both C++ and Java are hybrid languages,
but in Java the designers felt that the hybridization was not as important as it
was in C++. A hybrid language allows multiple programming styles; the reason C++
is hybrid is to support backward compatibility with the C language. Because C++
is a superset of the C language, it includes many of that language’s
undesirable features, which can make some aspects of C++ overly
complicated.
|
|
C++ et Java sont tous les deux des langages hybrides, mais dans Java, les
concepteurs ont pens que l'hybridation est moins importante qu'elle ne l'est en C++. Un langage
hybride autorise plusieurs styles de programmation : C++ est hybride pour assurer la
compatibilit avec le langage C. Comme C++ est une extension du langage C, il contient un grand
nombre des particularit? ind?irables de ce langage, ce qui peut rendre certains aspects du C++
particuli?ement embrouill?.
|
|
|
|
|
The Java language assumes that you want
to do only object-oriented programming. This means that before you can begin you
must shift your mindset into an object-oriented world (unless it’s already
there). The benefit of this initial effort is the ability to program in a
language that is simpler to learn and to use than many other OOP languages. In
this chapter we’ll see the basic components of a Java program and
we’ll learn that everything in Java is an object, even a Java
program.
|
|
Le langage Java suppose qu'on ne veut faire que de la programmation
orient? objet (POO). Ceci signifie qu'avant de pouvoir commencer il faut tourner sa vision des
choses vers un monde orient objets ( moins qu'elle ne le soit d??. L'avantage de cet effort
pr?iminaire est la capacit programmer dans un langage qui est plus simple apprendre et
utiliser que beaucoup d'autres langages de POO. Dans ce chapitre nous verrons les composantes de
base d'un programme Java et nous apprendrons que tout dans Java est objet, m?e un programme
Java.
|
|
|
|
You manipulate objects with references
|
|
Les objets sont manipul? avec des r??ences
|
|
|
|
|
Each programming language has its own
means of manipulating data. Sometimes the programmer must be constantly aware of
what type of manipulation is going on. Are you manipulating the object directly,
or are you dealing with some kind of indirect representation (a pointer in C or
C++) that must be treated with a special syntax?
|
|
Chaque langage de programmation a ses propres fa?ns de manipuler les
donn?s. Parfois le programmeur doit ?re constamment conscient du type des manipulations en cours.
Manipulez-vous l'objet directement, ou avez-vous affaire une sorte de repr?entation indirecte
(un pointeur en C ou C++) qui doit ?re trait avec une syntaxe particuli?e ?
|
|
|
|
|
All this is simplified in Java. You treat
everything as an object, so there is a single consistent syntax that you use
everywhere. Although you treat everything as an object, the identifier
you manipulate is actually a “reference” to an
object[20]. You
might imagine this scene as a television (the object) with your remote control
(the reference). As long as you’re holding this reference, you have a
connection to the television, but when someone says “change the
channel” or “lower the volume,” what you’re manipulating
is the reference, which in turn modifies the object. If you want to move around
the room and still control the television, you take the remote/reference with
you, not the television.
|
|
Tout ceci est simplifi en Java. On consid?e tout comme des objets, ainsi
il n'y a qu'une seule syntaxe coh?ente qui est utilis? partout. Bien qu'on traite tout
comme des objets, les identificateurs qui sont manipul? sont en r?lit des
? r??ences ? vers des objets [21]. On pourrait
imaginer cette situation comme une t??ision (l'objet) avec une t??ommande (la r??ence). Tant
qu'on conserve cette r??ence, on a une liaison vers la t??ision, mais quand quelqu'un dit
? change de cha?e ? ou ? baisse le volume ?, ce qu'on manipule est la
r??ence, qui en retour modifie l'objet. Si on veut se d?lacer dans la pi?e tout en contr?ant
la t??ision, on emporte la t??ommande/r??ence, pas la t??ision.
|
|
|
|
|
Also, the remote control can stand on its
own, with no television. That is, just because you have a reference
doesn’t mean there’s necessarily an object connected to it. So if
you want to hold a word or sentence, you create a String
reference:
|
|
De plus, la t??ommande peut exister par elle m?e sans t??ision. C'est
dire que le fait d'avoir une r??ence ne signifie pas n?essairement qu'un objet y soit associ?
Ainsi, si on veut avoir avoir un mot ou une phrase, on cr? une r??ence sur une
String :
|
|
|
|
String s;
|
|
String s;
|
|
|
|
But here you’ve created only
the reference, not an object. If you decided to send a message to s at
this point, you’ll get an error (at run-time) because s isn’t
actually attached to anything (there’s no television). A safer practice,
then, is always to initialize a reference when you create it:
|
|
Mais on a seulement cr? la r??ence, pas un objet. ? ce point,
si on d?idait d'envoyer un message s, on aurait une erreur (lors de
l'ex?ution) parce que s n'est pas rattach? quoi que ce soit (il n'y a pas de
t??ision). Une pratique plus s?e est donc de toujours initialiser une r??ence quand on la
cr? :
|
|
|
|
String s = "asdf";
|
|
String s = "asdf";
|
|
|
|
However, this uses a special Java
feature: strings can be initialized with quoted text. Normally, you must use a
more general type of initialization for
objects.
|
|
Toutefois, ceci utilise une caract?istique sp?iale de Java : les
cha?es de caract?es peuvent ?re initialis?s avec du texte entre guillemets. Normalement, on
doit utiliser un type d'initialisation plus g??al pour les objets.
|
|
|
|
You must create all the objects
|
|
Vous devez cr?r tous les objets
|
|
|
|
When you create a reference, you want to
connect it with a new object. You do so, in general, with the new
keyword. new says, “Make me a new one of these objects.” So
in the above example, you can say:
|
|
Quand on cr? une r??ence, on veut la connecter un nouvel objet. Ceci
se fait, en g??al, avec le mot-clef new. new veut dire
? fabrique moi un de ces objets ?. Ainsi, dans l'exemple pr??ent, on peut
dire :
|
|
|
|
String s = new String("asdf");
|
|
String s = new String("asdf");
|
|
|
|
Not only does this mean “Make me a
new String,” but it also gives information about how to make
the String by supplying an initial character string.
|
|
Ceci ne veut pas seulement dire ? fabrique moi un nouvel objet
String ?, mais cela donne aussi une information sur comment
fabriquer l'objet String en fournissant une cha?e de caract?es
initiale.
|
|
|
|
Of course, String is not the only
type that exists. Java comes with a plethora of ready-made types. What’s
more important is that you can create your own types. In fact, that’s the
fundamental activity in Java programming, and it’s what you’ll be
learning about in the rest of this
book.
|
|
Bien s?, String n'est pas le seul type qui existe. Java
propose une pl?hore de types tout pr?s. Le plus important est qu'on puisse cr?r ses propres
types. En fait, c'est l'activit fondamentale en programmation Java et c'est ce qu'on apprendra
faire dans la suite de ce livre.
|
|
|
|
Where storage lives
|
|
O r?ide la m?oire ?
|
|
|
|
It’s useful to visualize some
aspects of how things are laid out while the program is running, in particular
how memory is arranged. There are six different places to store
data:
|
|
Il est utile de visualiser certains aspects de comment les choses sont
arrang?s lorsque le programme tourne, en particulier comment la m?oire est organis?. Il y a six
endroits diff?ents pour stocker les donn?s :
|
|
|
|
-
Registers.
This is the fastest storage because it exists in a place different from that of
other storage: inside the processor. However, the number of registers is
severely limited, so registers are allocated by the compiler according to its
needs. You don’t have direct control, nor do you see any evidence in your
programs that registers even
exist. -
The
stack. This lives in the general RAM (random-access memory) area, but has
direct support from the processor via its stack pointer. The stack
pointer is moved down to create new memory and moved up to release that memory.
This is an extremely fast and efficient way to allocate storage, second only to
registers. The Java compiler must know, while it is creating the program, the
exact size and lifetime of all the data that is stored on the stack, because it
must generate the code to move the stack pointer up and down. This constraint
places limits on the flexibility of your programs, so while some Java storage
exists on the stack—in particular, object references—Java objects
themselves are not placed on the
stack. -
The
heap. This is a general-purpose pool of memory (also in the RAM area) where
all Java objects live. The nice thing about the heap is that, unlike the stack,
the compiler doesn’t need to know how much storage it needs to allocate
from the heap or how long that storage must stay on the heap. Thus,
there’s a great deal of flexibility in using storage on the heap. Whenever
you need to create an object, you simply write the code to create it using
new, and the storage is allocated on the heap when that code is
executed. Of course there’s a price you pay for this flexibility: it takes
more time to allocate heap storage than it does to allocate stack storage (that
is, if you even could create objects on the stack in Java, as you can in
C++). -
Static
storage. “Static” is used here in the sense of “in a fixed
location” (although it’s also in RAM). Static storage contains data
that is available for the entire time a program is running. You can use the
static keyword to specify that a particular element of an object is
static, but Java objects themselves are never placed in static
storage. -
Constant
storage. Constant values are often placed directly in the program code,
which is safe since they can never change. Sometimes constants are cordoned off
by themselves so that they can be optionally placed in read-only memory
(ROM). -
Non-RAM
storage. If data lives completely outside a program it can exist while the
program is not running, outside the control of the program. The two primary
examples of this are streamed objects, in which objects are turned into
streams of bytes, generally to be sent to another machine, and persistent
objects, in which the objects are placed on disk so they will hold their
state even when the program is terminated. The trick with these types of storage
is turning the objects into something that can exist on the other medium, and
yet can be resurrected into a regular RAM-based object when necessary. Java
provides support for lightweight persistence, and future versions of Java
might provide more complete solutions for
persistence.
|
|
- Les registres. C'est le stockage le plus rapide car il se
trouve un endroit diff?ent des autres zones de stockage : dans le processeur. Toutefois, le
nombre de registres est s??ement limit? donc les registres sont allou? par le compilateur en
fonction de ses besoins. On n'a aucun contr?e direct et il n'y a m?e aucune trace de l'existence
des registres dans les programmes.
- La pile. Elle se trouve dans la RAM (random access
memory) mais elle est prise en compte directement par le processeur via son pointeur de
pile. Le pointeur de pile est d?lac vers le bas pour cr?r plus d'espace m?oire et d?lac
vers le haut pour lib?er cet espace. C'est un moyen extr?ement efficace et rapide d'allouer de la
m?oire, supplant seulement par les registres. Le compilateur Java doit conna?re, lorsqu'il cr?
le programme, la taille et la dur? de vie exacte de toutes les donn?s qui sont rang?s sur la
pile, parce qu'il doit g??er le code pour d?lacer le pointeur de pile vers le haut et vers le
bas. Cette contrainte met des limites la flexibilit des programmes, donc, bien qu'il y ait du
stockage Java sur la pile -- en particulier les r??ences aux objets -- les objets Java eux m?e
ne sont pas plac? sur la pile.
- Le segment. C'est une r?erve de m?oire d'usage g??al
(aussi en RAM) o r?ident tous les objets java. La bonne chose propos du segment est que,
contrairement la pile, le compilateur n'a pas besoin de savoir de combien de place il a besoin
d'allouer sur le segment ni combien de temps cette place doit rester sur le segment.Ainsi, il y a
une grande flexibilit utiliser la m?oire sur le segment. Lorsqu'on a besoin de cr?r un objet,
il suffit d'?rire le code pour le cr?r en utilisant new et la m?oire est
allou? sur le segment lorsque le programme s'ex?ute. Bien entendu il y a un prix payer pour
cette flexibilit?nbsp;: il faut plus de temps pour allouer de la m?oire sur le segment qu'il n'en
faut pour allouer de la m?oire sur la pile (c'est dire si on avait la possibilit de
cr?r des objets sur la pile en Java, comme on peut le faire en C++).
- La m?oire statique. ? Statique ? est utilis
ici dans le sens ? un endroit fixe ? (bien que ce soit aussi dans la RAM). La m?oire
statique contient les donn?s qui sont disponibles pendant tout le temps d'ex?ution du programme.
On peut utiliser le mot-clef static pour sp?ifier qu'un ??ent particulier d'un
objet est statique, mais les objets Java par eux-m?es ne sont jamais plac? dans la m?oire
statique.
- Les constantes. Les valeurs des constantes sont souvent
plac?s directement dans le code du programme, ce qui est s? puisqu'elles ne peuvent jamais
changer. Parfois les constantes sont isol?s de fa?n pouvoir ?re optionnellement plac?s dans
une m?oire accessible en lecture seulement (ROM).
- Stockage hors RAM. Si les donn?s r?ident enti?ement
hors du programme, elles peuvent exister m?e quand le programme ne tourne pas, en dehors du
contr?e du programme. Les deux exemples de base sont les flots de donn?s, pour lesquels
les donn?s sont transform?s en flots d'octets, g??alement pour ?re transmises vers une autre
machine, et les objets persistants, pour lesquels les objets sont plac? sur disque de
fa?n ce qu'ils conservent leur ?at m?e apr? que le programme soit termin? L'astuce avec ces
types de stockage est de transformer les objets en quelque chose qui peut exister sur l'autre
support, tout en pouvant ?re ressuscit en un objet normal en m?oire, lorsque c'est n?essaire.
Java fournit des outils pour la persistance l??e, et les versions futures pourraient
fournir des solutions plus compl?es pour la persistance.
|
|
|
|
Special case: primitive
types
|
|
Cas particulier : les types primitifs
|
|
|
|
There is a group of types that gets
special treatment; you can think of these as “primitive” types that
you use quite often in your programming. The reason for the special treatment is
that to create an object with new—especially a small, simple
variable—isn’t very efficient because new places objects on
the heap. For these types Java falls back on the approach taken by C and C++.
That is, instead of creating the variable using new, an
“automatic” variable is created that is not a reference. The
variable holds the value, and it’s placed on the stack so it’s much
more efficient.
|
|
Il y a un ensemble de types qui sont soumis un traitement
particulier ; ils peuvent ?re consid?? comme les types ? primitifs ? fr?uemment
utilis? en programmation. La raison de ce traitement particulier est que la cr?tion d'un objet
avec new -- en particulier une simple variable -- n'est pas tr? efficace parce
que new place les objets sur le segment. Pour ces types, Java a recours
l'approche retenue en C et en C++. Au lieu de cr?r la variable en utilisant new,
une variable ? automatique ?, qui n'est pas une r??ence, est cr?e. La variable
contient la valeur et elle est plac? sur la pile, ce qui est beaucoup plus efficace.
|
|
|
|
Java determines the size of each
primitive type. These sizes don’t change from one machine architecture to
another as they do in most languages. This size invariance is one reason Java
programs are so portable.
|
|
Java fixe la taille de chacun des types primitifs. Ces tailles ne changent
pas d'une architecture de machine une autre, comme c'est le cas dans la plupart des langages.
L'invariance de la taille de ces types est l'une des raisons pour lesquelles Java est si
portable.
|
|
|
|
Primitive type
|
Size
|
Minimum
|
Maximum
|
Wrapper type
|
boolean
|
—
|
—
|
—
|
Boolean
|
char
|
16-bit
|
Unicode 0
|
Unicode 216- 1
|
Character
|
byte
|
8-bit
|
-128
|
+127
|
Byte
|
short
|
16-bit
|
-215
|
+215—1
|
Short
|
int
|
32-bit
|
-231
|
+231—1
|
Integer
|
long
|
64-bit
|
-263
|
+263—1
|
Long
|
float
|
32-bit
|
IEEE754
|
IEEE754
|
Float
|
double
|
64-bit
|
IEEE754
|
IEEE754
|
Double
|
void
|
—
|
—
|
—
|
Void
|
|
|
| Type primitif |
Taille |
Minimum |
Maximum |
Type wrapper |
| boolean |
- |
- |
- |
Boolean |
| char |
16-bit |
Unicode 0 |
Unicode 216- 1 |
Character |
| byte |
8-bit |
-128 |
+127 |
Byte |
| short |
16-bit |
-215 |
+215-1 |
Short |
| int |
32-bit |
-231 |
+231-1 |
Integer |
| long |
64-bit |
-263 |
+263-1 |
Long |
| float |
32-bit |
IEEE754 |
IEEE754 |
Float |
| double |
64-bit |
IEEE754 |
IEEE754 |
Double |
| void |
- |
- |
- |
Void |
|
|
|
|
All numeric types are signed, so
don’t go looking for unsigned types.
|
|
Tous les types num?iques sont sign?, il est donc inutile d'aller chercher
apr? des types non sign?.
|
|
|
|
The size of the boolean type is
not explicitly defined; it is only specified to be able to take the literal
values true or false.
|
|
|
|
|
|
The primitive data types also have
“wrapper” classes for them. That means that if you want to
make a nonprimitive object on the heap to represent that primitive type, you use
the associated wrapper. For example:
|
|
Les types de donn?s primitifs sont aussi associ? des classes
? wrapper ?. Ceci signifie que pour faire un objet non primitif sur le segment pour
repr?enter ce type primitif il faut utiliser le wrapper associ? Par exemple :
|
|
|
|
char c = 'x';
Character C = new Character(c);
|
|
char c = 'x';Character C =
new Character(c);
|
|
|
|
|
Or you could also use:
|
|
On peut aussi utiliser :
|
|
|
|
Character C = new Character('x');
|
|
Character C = new
Character('x');
|
|
|
|
The reasons for doing this will be shown
in a later chapter.
|
|
Les raisons pour lesquelles on fait ceci seront indiqu?s dans un prochain
chapitre.
|
|
|
|
High-precision numbers
|
|
Nombres de grande pr?ision
|
|
|
|
Java includes two classes for performing
high-precision arithmetic: BigInteger and BigDecimal. Although
these approximately fit into the same category as the “wrapper”
classes, neither one has a primitive analogue.
|
|
Java contient deux classes pour effectuer des op?ations arithm?iques de
grande pr?ision : BigInteger et BigDecimal. Bien que
ceux-ci soient dans la m?e cat?orie que les classes ? wrapper ?, aucun d'eux n'a
d'analogue primitif.
|
|
|
|
Both classes have methods that provide
analogues for the operations that you perform on primitive types. That is, you
can do anything with a BigInteger or BigDecimal that you can with
an int or float, it’s just that you must use method calls
instead of operators. Also, since there’s more involved, the operations
will be slower. You’re exchanging speed for accuracy.
|
|
Chacune de ces classes a des m?hodes qui fournissent des op?ations
analogues celles qu'on peut faire sur les types primitifs. C'est dire qu'avec un
BigInteger ou un BigDecimal on peut faire tout ce qu'on peut
faire avec un int ou un float, seulement il faut utiliser des
appels de m?hodes au lieu des op?ateurs. Par ailleurs, comme elles en font plus, les op?ations
sont plus lentes. On ?hange la vitesse contre la pr?ision.
|
|
|
|
BigInteger supports
arbitrary-precision integers. This means that you can accurately represent
integral values of any size without losing any information during
operations.
|
|
BigInteger sert aux entiers de pr?ision arbitraire. C'est
dire qu'ils permettent de repr?enter des valeurs enti?es de n'importe quelle taille sans perdre
aucune information au cours des op?ations.
|
|
|
|
BigDecimal is for
arbitrary-precision fixed-point numbers; you can use these for accurate monetary
calculations, for example.
|
|
BigDecimal sert aux nombres virgule fixe de pr?ision
arbitraire ; par exemple, on peut les utiliser pour des calculs mon?aires pr?is.
|
|
|
|
Consult your online documentation for
details about the constructors and methods you can call for these two
classes.
|
|
Il faut se reporter la documentation en ligne pour obtenir des d?ails
sur les constructeurs et m?hodes utilisables avec ces deux classes.
|
|
|
|
Arrays in Java
|
|
Tableaux en Java
|
|
|
|
Virtually all programming languages
support arrays. Using arrays in C and C++ is perilous because those arrays are
only blocks of memory. If a program accesses the array outside of its memory
block or uses the memory before initialization (common programming errors) there
will be unpredictable results.
|
|
Pratiquement tous les langages de programmation g?ent les tableaux.
Utiliser des tableaux en C ou C++ est dangereux car ces tableaux ne sont que des blocs de m?oire.
Si un programme acc?e un tableau en dehors de son bloc m?oire, ou s'il utilise la m?oire avant
initialisation (erreurs de programmation fr?uentes) les r?ultats seront impr?isibles.
|
|
|
|
One of the primary goals of Java is
safety, so many of the problems that plague programmers in C and C++ are not
repeated in Java. A Java array is guaranteed to be initialized and cannot be
accessed outside of its range. The range checking comes at the price of having a
small amount of memory overhead on each array as well as verifying the index at
run-time, but the assumption is that the safety and increased productivity is
worth the expense.
|
|
Un des principaux objectifs de Java est la s?urit? aussi, un grand nombre
des probl?es dont souffrent C et C++ ne sont pas r??? en Java. On est assur qu'un tableau Java
est initialis et qu'il ne peut pas ?re acc? en dehors de ses bornes. La v?ification des bornes
se fait au prix d'un petit exc?ent de m?oire pour chaque tableau ainsi que de la v?ification de
l'index lors de l'ex?ution, mais on suppose que le gain en s?urit et en productivit vaut la
d?ense.
|
|
|
|
When you create an array of objects, you
are really creating an array of references, and each of those references is
automatically initialized to a special value with its own keyword:
null. When Java sees
null, it recognizes that the reference in question isn’t pointing
to an object. You must assign an object to each reference before you use
it, and if you try to use a reference that’s still null, the
problem will be reported at run-time. Thus, typical array errors are prevented
in Java.
|
|
Quand on cr? un tableau d'objets, on cr? en r?lit un tableau de
r??ences, et chacune de ces r??ences est automatiquement initialis? une valeur particuli?e
avec son propre mot cl?nbsp;: null. Quand Java voit null, il
reconna? que la r??ence en question ne pointe pas vers un objet. Il faut affecter un objet
chaque r??ence avant de l'utiliser et si on essaye d'utiliser une r??ence encore
null, le probl?e sera signal lors de l'ex?ution. Ainsi, les erreurs typiques
sur les tableaux sont ?it?s en Java.
|
|
|
|
You can also create an array of
primitives. Again, the compiler guarantees initialization because it zeroes the
memory for that array.
|
|
On peut aussi cr?r des tableaux de variables de type primitif. ? nouveau,
le compilateur garantit l'initialisation car il met z?o la m?oire utilis? par ces
tableaux.
|
|
|
|
Arrays will be covered in detail in later
chapters.
|
|
Les tableaux seront trait? plus en d?ails dans d'autres
chapitres.
|
|
|
|
You never need to destroy an object
|
|
Vous n'avez jamais besoin de d?ruire un objet
|
|
|
|
In most programming languages, the
concept of the lifetime of a variable occupies a significant portion of the
programming effort. How long does the variable last? If you are supposed to
destroy it, when should you? Confusion over variable lifetimes can lead to a lot
of bugs, and this section shows how Java greatly simplifies the issue by doing
all the cleanup work for
you.
|
|
Dans la plupart des langages de programmation, le concept de dur? de vie
d'une variable monopolise une part significative des efforts de programmation. Combien de temps une
variable existe-t-elle ? S'il faut la d?ruire, quand faut-il le faire ? Des erreurs sur
la dur? de vie des variables peuvent ?re la source de nombreux bugs et cette partie montre
comment Java simplifie ?orm?ent ce probl?e en faisant le m?age tout seul.
|
|
|
|
Scoping
|
|
Notion de port?
|
|
|
|
Most procedural languages have the
concept of scope. This determines both the visibility and lifetime of the
names defined within that scope. In C, C++, and Java, scope is determined by the
placement of curly braces {}. So for example:
|
|
La plupart des langages proc?uraux ont le concept de port?. Il
fixe simultan?ent la visibilit et la dur? de vie des noms d?inis dans cette port?. En C, C++
et Java, la port? est fix? par l'emplacement des accolades {}. Ainsi, par
exemple :
|
|
|
|
{
int x = 12;
/* only x available */
{
int q = 96;
/* both x & q available */
}
/* only x available */
/* q “out of scope” */
}
|
|
{
int x = 12;
/* seul x est accessible */
{
int q = 96;
/* x & q sont tous les deux accessibles */
}
/* seul x est accessible */
/* q est ? hors de port? ? */
}
|
|
|
|
|
A variable defined within a scope is
available only to the end of that scope.
|
|
Une variable d?inie dans une port? n'est accessible que jusqu' la fin de
cette port?.
|
|
|
|
|
Indentation makes Java code easier to
read. Since Java is a free-form language, the extra spaces, tabs, and carriage
returns do not affect the resulting program.
|
|
L'indentation rend le code Java plus facile lire. ?tant donn que Java
est un langage ind?endant de la mise en page, les espaces, tabulations et retours chariots
suppl?entaires ne changent pas le programme.
|
|
|
|
|
Note that you cannot do the
following, even though it is legal in C and C++:
|
|
Il faut remarquer qu'on ne peut pas faire la chose suivante, bien que cela
soit autoris en C et C++ :
|
|
|
|
{
int x = 12;
{
int x = 96; /* illegal */
}
}
|
|
{
int x = 12;
{
int x = 96; /* illegal */
}
}
|
|
|
|
|
The compiler will announce that the
variable x has already been defined. Thus the C and C++ ability to
“hide” a variable in a larger scope is not allowed because the Java
designers thought that it led to confusing
programs.
|
|
Le compilateur annoncera que la variable x a d? ?
d?inie. Ainsi, la facult du C et du C++ ? cacher ? une variable d'une port? plus
?endue n'est pas autoris? parce que les concepteurs de Java ont pens que ceci m?e des
programmes confus.
|
|
|
|
Scope of objects
|
|
Port? des objets
|
|
|
|
|
Java objects do not have the same
lifetimes as primitives. When you create a Java object using new, it
hangs around past the end of the scope. Thus if you use:
|
|
Les objets Java n'ont pas la m?e dur? de vie que les variables
primitives. Quand on cr? un objet Java avec new, il existe toujours apr? la fin
de la port?. Ainsi, si on fait :
|
|
|
|
{
String s = new String("a string");
} /* end of scope */
|
|
{
String s = new String("a string");
} /* fin de port? */
|
|
|
|
|
the reference s vanishes at the
end of the scope. However, the String object that s was pointing
to is still occupying memory. In this bit of code, there is no way to access the
object because the only reference to it is out of scope. In later chapters
you’ll see how the reference to the object can be passed around and
duplicated during the course of a program.
|
|
la r??ence s dispara? la fin de la port?. Par contre
l'objet String sur lequel s pointait occupe toujours la m?oire.
Dans ce bout de code, il n'y a aucun moyen d'acc?er l'objet parce que son unique r??ence est
hors de port?. Dans d'autres chapitres on verra comment la r??ence un objet peut ?re
transmise et dupliqu? dans un programme.
|
|
|
|
|
It turns out that because objects created
with new stay around for as long as you want them, a whole slew of C++
programming problems simply vanish in Java. The hardest problems seem to occur
in C++ because you don’t get any help from the language in making sure
that the objects are available when they’re needed. And more important, in
C++ you must make sure that you destroy the objects when you’re done with
them.
|
|
Il s'av?e que du simple fait qu'un objet cr? avec new reste disponible
tant qu'on le veut, tout un tas de probl?es de programmation du C++ disparaissent tout simplement
en Java. Il semble que les probl?es les plus durs surviennent en C++ parce que le langage ne
fournit aucune aide pour s'assurer que les objets sont disponibles quand on en a besoin. Et, encore
plus important, en C++ on doit s'assurer qu'on d?ruit bien les objets quand on en a termin avec
eux.
|
|
|
|
|
That brings up an interesting question.
If Java leaves the objects lying around, what keeps them from filling up memory
and halting your program? This is exactly the kind of problem that would occur
in C++. This is where a bit of magic happens. Java has a garbage
collector, which looks at all the objects that were created with new
and figures out which ones are not being referenced anymore. Then it releases
the memory for those objects, so the memory can be used for new objects. This
means that you never need to worry about reclaiming memory yourself. You simply
create objects, and when you no longer need them they will go away by
themselves. This eliminates a certain class of programming problem: the
so-called “memory leak,” in which a programmer forgets to release
memory.
|
|
Ceci am?e une question int?essante. Si Java laisse les objets tra?er,
qu'est-ce qui les emp?he de compl?ement remplir la m?oire et d'arr?er le programme ? C'est
exactement le probl?e qui surviendrait dans un programme C++. C'est l qu'un peu de magie
appara?. Java a un ramasse-miettes qui surveille tous les objets qui ont ? cr?s avec
new et qui arrive deviner lesquels ne sont plus r??enc?. Ensuite il lib?e la
m?oire de ces objets de fa?n ce que cette m?oire puisse ?re utilis? pour de nouveaux objets.
Ceci signifie qu'il ne faut jamais s'emb?er r?up?er la m?oire soi-m?e. On cr? simplement
les objets, et quand on n'en a plus besoin, ils disparaissent d'eux m?e. Ceci ?imine toute une
classe de probl?es de programmation : les soi-disant ? fuites de m?oire ? qui
arrivent quand un programmeur oublie de lib?er la m?oire.
|
|
|
|
Creating new data types: class
|
|
Cr?r de nouveaux types de donn?s : class
|
|
|
|
|
If everything is an object, what
determines how a particular class of object looks and behaves? Put another way,
what establishes the type of an object? You might expect there to be a
keyword called “type,” and that certainly would have made sense.
Historically, however, most object-oriented languages have used the keyword
class to mean “I’m about to tell you what a new type of
object looks like.” The class keyword (which is so common that it
will not be emboldened throughout this book) is followed by the name of the new
type. For example:
|
|
Si tout est objet, qu'est-ce qui d?init quoi ressemble une classe
particuli?e d'objets et comment elle se comporte ? Autrement dit, qu'est-ce qui constitue le
type d'un objet ? On pourrait s'attendre avoir un mot-clef appel
? type ?, et cela serait parfaitement sens? Historiquement, toutefois, la plupart des
langages orient? objet ont utilis le mot-clef class qui signifie ? je vais
d?rire quoi ressemble un nouveau type d'objet ?. Le mot-clef class (qui
est si commun qu'il ne sera plus mis en gras dans la suite de ce livre) est suivi par le nom du
nouveau type. Par exemple :
|
|
|
|
class ATypeName { /* class body goes here */ }
|
|
class ATypeName { /* le corps de la classe vient ici */ }
|
|
|
|
This introduces a new type, so you can
now create an object of this type using new:
|
|
Ceci introduit un nouveau type, on peut alors cr?r un objet de ce type en
utilisant new :
|
|
|
|
ATypeName a = new ATypeName();
|
|
ATypeName a = new ATypeName();
|
|
|
|
In ATypeName, the class body
consists only of a comment (the stars and slashes and what is inside, which will
be discussed later in this chapter), so there is not too much that you can do
with it. In fact, you cannot tell it to do much of anything (that is, you cannot
send it any interesting messages) until you define some methods for
it.
|
|
Dans ATypeName, le corps de la classe ne consiste qu'en un
commentaire (les ?oiles et barres obliques et ce qu'il y a l'int?ieur, ce qui sera d?rit
ult?ieurement dans ce chapitre), donc il n'y pas grand chose faire avec. En fait, on ne peut pas
lui dire de faire quoi que ce soit (c'est dire qu'on ne peut pas lui transmettre de message
int?essant) tant qu'on n'y d?init pas de m?hodes.
|
|
|
|
|
|
|
|
|
|
|
|
|
