surcharge de méthode (overloading) - la capacité de définir plusieurs méthodes qui possèdent le même nom dans la même classe. Lorsque la méthode est appelée le compilateur choisit la méthode qu'il convient d'exécuter, en fonction des arguments qui doivent lui être passés. Les méthodes doivent avoir un nombre ou des types d'argument différents.
La surcharge de méthode est une caractéristique puissante et très utile. C'est une forme de polymorphisme paramétrique. L'idée est de créer des méthodes qui agissent de la même manière quel que soit le type des arguments et qui semblent être une seule et même méthode traitant n'importe quels types d'arguments.
public class Person { String name; int age; Person(){ name = "Penda"; age = 20; } Person(String name){ this.name=name; age=20; } Person(int age){ name="Pijo"; this.age=age; } Person(String name, int age){ this.name=name; this.age=age; } public static void main(String[] arg){ Person ps[]=new Person[4]; ps[0]= new Person(); ps[1]= new Person(22); ps[2]= new Person("Kami"); ps[3]= new Person("Simo",26); main(ps); } public static void main(Person[] ps){ for(int i=0;i<ps.length;i++){ System.out.print(ps[i].name); System.out.println(" age: "+ps[i].age); } } } |
Penda
age: 20 Pijo age: 22 Kami age: 20 Simo age: 26 |
Java utilise la technique de ramasse - miette (garbage - collector) pour supprimer les objets qui ne sont plus utiles. Le ramasse - miette travaille généralement dans un thread de faible priorité et observe les objets. Lorsque toutes les références à un objet ont disparu et qu'il n'est plus accessible, le mécanisme de ramasse – miette le détruit et renvoie l'espace ainsi libéré dans la zone de mémoire libre.
Avant qu'un objet ne soit supprimé par le ramasse – miette, sa méthode finalize() est appelée. Le ramasse – miette peut récupérer tous les ressources mémoire, mais il ne se charge pas de fermer les fichier, les connexions réseaux ou d'effectuer les actions de destruction exigés par une fonction "native". Il est important de noter qu'il n'y a aucune garantie quand l'objet sera détruit par le ramasse – miette. Il n'y a même garantie qu'il sera détruit. Dont s'il y a des actions qu'il faut faire obligatoirement il faut mieux de ne pas compter sur la méthode finalize();
Le code source pour une classe Java est appelé une unité de compilation. Une unité de compilation représente une fichier qui contient en principe une seule définition de classe et porte son nom avec une extension .java. Le compilateur compte sur les noms des fichiers sources pour trouver et générer les dépendances des classes. Il est possible d'avoir plus d'une définition de classe dans un seul fichier, mais seulement une de ces classes peut être déclarée public et c'est lui qui détermine le nom de fichier source. Après la compilation on obtient un fichier différent pour chaque classe qui porte son nom avec l'extension .class.
Au-dessus des classes il y a une couche qui regroupe les classes en unité fonctionnelles qui s'appelle paquetage. Les paquetages fournissent organisation des module en deuxième niveau. En principe une répertoire contient une seule paquetage.
L'interpréteur et le compilateur Java utilisent une variable d'environnement CLASSPATH lorsqu'ils cherchent des fichiers sur les machines où ils sont installés. La variable CLASSPATH contient le chemin où peuvent être recherchés des paquetages contenant des fichiers de classes Java.
Java peut gérer des fichier d'archives de classes au format compressé ZIP. La variable CLASSPATH des noms des répertoires ou des noms des archives ZIP, séparés par des deux-points sur un système UNIX:
CLASSPATH=/usr/lib/classes.zip:/home/momtchev/Java/classes:.
ou par points-virgules sur un système Windows:
CLASSPATH=C:\jdk1.1.5\lib\classes.zip;D:\users\momtchev\classes;.
Dans les deux cas on a spécifié trois endroits (le dernier c'est le répertoire courant). Le compilateur et interpréteur Java cherchent dans les trois endroits, l'un après l'autre pour trouver des classes. Ils s'attendent à trouver des fichiers de classes dans une arborescence de répertoires ou bien dans un répertoire du fichier archive ZIP qui corresponde parfaitement au nom complet de la classe. Les composants de nom d'un paquetage de classe deviennent les composants d'un chemin d'accès. Par exemple si on a donné un nom de classe "exemple.test.animal" java commence a le cherché dans l'archive "C:\jdk1.1.5\lib\classes.zip". Il recherche une classe archivé sous le nom " exemple/test/animal" . S'il ne le retrouve pas il le recherche dans "D:\users\momtchev\classes" et ainsi de suite.
package
monPaquetage; //premier instruction dans le fichier
import
monPaquetage.*; //pour pouvoir accéder des classes dans ce
paquetage
La classe Math fournis une ensemble de méthodes -
arithmétiques,
trigonométriques, exponentielles, logarithmiques, de nombres par
hasard, et de conversion:
| example | resultat |
| public class MathApp {
public static void main(String args[]) { System.out.println(Math.E); System.out.println(Math.PI); System.out.println(Math.abs(-1234)); System.out.println(Math.cos(Math.PI/4)); System.out.println(Math.sin(Math.PI/2)); System.out.println(Math.tan(Math.PI/4)); System.out.println(Math.log(1)); System.out.println(Math.pow(3.1,2.2)); //puissance for(int i=0;i<3;++i) System.out.print(Math.random()+" "); //dans [0, 1.0) System.out.println(); } } |
2.718281828459045 3.141592653589793 1234 0.7071067811865476 1.0 0.9999999999999999 0.0 12.050240825798763 0.797925915204636 |
Il faut noter, qu'il existe aussi une classe avec le nom Random, qui fournis plus de possibilités pour la generation des nombres par hasard. Pour l'utiliser il faut importer "java.util.Random".