java:bp
Différences
Ci-dessous, les différences entre deux révisions de la page.
| Les deux révisions précédentesRévision précédenteProchaine révision | Révision précédente | ||
| java:bp [2012/10/09 19:01] – bruno | java:bp [2018/11/13 16:25] (Version actuelle) – [En programmant] bruno | ||
|---|---|---|---|
| Ligne 82: | Ligne 82: | ||
| Ils se placent avant l' | Ils se placent avant l' | ||
| - | //Petite anecdote: lorsque j'ai commencé le projet [[http://natabraille.free.fr|natbraille]], | + | //Petite anecdote: lorsque j'ai commencé le projet [[http://natbraille.org|natbraille]], |
| - | Voici par exemple le code de la classe Object de java: | + | Voici par exemple le code de la classe |
| - | <code java> | ||
| - | /* | ||
| - | * Copyright (c) 1994, 2010, Oracle and/or its affiliates. All rights reserved. | ||
| - | * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. | ||
| - | * | ||
| - | * This code is free software; you can redistribute it and/or modify it | ||
| - | * under the terms of the GNU General Public License version 2 only, as | ||
| - | * published by the Free Software Foundation. | ||
| - | * particular file as subject to the " | ||
| - | * by Oracle in the LICENSE file that accompanied this code. | ||
| - | * | ||
| - | * This code is distributed in the hope that it will be useful, but WITHOUT | ||
| - | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | ||
| - | * FITNESS FOR A PARTICULAR PURPOSE. | ||
| - | * version 2 for more details (a copy is included in the LICENSE file that | ||
| - | * accompanied this code). | ||
| - | * | ||
| - | * You should have received a copy of the GNU General Public License version | ||
| - | * 2 along with this work; if not, write to the Free Software Foundation, | ||
| - | * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | ||
| - | * | ||
| - | * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA | ||
| - | * or visit www.oracle.com if you need additional information or have any | ||
| - | * questions. | ||
| - | */ | ||
| - | |||
| - | package java.lang; | ||
| - | |||
| - | /** | ||
| - | * Class {@code Object} is the root of the class hierarchy. | ||
| - | * Every class has {@code Object} as a superclass. All objects, | ||
| - | * including arrays, implement the methods of this class. | ||
| - | * | ||
| - | * @author | ||
| - | * @see | ||
| - | * @since | ||
| - | */ | ||
| - | public class Object { | ||
| - | |||
| - | private static native void registerNatives(); | ||
| - | static { | ||
| - | registerNatives(); | ||
| - | } | ||
| - | |||
| - | /** | ||
| - | * Returns the runtime class of this {@code Object}. The returned | ||
| - | * {@code Class} object is the object that is locked by {@code | ||
| - | * static synchronized} methods of the represented class. | ||
| - | * | ||
| - | * < | ||
| - | * where {@code |X|} is the erasure of the static type of the | ||
| - | * expression on which {@code getClass} is called.</ | ||
| - | * example, no cast is required in this code fragment:</ | ||
| - | * | ||
| - | * <p> | ||
| - | * {@code Number n = 0; | ||
| - | * {@code Class<? extends Number> c = n.getClass(); | ||
| - | * </p> | ||
| - | * | ||
| - | * @return The {@code Class} object that represents the runtime | ||
| - | | ||
| - | * @see Class Literals, section 15.8.2 of | ||
| - | | ||
| - | */ | ||
| - | public final native Class<?> | ||
| - | |||
| - | /** | ||
| - | * Returns a hash code value for the object. This method is | ||
| - | * supported for the benefit of hash tables such as those provided by | ||
| - | * {@link java.util.HashMap}. | ||
| - | * <p> | ||
| - | * The general contract of {@code hashCode} is: | ||
| - | * <ul> | ||
| - | * < | ||
| - | | ||
| - | | ||
| - | | ||
| - | | ||
| - | | ||
| - | * < | ||
| - | | ||
| - | | ||
| - | * < | ||
| - | | ||
| - | | ||
| - | | ||
| - | | ||
| - | | ||
| - | * </ul> | ||
| - | * <p> | ||
| - | * As much as is reasonably practical, the hashCode method defined by | ||
| - | * class {@code Object} does return distinct integers for distinct | ||
| - | * objects. (This is typically implemented by converting the internal | ||
| - | * address of the object into an integer, but this implementation | ||
| - | * technique is not required by the | ||
| - | * Java< | ||
| - | * | ||
| - | * @return | ||
| - | * @see | ||
| - | * @see | ||
| - | */ | ||
| - | public native int hashCode(); | ||
| - | |||
| - | /** | ||
| - | * Indicates whether some other object is "equal to" this one. | ||
| - | * <p> | ||
| - | * The {@code equals} method implements an equivalence relation | ||
| - | * on non-null object references: | ||
| - | * <ul> | ||
| - | * < | ||
| - | | ||
| - | | ||
| - | * < | ||
| - | | ||
| - | | ||
| - | | ||
| - | * < | ||
| - | | ||
| - | | ||
| - | | ||
| - | | ||
| - | * < | ||
| - | | ||
| - | | ||
| - | | ||
| - | | ||
| - | | ||
| - | * < | ||
| - | | ||
| - | * </ul> | ||
| - | * <p> | ||
| - | * The {@code equals} method for class {@code Object} implements | ||
| - | * the most discriminating possible equivalence relation on objects; | ||
| - | * that is, for any non-null reference values {@code x} and | ||
| - | * {@code y}, this method returns {@code true} if and only | ||
| - | * if {@code x} and {@code y} refer to the same object | ||
| - | * ({@code x == y} has the value {@code true}). | ||
| - | * <p> | ||
| - | * Note that it is generally necessary to override the {@code hashCode} | ||
| - | * method whenever this method is overridden, so as to maintain the | ||
| - | * general contract for the {@code hashCode} method, which states | ||
| - | * that equal objects must have equal hash codes. | ||
| - | * | ||
| - | * @param | ||
| - | * @return | ||
| - | | ||
| - | * @see # | ||
| - | * @see | ||
| - | */ | ||
| - | public boolean equals(Object obj) { | ||
| - | return (this == obj); | ||
| - | } | ||
| - | |||
| - | /** | ||
| - | * Creates and returns a copy of this object. | ||
| - | * of " | ||
| - | * intent is that, for any object {@code x}, the expression: | ||
| - | * < | ||
| - | * <pre> | ||
| - | * x.clone() != x</ | ||
| - | * will be true, and that the expression: | ||
| - | * < | ||
| - | * <pre> | ||
| - | * x.clone().getClass() == x.getClass()</ | ||
| - | * will be {@code true}, but these are not absolute requirements. | ||
| - | * While it is typically the case that: | ||
| - | * < | ||
| - | * <pre> | ||
| - | * x.clone().equals(x)</ | ||
| - | * will be {@code true}, this is not an absolute requirement. | ||
| - | * <p> | ||
| - | * By convention, the returned object should be obtained by calling | ||
| - | * {@code super.clone}. | ||
| - | * {@code Object}) obey this convention, it will be the case that | ||
| - | * {@code x.clone().getClass() == x.getClass()}. | ||
| - | * <p> | ||
| - | * By convention, the object returned by this method should be independent | ||
| - | * of this object (which is being cloned). | ||
| - | * it may be necessary to modify one or more fields of the object returned | ||
| - | * by {@code super.clone} before returning it. Typically, this means | ||
| - | * copying any mutable objects that comprise the internal "deep structure" | ||
| - | * of the object being cloned and replacing the references to these | ||
| - | * objects with references to the copies. | ||
| - | * primitive fields or references to immutable objects, then it is usually | ||
| - | * the case that no fields in the object returned by {@code super.clone} | ||
| - | * need to be modified. | ||
| - | * <p> | ||
| - | * The method {@code clone} for class {@code Object} performs a | ||
| - | * specific cloning operation. First, if the class of this object does | ||
| - | * not implement the interface {@code Cloneable}, then a | ||
| - | * {@code CloneNotSupportedException} is thrown. Note that all arrays | ||
| - | * are considered to implement the interface {@code Cloneable} and that | ||
| - | * the return type of the {@code clone} method of an array type {@code T[]} | ||
| - | * is {@code T[]} where T is any reference or primitive type. | ||
| - | * Otherwise, this method creates a new instance of the class of this | ||
| - | * object and initializes all its fields with exactly the contents of | ||
| - | * the corresponding fields of this object, as if by assignment; the | ||
| - | * contents of the fields are not themselves cloned. Thus, this method | ||
| - | * performs a " | ||
| - | * <p> | ||
| - | * The class {@code Object} does not itself implement the interface | ||
| - | * {@code Cloneable}, so calling the {@code clone} method on an object | ||
| - | * whose class is {@code Object} will result in throwing an | ||
| - | * exception at run time. | ||
| - | * | ||
| - | * @return | ||
| - | * @exception | ||
| - | | ||
| - | | ||
| - | | ||
| - | | ||
| - | * @see java.lang.Cloneable | ||
| - | */ | ||
| - | protected native Object clone() throws CloneNotSupportedException; | ||
| - | |||
| - | /** | ||
| - | * Returns a string representation of the object. In general, the | ||
| - | * {@code toString} method returns a string that | ||
| - | * " | ||
| - | * be a concise but informative representation that is easy for a | ||
| - | * person to read. | ||
| - | * It is recommended that all subclasses override this method. | ||
| - | * <p> | ||
| - | * The {@code toString} method for class {@code Object} | ||
| - | * returns a string consisting of the name of the class of which the | ||
| - | * object is an instance, the at-sign character `{@code @}', and | ||
| - | * the unsigned hexadecimal representation of the hash code of the | ||
| - | * object. In other words, this method returns a string equal to the | ||
| - | * value of: | ||
| - | * < | ||
| - | * <pre> | ||
| - | * getClass().getName() + ' | ||
| - | * </ | ||
| - | * | ||
| - | * @return | ||
| - | */ | ||
| - | public String toString() { | ||
| - | return getClass().getName() + " | ||
| - | } | ||
| - | |||
| - | /** | ||
| - | * Wakes up a single thread that is waiting on this object' | ||
| - | * monitor. If any threads are waiting on this object, one of them | ||
| - | * is chosen to be awakened. The choice is arbitrary and occurs at | ||
| - | * the discretion of the implementation. A thread waits on an object' | ||
| - | * monitor by calling one of the {@code wait} methods. | ||
| - | * <p> | ||
| - | * The awakened thread will not be able to proceed until the current | ||
| - | * thread relinquishes the lock on this object. The awakened thread will | ||
| - | * compete in the usual manner with any other threads that might be | ||
| - | * actively competing to synchronize on this object; for example, the | ||
| - | * awakened thread enjoys no reliable privilege or disadvantage in being | ||
| - | * the next thread to lock this object. | ||
| - | * <p> | ||
| - | * This method should only be called by a thread that is the owner | ||
| - | * of this object' | ||
| - | * object' | ||
| - | * <ul> | ||
| - | * < | ||
| - | * < | ||
| - | | ||
| - | * < | ||
| - | | ||
| - | * </ul> | ||
| - | * <p> | ||
| - | * Only one thread at a time can own an object' | ||
| - | * | ||
| - | * @exception | ||
| - | | ||
| - | * @see java.lang.Object# | ||
| - | * @see java.lang.Object# | ||
| - | */ | ||
| - | public final native void notify(); | ||
| - | |||
| - | /** | ||
| - | * Wakes up all threads that are waiting on this object' | ||
| - | * thread waits on an object' | ||
| - | * {@code wait} methods. | ||
| - | * <p> | ||
| - | * The awakened threads will not be able to proceed until the current | ||
| - | * thread relinquishes the lock on this object. The awakened threads | ||
| - | * will compete in the usual manner with any other threads that might | ||
| - | * be actively competing to synchronize on this object; for example, | ||
| - | * the awakened threads enjoy no reliable privilege or disadvantage in | ||
| - | * being the next thread to lock this object. | ||
| - | * <p> | ||
| - | * This method should only be called by a thread that is the owner | ||
| - | * of this object' | ||
| - | * description of the ways in which a thread can become the owner of | ||
| - | * a monitor. | ||
| - | * | ||
| - | * @exception | ||
| - | | ||
| - | * @see java.lang.Object# | ||
| - | * @see java.lang.Object# | ||
| - | */ | ||
| - | public final native void notifyAll(); | ||
| - | |||
| - | /** | ||
| - | * Causes the current thread to wait until either another thread invokes the | ||
| - | * {@link java.lang.Object# | ||
| - | * {@link java.lang.Object# | ||
| - | * specified amount of time has elapsed. | ||
| - | * <p> | ||
| - | * The current thread must own this object' | ||
| - | * <p> | ||
| - | * This method causes the current thread (call it < | ||
| - | * place itself in the wait set for this object and then to relinquish | ||
| - | * any and all synchronization claims on this object. Thread < | ||
| - | * becomes disabled for thread scheduling purposes and lies dormant | ||
| - | * until one of four things happens: | ||
| - | * <ul> | ||
| - | * < | ||
| - | * object and thread < | ||
| - | * the thread to be awakened. | ||
| - | * < | ||
| - | * object. | ||
| - | * < | ||
| - | * thread < | ||
| - | * < | ||
| - | * {@code timeout} is zero, however, then real time is not taken into | ||
| - | * consideration and the thread simply waits until notified. | ||
| - | * </ul> | ||
| - | * The thread < | ||
| - | * object and re-enabled for thread scheduling. It then competes in the | ||
| - | * usual manner with other threads for the right to synchronize on the | ||
| - | * object; once it has gained control of the object, all its | ||
| - | * synchronization claims on the object are restored to the status quo | ||
| - | * ante - that is, to the situation as of the time that the {@code wait} | ||
| - | * method was invoked. Thread < | ||
| - | * invocation of the {@code wait} method. Thus, on return from the | ||
| - | * {@code wait} method, the synchronization state of the object and of | ||
| - | * thread {@code T} is exactly as it was when the {@code wait} method | ||
| - | * was invoked. | ||
| - | * <p> | ||
| - | * A thread can also wake up without being notified, interrupted, | ||
| - | * timing out, a so-called < | ||
| - | * occur in practice, applications must guard against it by testing for | ||
| - | * the condition that should have caused the thread to be awakened, and | ||
| - | * continuing to wait if the condition is not satisfied. | ||
| - | * waits should always occur in loops, like this one: | ||
| - | * <pre> | ||
| - | | ||
| - | | ||
| - | | ||
| - | | ||
| - | | ||
| - | * </ | ||
| - | * (For more information on this topic, see Section 3.2.3 in Doug Lea's | ||
| - | * " | ||
| - | * 2000), or Item 50 in Joshua Bloch' | ||
| - | * Language Guide" (Addison-Wesley, | ||
| - | * | ||
| - | * <p>If the current thread is {@linkplain java.lang.Thread# | ||
| - | * interrupted} by any thread before or while it is waiting, then an | ||
| - | * {@code InterruptedException} is thrown. | ||
| - | * thrown until the lock status of this object has been restored as | ||
| - | * described above. | ||
| - | * | ||
| - | * <p> | ||
| - | * Note that the {@code wait} method, as it places the current thread | ||
| - | * into the wait set for this object, unlocks only this object; any | ||
| - | * other objects on which the current thread may be synchronized remain | ||
| - | * locked while the thread waits. | ||
| - | * <p> | ||
| - | * This method should only be called by a thread that is the owner | ||
| - | * of this object' | ||
| - | * description of the ways in which a thread can become the owner of | ||
| - | * a monitor. | ||
| - | * | ||
| - | * @param | ||
| - | * @exception | ||
| - | | ||
| - | * @exception | ||
| - | | ||
| - | * @exception | ||
| - | | ||
| - | | ||
| - | | ||
| - | | ||
| - | * @see java.lang.Object# | ||
| - | * @see java.lang.Object# | ||
| - | */ | ||
| - | public final native void wait(long timeout) throws InterruptedException; | ||
| - | |||
| - | /** | ||
| - | * Causes the current thread to wait until another thread invokes the | ||
| - | * {@link java.lang.Object# | ||
| - | * {@link java.lang.Object# | ||
| - | * some other thread interrupts the current thread, or a certain | ||
| - | * amount of real time has elapsed. | ||
| - | * <p> | ||
| - | * This method is similar to the {@code wait} method of one | ||
| - | * argument, but it allows finer control over the amount of time to | ||
| - | * wait for a notification before giving up. The amount of real time, | ||
| - | * measured in nanoseconds, | ||
| - | * < | ||
| - | * <pre> | ||
| - | * 1000000*timeout+nanos</ | ||
| - | * <p> | ||
| - | * In all other respects, this method does the same thing as the | ||
| - | * method {@link # | ||
| - | * {@code wait(0, 0)} means the same thing as {@code wait(0)}. | ||
| - | * <p> | ||
| - | * The current thread must own this object' | ||
| - | * releases ownership of this monitor and waits until either of the | ||
| - | * following two conditions has occurred: | ||
| - | * <ul> | ||
| - | * < | ||
| - | | ||
| - | | ||
| - | * < | ||
| - | | ||
| - | | ||
| - | * </ul> | ||
| - | * <p> | ||
| - | * The thread then waits until it can re-obtain ownership of the | ||
| - | * monitor and resumes execution. | ||
| - | * <p> | ||
| - | * As in the one argument version, interrupts and spurious wakeups are | ||
| - | * possible, and this method should always be used in a loop: | ||
| - | * <pre> | ||
| - | | ||
| - | | ||
| - | | ||
| - | | ||
| - | | ||
| - | * </ | ||
| - | * This method should only be called by a thread that is the owner | ||
| - | * of this object' | ||
| - | * description of the ways in which a thread can become the owner of | ||
| - | * a monitor. | ||
| - | * | ||
| - | * @param | ||
| - | * @param | ||
| - | | ||
| - | * @exception | ||
| - | | ||
| - | | ||
| - | * @exception | ||
| - | | ||
| - | * @exception | ||
| - | | ||
| - | | ||
| - | | ||
| - | | ||
| - | */ | ||
| - | public final void wait(long timeout, int nanos) throws InterruptedException { | ||
| - | if (timeout < 0) { | ||
| - | throw new IllegalArgumentException(" | ||
| - | } | ||
| - | |||
| - | if (nanos < 0 || nanos > 999999) { | ||
| - | throw new IllegalArgumentException( | ||
| - | " | ||
| - | } | ||
| - | |||
| - | if (nanos >= 500000 || (nanos != 0 && timeout == 0)) { | ||
| - | timeout++; | ||
| - | } | ||
| - | |||
| - | wait(timeout); | ||
| - | } | ||
| - | |||
| - | /** | ||
| - | * Causes the current thread to wait until another thread invokes the | ||
| - | * {@link java.lang.Object# | ||
| - | * {@link java.lang.Object# | ||
| - | * In other words, this method behaves exactly as if it simply | ||
| - | * performs the call {@code wait(0)}. | ||
| - | * <p> | ||
| - | * The current thread must own this object' | ||
| - | * releases ownership of this monitor and waits until another thread | ||
| - | * notifies threads waiting on this object' | ||
| - | * either through a call to the {@code notify} method or the | ||
| - | * {@code notifyAll} method. The thread then waits until it can | ||
| - | * re-obtain ownership of the monitor and resumes execution. | ||
| - | * <p> | ||
| - | * As in the one argument version, interrupts and spurious wakeups are | ||
| - | * possible, and this method should always be used in a loop: | ||
| - | * <pre> | ||
| - | | ||
| - | | ||
| - | | ||
| - | | ||
| - | | ||
| - | * </ | ||
| - | * This method should only be called by a thread that is the owner | ||
| - | * of this object' | ||
| - | * description of the ways in which a thread can become the owner of | ||
| - | * a monitor. | ||
| - | * | ||
| - | * @exception | ||
| - | | ||
| - | * @exception | ||
| - | | ||
| - | | ||
| - | | ||
| - | | ||
| - | * @see java.lang.Object# | ||
| - | * @see java.lang.Object# | ||
| - | */ | ||
| - | public final void wait() throws InterruptedException { | ||
| - | wait(0); | ||
| - | } | ||
| - | |||
| - | /** | ||
| - | * Called by the garbage collector on an object when garbage collection | ||
| - | * determines that there are no more references to the object. | ||
| - | * A subclass overrides the {@code finalize} method to dispose of | ||
| - | * system resources or to perform other cleanup. | ||
| - | * <p> | ||
| - | * The general contract of {@code finalize} is that it is invoked | ||
| - | * if and when the Java< | ||
| - | * machine has determined that there is no longer any | ||
| - | * means by which this object can be accessed by any thread that has | ||
| - | * not yet died, except as a result of an action taken by the | ||
| - | * finalization of some other object or class which is ready to be | ||
| - | * finalized. The {@code finalize} method may take any action, including | ||
| - | * making this object available again to other threads; the usual purpose | ||
| - | * of {@code finalize}, however, is to perform cleanup actions before | ||
| - | * the object is irrevocably discarded. For example, the finalize method | ||
| - | * for an object that represents an input/ | ||
| - | * explicit I/O transactions to break the connection before the object is | ||
| - | * permanently discarded. | ||
| - | * <p> | ||
| - | * The {@code finalize} method of class {@code Object} performs no | ||
| - | * special action; it simply returns normally. Subclasses of | ||
| - | * {@code Object} may override this definition. | ||
| - | * <p> | ||
| - | * The Java programming language does not guarantee which thread will | ||
| - | * invoke the {@code finalize} method for any given object. It is | ||
| - | * guaranteed, however, that the thread that invokes finalize will not | ||
| - | * be holding any user-visible synchronization locks when finalize is | ||
| - | * invoked. If an uncaught exception is thrown by the finalize method, | ||
| - | * the exception is ignored and finalization of that object terminates. | ||
| - | * <p> | ||
| - | * After the {@code finalize} method has been invoked for an object, no | ||
| - | * further action is taken until the Java virtual machine has again | ||
| - | * determined that there is no longer any means by which this object can | ||
| - | * be accessed by any thread that has not yet died, including possible | ||
| - | * actions by other objects or classes which are ready to be finalized, | ||
| - | * at which point the object may be discarded. | ||
| - | * <p> | ||
| - | * The {@code finalize} method is never invoked more than once by a Java | ||
| - | * virtual machine for any given object. | ||
| - | * <p> | ||
| - | * Any exception thrown by the {@code finalize} method causes | ||
| - | * the finalization of this object to be halted, but is otherwise | ||
| - | * ignored. | ||
| - | * | ||
| - | * @throws Throwable the {@code Exception} raised by this method | ||
| - | */ | ||
| - | protected void finalize() throws Throwable { } | ||
| - | } | ||
| - | |||
| - | </ | ||
| Et [[http:// | Et [[http:// | ||
| Ligne 653: | Ligne 96: | ||
| Vous constaterez au passage que **la plupart du code, c'est de la documentation!** (bien que simple, la classe Object est utilisée par tout le monde en java, il est important de fournir une documentation la plus exhaustive possible pour les programmeurs). | Vous constaterez au passage que **la plupart du code, c'est de la documentation!** (bien que simple, la classe Object est utilisée par tout le monde en java, il est important de fournir une documentation la plus exhaustive possible pour les programmeurs). | ||
| + | |||
| + | ==== Quelques outils et liens ==== | ||
| + | * [[http:// | ||
| + | * [[http:// | ||
| ===== Bonnes habitudes pour la programmation ===== | ===== Bonnes habitudes pour la programmation ===== | ||
| Ligne 659: | Ligne 106: | ||
| - utilisez des noms de classe/ | - utilisez des noms de classe/ | ||
| - ... et dans l' | - ... et dans l' | ||
| - | - déclarez toujours dans le même ordre vos attributs, constructeurs, | + | - déclarez toujours dans le même ordre vos attributs, constructeurs, |
| - | - initialisez TOUJOURS un attributs, une variable; | + | - initialisez TOUJOURS un attribut, une variable... soit lors de sa déclaration, |
| + | - ... ou faites-le systématiquement dans le constructeur; | ||
| - dès que vous ouvrez un bloc avec {, fermez-le immédiatement avec }:<code java> | - dès que vous ouvrez un bloc avec {, fermez-le immédiatement avec }:<code java> | ||
| for (int i=0; | for (int i=0; | ||
| Ligne 697: | Ligne 145: | ||
| } | } | ||
| </ | </ | ||
| + | - Vous ne devriez JAMAIS quitter une méthode qui renvoie une valeur autre part qu'à la dernière ligne, et cette dernière ligne devrait contenir la seule instruction **return** de la méthode: méfiez-vous donc des instructions **break** et des **return** multiples; | ||
| ==== En compilant ==== | ==== En compilant ==== | ||
| + | **Le compilateur est votre ami.** | ||
| + | |||
| + | Un compilateur ne s'use pas: n'ayez pas peur de l' | ||
| + | |||
| + | **Votre confiance en la qualité de votre code devrait être inversement proportionnelle à votre fréquence de compilation!** | ||
| + | |||
| + | LISEZ le premier message d' | ||
| + | |||
| + | Plus vous aurez l' | ||
| + | |||
| + | < | ||
| + | En d' | ||
| ==== En debugant ==== | ==== En debugant ==== | ||
| - | < | + | < |
| + | |||
| + | |||
| + | Un bon débogage est une des clefs de la réussite en informatique. | ||
| + | |||
| + | J'y consacre un [[java: | ||
| + | |||
| + | Gardez cependant à l' | ||
| + | |||
| + | < | ||
| + | |||
| + | Travailler à plusieurs n' | ||
| ==== En testant ==== | ==== En testant ==== | ||
| + | < | ||
| + | |||
| + | L' | ||
| + | |||
| + | Par exemple, en créant une classe de test extérieure au programme. | ||
| + | |||
| + | < | ||
| + | Faites tester votre programme par d' | ||
java/bp.1349809313.txt.gz · Dernière modification : 2012/10/09 19:01 de bruno