t
t
t
t
t t 2) Tout est « objet »
tttt
2) Tout est « objet »
Texte original t Traducteur : Raczy
t
 t
    
Ce chapitre contient 4 pages
1 2 3 4
\\\
t t t
t t t
t
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éparation 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ère modification : 27 juin 2000
Traducteur :
- Raczy
Texte original :
-Thinking in Java, 2nd edition, Revision 10
© 2000 by Bruce Eckel
t t t
2: Everythingis an Object t 2 : Tout est Objet
t t t
Although it is based on C++, Java is more of a “pure” object-oriented language. t Bien qu'il soit basé sur C++, Java est un langage orienté objet plus « pur ».
t t t
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. t 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és indésirables de ce langage, ce qui peut rendre certains aspects du C++ particulièrement embrouillés.
t t t
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. t Le langage Java suppose qu'on ne veut faire que de la programmation orientée 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éjà). L'avantage de cet effort préliminaire 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ême un programme Java.
t t t

You manipulate objects with references

t

Les objets sont manipulés avec des références
t t t
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? t Chaque langage de programmation a ses propres façons de manipuler les données. Parfois le programmeur doit être constamment conscient du type des manipulations en cours. Manipulez-vous l'objet directement, ou avez-vous affaire à une sorte de représentation indirecte (un pointeur en C ou C++) qui doit être traité avec une syntaxe particulière ?
t t t
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. t Tout ceci est simplifié en Java. On considère tout comme des objets, ainsi il n'y a qu'une seule syntaxe cohérente qui est utilisée partout. Bien qu'on traite tout comme des objets, les identificateurs qui sont manipulés sont en réalité des « références » vers des objets [21]. On pourrait imaginer cette situation comme une télévision (l'objet) avec une télécommande (la référence). Tant qu'on conserve cette référence, on a une liaison vers la télévision, mais quand quelqu'un dit « change de chaîne » ou « baisse le volume », ce qu'on manipule est la référence, qui en retour modifie l'objet. Si on veut se déplacer dans la pièce tout en contrôlant la télévision, on emporte la télécommande/référence, pas la télévision.
t t t
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: t De plus, la télécommande peut exister par elle même sans télévision. C'est à dire que le fait d'avoir une référence ne signifie pas nécessairement qu'un objet y soit associé. Ainsi, si on veut avoir avoir un mot ou une phrase, on crée une référence sur une String :
t t t
String s;
 t
String s;
t t t
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:

 t Mais on a seulement créé la référence, pas un objet. À ce point, si on décidait d'envoyer un message à s, on aurait une erreur (lors de l'exécution) parce que s n'est pas rattachée à quoi que ce soit (il n'y a pas de télévision). Une pratique plus sûre est donc de toujours initialiser une référence quand on la crée :
t t t
String s = "asdf";
 t
String s = "asdf";
t t t
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.
 t Toutefois, ceci utilise une caractéristique spéciale de Java : les chaînes de caractères peuvent être initialisées avec du texte entre guillemets. Normalement, on doit utiliser un type d'initialisation plus général pour les objets.
t t t


You must create all the objects


 t

Vous devez créer tous les objets
t t t
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:

 t Quand on crée une référence, on veut la connecter à un nouvel objet. Ceci se fait, en général, avec le mot-clef new. new veut dire « fabrique moi un de ces objets ». Ainsi, dans l'exemple précédent, on peut dire :
t t t
String s = new String("asdf");
 t
String s = new String("asdf");
t t t
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.
 t 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îne de caractères initiale.
t t t
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.
 t Bien sûr, String n'est pas le seul type qui existe. Java propose une pléthore de types tout prêts. Le plus important est qu'on puisse créer 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.
t t t


Where storage lives


 t

Où réside la mémoire ?
t t t
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:
 t Il est utile de visualiser certains aspects de comment les choses sont arrangées lorsque le programme tourne, en particulier comment la mémoire est organisée. Il y a six endroits différents pour stocker les données :
t t t

  1. 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.

  2. 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.

  3. 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++).

  4. 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.

  5. 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).

  6. 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.
 t
  1. Les registres. C'est le stockage le plus rapide car il se trouve à un endroit différent des autres zones de stockage : dans le processeur. Toutefois, le nombre de registres est sévèrement limité, donc les registres sont alloués par le compilateur en fonction de ses besoins. On n'a aucun contrôle direct et il n'y a même aucune trace de l'existence des registres dans les programmes.
  2. 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éplacé vers le bas pour créer plus d'espace mémoire et déplacé vers le haut pour libérer cet espace. C'est un moyen extrêmement efficace et rapide d'allouer de la mémoire, supplanté seulement par les registres. Le compilateur Java doit connaître, lorsqu'il crée le programme, la taille et la durée de vie exacte de toutes les données qui sont rangées sur la pile, parce qu'il doit générer le code pour déplacer 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éférences aux objets -- les objets Java eux même ne sont pas placés sur la pile.
  3. Le segment. C'est une réserve de mémoire d'usage général (aussi en RAM) où résident 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émoire sur le segment. Lorsqu'on a besoin de créer un objet, il suffit d'écrire le code pour le créer en utilisant new et la mémoire est allouée sur le segment lorsque le programme s'exécute. Bien entendu il y a un prix à payer pour cette flexibilité : il faut plus de temps pour allouer de la mémoire sur le segment qu'il n'en faut pour allouer de la mémoire sur la pile (c'est à dire si on avait la possibilité de créer des objets sur la pile en Java, comme on peut le faire en C++).
  4. La mémoire statique. « Statique » est utilisé ici dans le sens « à un endroit fixe » (bien que ce soit aussi dans la RAM). La mémoire statique contient les données qui sont disponibles pendant tout le temps d'exécution du programme. On peut utiliser le mot-clef static pour spécifier qu'un élément particulier d'un objet est statique, mais les objets Java par eux-mêmes ne sont jamais placés dans la mémoire statique.
  5. Les constantes. Les valeurs des constantes sont souvent placées directement dans le code du programme, ce qui est sûr puisqu'elles ne peuvent jamais changer. Parfois les constantes sont isolées de façon à pouvoir être optionnellement placées dans une mémoire accessible en lecture seulement (ROM).
  6. Stockage hors RAM. Si les données résident entièrement hors du programme, elles peuvent exister même quand le programme ne tourne pas, en dehors du contrôle du programme. Les deux exemples de base sont les flots de données, pour lesquels les données sont transformées en flots d'octets, généralement pour être transmises vers une autre machine, et les objets persistants, pour lesquels les objets sont placés sur disque de façon à ce qu'ils conservent leur état même après 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 être ressuscité en un objet normal en mémoire, lorsque c'est nécessaire. Java fournit des outils pour la persistance légère, et les versions futures pourraient fournir des solutions plus complètes pour la persistance.
t t t


Special case: primitive
types


 t

Cas particulier : les types primitifs
t t t
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.
 t Il y a un ensemble de types qui sont soumis à un traitement particulier ; ils peuvent être considérés comme les types « primitifs » fréquemment utilisés en programmation. La raison de ce traitement particulier est que la création d'un objet avec new -- en particulier une simple variable -- n'est pas très 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éer la variable en utilisant new, une variable « automatique », qui n'est pas une référence, est créée. La variable contient la valeur et elle est placée sur la pile, ce qui est beaucoup plus efficace.
t t t
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.

 t 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.
t t t

  
    
    
    
    
    
  
  
    
    
    
    
    
  
  
    
    
    
    
    
  
  
    
    
    
    
    
  
  
    
    
    
    
    
  
  
    
    
    
    
    
  
  
    
    
    
    
    
  
  
    
    
    
    
    
  
  
    
    
    
    
    
  
  
    
    
    
    
    
  
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

      

 t
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
t t t
All numeric types are signed, so
don’t go looking for unsigned types.
 t Tous les types numériques sont signés, il est donc inutile d'aller chercher après des types non signés.
t t t
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.
 t
t t t
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:

 t Les types de données primitifs sont aussi associés à des classes « wrapper ». Ceci signifie que pour faire un objet non primitif sur le segment pour représenter ce type primitif il faut utiliser le wrapper associé. Par exemple :
t t t
char c = 'x';
Character C = new Character(c); 		t
char c = 'x';Character C =
  new Character(c);
t t t
Or you could also use: t On peut aussi utiliser :
t t t
Character C = new Character('x');
 t
Character C = new
  Character('x');
t t t
The reasons for doing this will be shown
in a later chapter.
 t Les raisons pour lesquelles on fait ceci seront indiquées dans un prochain chapitre.
t t t


High-precision numbers


 t

Nombres de grande précision
t t t
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.
 t Java contient deux classes pour effectuer des opérations arithmétiques de grande précision : BigInteger et BigDecimal. Bien que ceux-ci soient dans la même catégorie que les classes « wrapper », aucun d'eux n'a d'analogue primitif.
t t t
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.
 t Chacune de ces classes a des méthodes qui fournissent des opérations 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éthodes au lieu des opérateurs. Par ailleurs, comme elles en font plus, les opérations sont plus lentes. On échange la vitesse contre la précision.
t t t
BigInteger supports
arbitrary-precision integers. This means that you can accurately represent
integral values of any size without losing any information during
operations.
 t BigInteger sert aux entiers de précision arbitraire. C'est à dire qu'ils permettent de représenter des valeurs entières de n'importe quelle taille sans perdre aucune information au cours des opérations.
t t t
BigDecimal is for
arbitrary-precision fixed-point numbers; you can use these for accurate monetary
calculations, for example.
 t BigDecimal sert aux nombres à virgule fixe de précision arbitraire ; par exemple, on peut les utiliser pour des calculs monétaires précis.
t t t
Consult your online documentation for
details about the constructors and methods you can call for these two
classes.
 t Il faut se reporter à la documentation en ligne pour obtenir des détails sur les constructeurs et méthodes utilisables avec ces deux classes.
t t t


Arrays in Java


 t

Tableaux en Java
t t t
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.
 t Pratiquement tous les langages de programmation gèrent les tableaux. Utiliser des tableaux en C ou C++ est dangereux car ces tableaux ne sont que des blocs de mémoire. Si un programme accède à un tableau en dehors de son bloc mémoire, ou s'il utilise la mémoire avant initialisation (erreurs de programmation fréquentes) les résultats seront imprévisibles.
t t t
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.
 t Un des principaux objectifs de Java est la sécurité, aussi, un grand nombre des problèmes dont souffrent C et C++ ne sont pas répétés en Java. On est assuré qu'un tableau Java est initialisé et qu'il ne peut pas être accédé en dehors de ses bornes. La vérification des bornes se fait au prix d'un petit excédent de mémoire pour chaque tableau ainsi que de la vérification de l'index lors de l'exécution, mais on suppose que le gain en sécurité et en productivité vaut la dépense.
t t t
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.
 t Quand on crée un tableau d'objets, on crée en réalité un tableau de références, et chacune de ces références est automatiquement initialisée à une valeur particulière avec son propre mot clé : null. Quand Java voit null, il reconnaît que la référence en question ne pointe pas vers un objet. Il faut affecter un objet à chaque référence avant de l'utiliser et si on essaye d'utiliser une référence encore à null, le problème sera signalé lors de l'exécution. Ainsi, les erreurs typiques sur les tableaux sont évitées en Java.
t t t
You can also create an array of
primitives. Again, the compiler guarantees initialization because it zeroes the
memory for that array.
 t On peut aussi créer des tableaux de variables de type primitif. À nouveau, le compilateur garantit l'initialisation car il met à zéro la mémoire utilisée par ces tableaux.
t t t
Arrays will be covered in detail in later
chapters.
 t Les tableaux seront traités plus en détails dans d'autres chapitres.
t t t


You never need to destroy an object


 t

Vous n'avez jamais besoin de détruire un objet
t t t
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.
 t Dans la plupart des langages de programmation, le concept de durée 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étruire, quand faut-il le faire ? Des erreurs sur la durée de vie des variables peuvent être la source de nombreux bugs et cette partie montre comment Java simplifie énormément ce problème en faisant le ménage tout seul.
t t t


Scoping


 t

Notion de portée
t t t
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:

 t La plupart des langages procéduraux ont le concept de portée. Il fixe simultanément la visibilité et la durée de vie des noms définis dans cette portée. En C, C++ et Java, la portée est fixée par l'emplacement des accolades {}. Ainsi, par exemple :
t t t
{
  int x = 12;
  /* only x available */
  {
    int q = 96;
    /* both x & q available */
  }
  /* only x available */
  /* q “out of scope” */
} 		t
{
  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ée » */
}
t t t
A variable defined within a scope is available only to the end of that scope. t Une variable définie dans une portée n'est accessible que jusqu'à la fin de cette portée.
t t t
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. t L'indentation rend le code Java plus facile à lire. Étant donné que Java est un langage indépendant de la mise en page, les espaces, tabulations et retours chariots supplémentaires ne changent pas le programme.
t t t
Note that you cannot do the following, even though it is legal in C and C++: t Il faut remarquer qu'on ne peut pas faire la chose suivante, bien que cela soit autorisé en C et C++ :
t t t
{
  int x = 12;
  {
    int x = 96; /* illegal */
  }
} 		t
{
  int x = 12;
  {
    int x = 96; /* illegal */
  }
}
t t t
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. t Le compilateur annoncera que la variable x a déjà été définie. Ainsi, la faculté du C et du C++ à « cacher » une variable d'une portée plus étendue n'est pas autorisée parce que les concepteurs de Java ont pensé que ceci mène à des programmes confus.
t t t

Scope of objects

 t

Portée des objets
t t t
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: t Les objets Java n'ont pas la même durée de vie que les variables primitives. Quand on crée un objet Java avec new, il existe toujours après la fin de la portée. Ainsi, si on fait :
t t t
{
  String s = new String("a string");
} /* end of scope */ 		t
{
  String s = new String("a string");
} /* fin de portée */
t t t
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. t la référence s disparaît à la fin de la portée. Par contre l'objet String sur lequel s pointait occupe toujours la mémoire. Dans ce bout de code, il n'y a aucun moyen d'accéder à l'objet parce que son unique référence est hors de portée. Dans d'autres chapitres on verra comment la référence à un objet peut être transmise et dupliquée dans un programme.
t t t
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. t Il s'avère que du simple fait qu'un objet créé avec new reste disponible tant qu'on le veut, tout un tas de problèmes de programmation du C++ disparaissent tout simplement en Java. Il semble que les problèmes 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étruit bien les objets quand on en a terminé avec eux.
t t t
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. t Ceci amène une question intéressante. Si Java laisse les objets traîner, qu'est-ce qui les empêche de complètement remplir la mémoire et d'arrêter le programme ? C'est exactement le problème qui surviendrait dans un programme C++. C'est là qu'un peu de magie apparaît. Java a un ramasse-miettes qui surveille tous les objets qui ont été créés avec new et qui arrive à deviner lesquels ne sont plus référencés. Ensuite il libère la mémoire de ces objets de façon à ce que cette mémoire puisse être utilisée pour de nouveaux objets. Ceci signifie qu'il ne faut jamais s'embêter à récupérer la mémoire soi-même. On crée simplement les objets, et quand on n'en a plus besoin, ils disparaissent d'eux même. Ceci élimine toute une classe de problèmes de programmation : les soi-disant « fuites de mémoire » qui arrivent quand un programmeur oublie de libérer la mémoire.
t t t

Creating new data types: class

 t

Créer de nouveaux types de données : class
t t t
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: t Si tout est objet, qu'est-ce qui définit à quoi ressemble une classe particulière 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és objet ont utilisé le mot-clef class qui signifie « je vais décrire à 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 :
t t t
class ATypeName { /* class body goes here */ }
 t
class ATypeName { /* le corps de la classe vient ici */ }
t t t
This introduces a new type, so you can
now create an object of this type using new:

 t Ceci introduit un nouveau type, on peut alors créer un objet de ce type en utilisant new :
t t t
ATypeName a = new ATypeName();
 t
ATypeName a = new ATypeName();
t t t
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.


 t Dans ATypeName, le corps de la classe ne consiste qu'en un commentaire (les étoiles et barres obliques et ce qu'il y a à l'intérieur, ce qui sera décrit ultérieurement 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éressant) tant qu'on n'y définit pas de méthodes.
t t t
t t t
t t
    
///
t t t
t
     
Sommaire Le site de Bruce Eckel