Résumé Java : syntaxe de base avec exemples d’application
…
2 Syntaxe de base
La syntaxe de java est très proche de celle de C++. 2.1 Commentaires
Ils sont introduits par // et se terminent avec la ligne.
On peut aussi utiliser /* en début et */ en fin ce qui permet d'étendre les commentaires sur plusieurs lignes ou de faire des commentaires sur une partie de la ligne seulement.
2.2 Types primitifs
Les variables de type primitif ne sont pas des objets et ne se comportent donc pas comme des objets mais comme des types semblables aux autres langages.
Les types primitifs sont : char int byte short long float et double comme en C mais on trouve aussi le type boolean qui prend les valeurs true et false.
Java offre aussi des classes correspondant à ces types (Character, Integer, Byte, Short, Long, Float, Double et Boolean) . Elles permettent d'avoir un comportement standard de tous les objets utilisés.
2.3 Tableaux
Il est possible de définir des tableaux d'objets ou de types primitifs. Le dimensionnement du tableau se fait lors de sa création par new et non lors de la déclaration de son nom.
Définition d'un nom de tableau: nomDeClasse nomDeTableau[]; ou nomDeClasse[] nomDeTableau;
Création du tableau : nomDeTableau -- new nomDeClasse[dimension];
La taille d'un tableau est désignée par nomDeTableau.length
Remarque : Afin de dimensionner les tableaux il faut utiliser new même lorsqu'il s'agit de tableaux dont les éléments sont de type primitif . Par exemple : int t[]; t--new int[25]; // définit un tableau de 25 entiers
2.4 Classes prédéfinies
Java possède une grande quantité de classes regroupées par grands thèmes dans des bibliothèques standard. On y trouve la plupart des choses dont on peut avoir besoin. Par contre il souvent assez difficile de savoir quoi et où chercher.
2.4.1 Les bibliothèques de java
les classes prédéfinies en Java sont standardisées et placées dans des bibliothèques dont les noms sont eux mêmes standard :
Certaines de ces bibliothèques contiennent des sous-bibliothèques qu'il faut explicitement nommer (par exemple java.awt.events.* pour les événements)
Remarque : les classes de la bibliothèque de base java.lang n'ont pas besoin de la commande import. 2.4.2 Les chaînes de caractères
Elles sont définies dans les classes String et StringBuffer de java.lang. La première est utilisée pour les chaînes fixes et la seconde pour les chaînes variables.
On y trouve, en particulier, les méthodes suivantes
ou StringBuffer nom = StringBuffer.ValueOf(variable);
en second paramètre : int indexOf(char, int)
donné en second paramètre : int indexOf(String, int)
Transformations de chaînes en éléments simple et transformations réciproques :
- Pour transformer une chaîne en type numérique primitif il est possible d'utiliser les méthodes Integer.parseInt, Long.parseLong, Byte.parseByte et Short.parseShort qui acceptent en paramètre un objet de classe String et retournent la valeur correspondante.
Ces méthodes peuvent lever une exception de type NumberFormatException si la conversion n'est pas possible (pour le traitement des exceptions voir 7.).
- Pour transformer une chaîne de caractères en un tableau de caractères on utilisera la méthode toCharArray() de la classe String qui retourne un tableau de caractères. L'opération inverse peut être obtenue grâce au constructeur de String acceptant un tableau de caractères en paramètre.
2.4.3 Le graphique
Il fait appel à la classe Graphics de java.awt. On y trouve les méthodes habituelles de dessin. La couleur du tracé peut être définie par la méthode setColor(Color) et on peut connaître sa valeur par Color getColor().
1°) Dessiner: Les dessins se font grâce aux méthodes suivantes : Ligne: drawLine(xl, yl, x2, y2) // coordonnées des 2 extrémités
Rectangle vide : drawRect(int,int,int,int) // coordonnées (x et y) du coin supérieur gauche et dimensions (largeur et hauteur)
Rectangle plein : fillRect(int,int,int,int) // même fonctionnement
Rectangle à bords arrondis vide : drawRoundRect(int,int,int,int,int,int) // coordonnées du coin supérieur gauche (x et y), dimensions (largeur et hauteur), largeur et hauteur de l'arrondi
Rectangle à bords arrondis plein : fillRoundRect(int,int,int,int,int,int) // même fonctionnement
Ovale ou cercle vide : drawOval(int,int,int,int) // coordonnées du coin supérieur gauche (x et y) et dimensions du rectangle contenant cet ovale (largeur et hauteur)
Ovale ou cercle plein: fillOval(int,int,int,int) // même fonctionnement
Arc d'ovale ou de cercle : drawArc(int,int,int,int,int,int) // coordonnées du coin supérieur gauche (x et y), dimensions du rectangle contenant cet arc d'ovale (largeur et hauteur) et angles de début et de fin de tracé en degrés
Arc d'ovale ou de cercle plein : fillArc(int,int,int,int,int,int) // même fonctionnement
Polygone vide : drawPolygon(int[], int[], int) // liste des coordonnées en x, liste des coordonnées en y des points et nombre de points
Polygone plein : fillPolygon(int[], int[], int) // même fonctionnement
Effacement d'une zone rectangulaire : clearRect(int,int,int,int) // coordonnées du coin supérieur gauche (x et y) et dimensions du rectangle à effacer (largeur et hauteur)
Ecriture de caractères : drawString(String, int, int) dessine le texte donné dans le 1er paramètre. Les deux derniers paramètres désignent les coordonnées (x et y) à partir desquelles sera dessiné ce texte (y est utilisé pour placer le bas du texte). La couleur et la fonte utilisées sont celles associées à l'objet Graphics.
2°) Les images : La classe Graphics permet l'affichage d'images au format gif ou jpeg. pour cela on dispose de la méthode drawImage(Image, int, int, ImageObserver) dont les paramètres sont les suivants : image à dessiner, coordonnées du coin supérieur gauche où la placer et composant qui gère l'image (c'est en général celui dont on a utilisé la méthode getGraphics()). On peut ajouter deux paramètres après les coordonnées du coin supérieur gauche pour définir les dimensions désirées de l'image (en horizontal et vertical), elle sera alors être déformée pour adopter ces dimensions.
La classe Image permet de faire quelques traitements élémentaires sur les images en voici les principaux:
int getHeight(ImageObserver) retourne la hauteur de l'image en pixels.
int getWidth(ImageObserver) retourne la largeur de l'image en pixels.
Image getScaledInstance(int, int, int) retourne une copie redimensionnée de l'image. les deux premiers paramètres précisent la hauteur et la largeur désirées pour la copie. Si l'un d'entre eux vaut —1 il sera adapté pour conserver l'aspect initial de l'image. Le dernier paramètre indique l'algorithme à utiliser pour créer cette copie. Il peut prendre les valeurs :
Image.SCALE_DEFAULT algorithme standard
Image.SCALE_FAST algorithme rapide
Image.SCALE_SMOOTH algorithme qui préserve la qualité de l'image
Image.SCALE_REPLICATE algorithme simple qui se contente de dupliquer ou d'enlever des pixels
Image.SCALE_AVERAGING algorithme qui utilise une méthode basée sur la moyenne entre pixels
voisins.
2.4.4 Les couleurs
En java les couleurs sont des objets de la classe Color. Cette classe est dotée d'un constructeur permettant de créer une couleur en donnant les proportions de ses composantes rouge, verte et bleue ( ces proportions sont données par des nombres compris entre 0 et 255 que l'on peut considérer comme des pourcentages):
Color maCouleur = new Color(120 , 255 , 22);
Réciproquement on trouve des méthodes permettant de récupérer les composantes rouge verte et bleue d'une couleur ces méthodes sont int getRed() , int getGreen() et int getBlue().
Les méthodes Color darker() et Color brighter() retournent une couleur plus foncée (resp. plus claire) que l'objet dont on a invoqué ces méthodes.
Il existe d'autres méthodes liées aux couleurs qui ne seront pas détaillées ici.
2.4.5 les fontes de caractères
En java les fontes de caractères sont des objets de la classe Font. Cette classe est dotée d'un constructeur permettant de créer une fonte en donnant son nom, son style et sa taille. Le style est une somme des constantes PLAIN, BOLD et ITALIC la taille est donnée en points :
Font maFonte = new Font(″ Serif″ , Font.BOLD+Font.ITALIC, 14);
Les fontes traditionnellement disponibles sont Dialog, DialogInput, Serif, SansSerif et Monospaced. Les 3 dernières correspondent à Times, Helvetica et Courrier.
Les informations concernant les tailles des textes écrits peuvent être obtenues grâce à la méthode
getFontMetrics() de la classe Graphics. Cette méthode retourne un objet de classe FontMetrics qui possède en particulier les méthodes suivantes :
int getHeight() qui donne la hauteur (en pixels) d'une ligne de texte
int charWidth(char ch) qui donne la longueur (en pixels) du caractère passé en paramètre
int stringWidth(String str) qui donne la longueur (en pixels) de la ligne passée en paramètre
Il existe d'autres méthodes liées aux fontes qui ne seront pas détaillées ici.
2.5 Constantes
Elles sont déclarés par le mot clé final par exemple : final int x=7;
2.6 Opérateurs
Ce sont les mêmes qu'en C++ :
= est l'opérateur d'affectation
+ = * et / sont les opérateurs arithmétiques
< <= > >= == et != sont les opérateurs de comparaison. Attention la comparaison porte sur les valeurs s'il s'agit de types primitifs mais sur les noms s'il s'agit d'objets. Si l'on veut comparer le contenu d'objets il faut les doter (si ce n'est pas déjà fait) d'une méthode de comparaison généralement appelée equals.
! ~~et && sont les opérateurs logiques
Enfin, on trouve des opérateurs d'incrémentation (++) et de décrémentation (==).
3 Classes
Tout objet doit appartenir à une classe. Il en constitue une instance. Les membres d'une classe (variables et méthodes) peuvent se voir doter d'un niveau de protection par utilisation des mots clés (public, private et protected). Les niveaux de protection font référence à la notion de paquetage. On peut placer certaines classes dans un paquetage en mettant, au début du fichier contenant cette classe package nomDuPaquetage;
Lorsqu'aucune protection n'est mise l'accès est possible depuis toute classe du même paquetage
Remarque : Lorsqu'une classe n'est associée à aucun paquetage, elle appartient au paquetage par défaut de java.. 3.1 Définition d’une classe
La classe est définie dans un fichier .java dont le nom doit être le même que celui de la classe (par exemple ici le fichier devra s'appeler Cible.java) :
class Cible; // nom de la classe
{
public int coordX , coordY; // deux entiers accessibles partout
private StringBuffer nom; // une chaîne non accessible de l'extérieur
public void init() // une méthode sans paramètres
{
// corps de cette méthode }
public void init(int,int) // une autre version de la méthode avec paramètres
{
// corps de cette méthode
}
void deplace(int,int) // une autre méthode accessible
{ //dans le même paquetage
// corps de cette méthode }
}
Plusieurs méthodes peuvent porter le même nom à condition qu'elles se distinguent par leurs paramètres (surdéfinition). Ceci permet de définir plusieurs façons de demander à l'objet de réaliser une certaine opération. Ainsi dans l'exemple précédent on dispose de deux méthodes init l'une avec et l'autre sans paramètres.
Attention : java distingue les majuscules et les minuscules dans les noms de classes et de variables mais aussi de fichiers.
3.2 Utilisation d’objets
Pour pouvoir utiliser un objet il faut:
Cible a; // déclaration d'un nom (a) devant être associé à des objets de classe Cible
a=new Cible(); // création d'une instance d'objet de classe Cible associée au nom a
a.init(4,5); // appel de la méthode init de a avec paramètres
Cible b; // déclaration d'un nom (b) devant être associé à des objets de classe Cible
b=a; // a et b sont deux noms pour le même objet
b.init(); // appel de la méthode init de b (c'est à dire de a) sans paramètres
b=new Cible (); /* création d'une instance d'objet de classe Cible associée au nom b qui n'est dès lors plus un autre nom pour a mais bien un nouvel objet */ if (b.coordX==5) // accès à un élément de b (coordX) qui est un entier, possible car il est public
3.3 Nom de l’instance courante
Lorsque l'on est dans une méthode d'un objet le nom this est toujours un nom de cet objet. 3.4 Appartenance à une classe
On peut tester l'appartenance d'un objet à une classe par l'opérateur instanceof de la façon suivante : If (tresnaHori instanceof Cible) { /* tresnaHori est une cible */ } else { /* tresnaHori n'est pas une cible */ }
3.5 Classe interne
On peut déclarer une classe à l'intérieur d'une autre comme suit :
class Exterieure {
public class Interieure {
// contenu de la classe Interieure
}
// reste du contenu de la classe Exterieure
}
A l'extérieur de la classe Exterieure, on désigne alors cette classe par son nom complet : Exterieure.Interieure.
Bien entendu ce nom n'est accessible de l'extérieur que si la classe interne a été désignée par public. Si elle a été désignée private, elle n'est visible que dans la classe Exterieure () et, si rien n'a été précisé, dans le reste de l'application.
Remarque : A chaque création d'un objet x de classe Exterieure il y a création d'une classe Interieure dont on pourra par la suite créer autant d'instances d'objets que l'on voudra. Toutes seront liées à cet objet x.
4 Construction d’objets
Le constructeur est une méthode appelée lors de la création de l'objet (utilisation de new). Il porte le même nom que la classe et peut accepter des paramètres.
public Cible(paramètres) { // le constructeur de la classe Cible
//corps du constructeur
}
Lorsque un objet est créé (par utilisation de new), le constructeur est appelé et doit recevoir ses paramètres (s'il en a). Il faut faire : Cible a = new Cible (liste de paramètres);
5 L’Héritage
L'Héritage permet de définir de nouvelles classes à partir de classes existantes. La nouvelle classe ainsi définie hérite des membres et des méthodes de sa classe mère et y ajoute ses propres membres et méthodes.
Un objet d'une classe B héritière de la classe A est aussi un objet de classe A et peut remplacer à tout instant un objet de classe A. En effet, un objet de classe B est au moins capable de se comporter comme un objet de classe A (il peut en général faire même plus).
Certaines méthodes de A peuvent être redéfinies dans B (on dit surchargées). Il conviendra que ces surcharges conservent la sémantique des méthodes initiales de façon à ce que le comportement d'un objet de classe B utilisé en lieu et place d'un objet de classe A reste cohérent. Si une méthode de A a été qualifiée par final elle ne peut pas être redéfinie dans B.
Lorsque l'on invoque une méthode d'un objet, java en recherche la définition de cette méthode dans la classe de cet objet, s'il ne la trouve pas il la recherche dans sa classe mère et ainsi de suite jusqu'à la rencontrer.
5.1 Définition d’une classe dérivée
class Nouvelle extends Ancienne { // définition d'une classe Nouvelle par héritage de la classe Ancienne // contenu de la nouvelle classe
}
La conception de Nouvelle peut utiliser tout ce qui n'est pas privé (private) dans Ancienne. Elle n'autorise pas les accès aux membres ou méthodes privées de Ancienne. L'utilisateur d'un objet de la classe Nouvelle pourra utiliser les méthodes publiques de Ancienne et celles de Nouvelle.
5.2 Surcharge de méthodes héritées
Si des méthodes de la classe Nouvelle (obtenue par héritage de Ancienne) ont le même nom que certaines existant dans Ancienne, elles viennent les cacher (surcharge). Pour appeler une méthode de Ancienne dans nouvelle il faut la préfixer par super. Par exemple si Ancienne contient une méthode void calcul(int) qui est redéfinie dans Nouvelle, on peut appeler dans Nouvelle l'ancienne version de calcul par super.calcul(x)
5.3 Construction
Le constructeur de la classe Nouvelle peut faire appel à celui de la classe Ancienne par: super(paramètres). Mais ceci doit être impérativement fait au tout début du corps du constructeur de Nouvelle (1ere instruction).
Si ce n'est pas fait c'est le constructeur sans paramètres de la classe Ancienne qui sera utilisé (s'il y en a un).
Un objet d'une classe dérivée est objet de la classe de base et pas le contraire
5.4 Polymorphisme, classe Object et coercition
Un objet de classe B dérivée de A peut être utilisé partout où un objet de A peut l'être. Si une méthode de A a été redéfinie dans B on utilisera celle de B.
A quoi sert le polymorphisme ?
Si on définit une classe L qui est une liste d'objets de classe A, on pourra mettre dans cette liste des objets de n'importe quelle classe à partir du moment où elle est hérité de A.
Java introduit la classe Object qui est celle dont héritent implicitement toutes les classes définies en java (mais pas les types primitifs). Ainsi, tout objet peut être vu comme appartenant à la classe Object et donc, par exemple, être mis dans une liste dont les éléments sont de cette classe. On peut ensuite indiquer la classe réelle de cet objet en utilisant l'opérateur de coercition (nom de la classe réelle entre parenthèses) :
(nomDeClasse) objetDeClasseObject
qui permet de préciser que objetDeClasseObject est de classe nomDeClasse.
5.5 Les collections
Java propose une certain nombre de classes permettant de gérer des collections d'objets quelconques. Ces classes utilisent le polymorphisme et le fait que toute classe dans Java hérite de la classe Object. Ainsi il est possible de définir des tableaux ou des liste d'Objets dans lesquels on pourra mettre tout objet défini en Java.
5.5.1 La classe Vector
Elle permet de gérer des tableaux d'objets. Ces tableaux ont une taille qui croit au fur et à mesure que l'on les remplit. Le taux de croissance peut être défini de façon a éviter de trop fréquentes réorganisations des données en mémoire. On y trouve les méthodes suivantes :
Vector(int,int) permet de créer un vecteur en en précisant la taille initiale et le taux de croissance.
void insertElementAt(Object, int) qui ajoute un objet au rang précisé.
void addElement(Object) qui ajoute un objet à la fin du tableau.
void removeAllElements() qui vide la liste
boolean contains(Object) qui retourne true si l'objet est dans la liste
void copyInto(Object[]) qui copie le vecteur dans un tableau d'objets.
Object elementAt(int) qui retourne l'objet de rang donné (il faudra utiliser la coercition pour rétablir cet objet dans sa classe d'origine)
Object firstElement() qui retourne le premier objet (il faudra utiliser la coercition pour rétablir cet objet dans sa classe d'origine)
Object lastElement() qui retourne le dernier objet (il faudra utiliser la coercition pour rétablir cet objet dans
sa classe d'origine)
int indexOf(Object, int) qui retourne le rang de la première occurrence de l'objet en commençant à partir de l'index précisé en second paramètre. Si le second paramètre est omis, le recherche commence au début.
int lastIndexOf(Object, int) qui retourne le rang de la dernière occurrence de l'objet en ne dépassant pas le rang précisé en second paramètre. Si le second paramètre est omis, le recherche va jusqu'à la fin.
void removeElementAt(int) qui supprime l'objet de rang donné.
void removeElement(Object) qui supprime la première occurrence de l'objet donné.
void removeRange(int, int) qui supprime tous les objets entre les 2 rangs donnés.
void setElementAt(int, Object) qui remplace l'objet de rang indiqué par celui passé en second paramètre.
boolean isEmpty() qui indique si la liste est vide.
int size() qui donne la taille de la liste.
5.5.2 La classe LinkedList
Elle permet de gérer des liste d'objets On y trouve les méthodes suivantes :
void add(int, Object) qui ajoute un objet au rang précisé. Si le rang est omis, l'objet est rajouté à la fin.
void clear() qui vide la liste
boolean contains(Object) qui retourne true si l'objet est dans la liste
Object get(int) qui retourne l'objet de rang donné (il faudra utiliser la coercition pour rétablir cet objet dans sa classe d'origine)
Object getFirst() qui retourne le premier objet (il faudra utiliser la coercition pour rétablir cet objet dans sa classe d'origine)
Object getLast() qui retourne le dernier objet (il faudra utiliser la coercition pour rétablir cet objet dans sa classe d'origine)
int indexOf(Object) qui retourne le rang de la première occurrence de l'objet
int lastIndexOf(Object) qui retourne le rang de la dernière occurrence de l'objet
Object remove(int) qui supprime l'objet de rang donné. La valeur de retour est cet objet.
Object removeFirst() qui supprime le premier objet. La valeur de retour est cet objet.
Object removeLast() qui supprime le dernier objet. La valeur de retour est cet objet.
Object set(int, Object) qui remplace l'objet de rang indiqué par celui passé en second paramètre. La valeur de retour est l'objet remplacé.
int size() qui donne la taille de la liste.
Remarque : Il existe bien d'autres collections dans la bibliothèque java.utils (piles, arbres ...). 5.6 Héritage multiple
Java ne possède pas d'héritage multiple. Il existe toutefois la notion d'interface qui permet de doter une classe d'un certain nombre de méthodes définies dans une interface. De plus, on peut faire hériter une classe d'une autre et lui adjoindre une interface.
5.6.1 Définition d’interface
On utilise le mot clé interface au lieu du mot clé class.
interface NomDInterface {
// contenu de l'interface
}
Une interface est une classe abstraite sans données qui ne peut servir qu'à être adjointe à d'autres classes.
5.6.2 Héritage et interface
Pour définir une classe qui possède une interface on utilise le mot clé implements au lieu du mot clé extends : class Nomc implements NomDInterface {
// contenu de la classe Nomc
}
On peut cumuler ceci avec un héritage normal :
class Nomhc extends NomDeClasseMere implements NomDInterface { // contenu de la classe Nomhc
}
6 Entrées / Sorties 6.1 Les flots
Les entrées/sorties en java se font par des flots. Ceux-ci s'appliquent aussi bien aux entrées/sorties classiques clavier et écran qu'à celles sur fichier ou sur internet.
6.1.1 Les flots standard
Les classes de base pour définir les flots sont InputStream et OutputStream. Elles possèdent une grande quantité de classes dérivées dont les plus utilisées sont les classes PrintStream pour les sorties et DataInputStream et BufferedReader pour les entrées.
La classe OutputStream n'offre que la méthode write permettant d'écrire un ou plusieurs octets. La classe PrintWriter offre en plus les méthodes print et println qui connaissent les types primitifs. Il est possible de construire un objet de la classe PrintWriter à partir d'un objet de la classe OutputStream en faisant: PrintWriter ecriture = new PrintWriter(objet de classe OutputStream);
La classe InputStream n'offre que la méthode read permettant de lire un ou plusieurs octets. Toutefois il est possible de construire un objet de la classe DataInputStream à partir d'un objet de la classe InputStream en faisant:
DataInputStream lecture = new DataInputStream(objet de classe InputStream);
La classe DataInputStream offre alors les méthodes adaptées aux types primitifs comme readInt , readChar, readLong etc.
Pour ce qui est des chaînes de caractères, elles peuvent être transmises sans problème aux méthodes print et println. Par contre leur lecture doit faire appel à la méthode readLine qui n'existe pas dans la classe DataInputStream. Il faut alors utiliser un objet de la classe BufferedReader que l'on peut construire à partir d'un objet de la classe InputStream en faisant:
BufferedReader lectChaine = new BufferedReader(new InputStreamReader(objet de classe InputStream));
Remarque : toutes les méthodes permettant la lecture sur un flot peuvent lever une exception de classe IOException en cas d'erreur et EOFException s'il n'y a pas assez d'entrées pour terminer la lecture (pour le traitement des exceptions voir 7.).
6.1.2 Objets et Flots
On peut utiliser des flots pour envoyer et recevoir des objets via des fichiers ou le réseau. Pour cela on utilise les classes ObjectOutputStream et ObjectInputStream. La création de tels objets à partir d'un flot existant associé à une URL (voir 6.3), une socket ou un fichier (voir 6.4) se fait par le constructeur : ObjectOutputStream(OutputStream)
ObjectInputStream(InputStream)
Le transfert des objets fait alors appel aux méthodes :
Objet readObject() pour la classe ObjectInputStream. Cette méthode peut lever les exceptions : ClassNotFoundException, OptionalDataException et IOException
Et void writeObject(Objet) pour la classe ObjectOutputStream. Cette méthode peut lever l'exception IOException
Les deux classes possèdent une méthode close() qui ferme le flot.
La classe ObjectOutputStream possède en outre une méthode flush() qui assure que toutes les données soient transmises.
ATTENTION: pour qu'un objet puisse être transmis par un flot il doit implémenter l'interface Serializable de java.io.
6.2 Clavier et écran
On utilise la classe System qui possède deux flux de sortie et un d'entrée. Celui d'entrée correspond au clavier ceux de sortie sont respectivement associés à l'écran et au terminal d'erreur. On les désigne comme suit:
Remarque : Les navigateurs possèdent en général une fenêtre associée à ces terminaux : c'est la fenêtre `Console Java'.
6.3 Les URL(Uniform Resource Locator)
Une URL (Uniform Resource Locator) permet de désigner une information sur le réseau. Elle contient le protocole (http : //), la désignation de la machine hôte (iutbay.univ-pau.fr/) parfois accompagnée d'un numéro de port (iutbay.univ-pau.fr :64111/), celle de l'information sur cette machine (java/index.html) et parfois d'une étiquette dans cette information (#etiq).
Remarque : Lorsque l'on désire désigner un fichier local on doit créer une URL avec le protocole file, cela s'écrit de la façon suivante: " file:///D:/java/documents/nom.txt"
Ses principales méthodes sont:
URL(String) construction à partir du texte passé en paramètre. Si ce texte ne fournit pas une URL correcte, une exception de classe MalformedURLException est déclenchée.
URL(URL,String) construction à partir d'une URL complétée par le texte passé en paramètre. Si ceci ne fournit pas une URL correcte, une exception de classe MalformedURLException est déclenchée.
URL(String, String, String) construction à partir du protocole (1er paramètre), de la machine hôte (2ème paramètre) et de la désignation de l'information (3ème paramètre). Si ces paramètres ne fournissent pas une URL correcte, une exception de classe MalformedURLException est déclenchée (voir 7).
String toString() qui retourne l'URL sous forme de chaîne de caractères.
String get~ile() qui retourne la désignation de l'information contenue dans cette URL.
String getHost() qui retourne la désignation de la machine hôte contenue dans cette URL.
int getPort() qui retourne le numéro de port contenu dans cette URL s'il y en a un et —1 dans la cas contraire. String getProtocol() qui retourne la désignation du protocole contenue dans cette URL.
InputStream openStream() qui établit la connexion à cette URL et retourne un flot permettant de récupérer l'information qu'elle contient. En cas d'impossibilité une exception de classe IOException est levée (voir 7).
URLConnection openConnection() qui crée un objet de connexion qui permettra d'établir la communication.
6.4 Communication sur le réseau par sockets en Java
Java permet de communiquer par sockets. Il utilise pour cela les classes Socket et ServerSocket placées dans la bibliothèque java.net.
Ces sockets permettent d'établir une connexion en utilisant un nom de machine hôte et un numéro de port puis de communiquer par des flux java standards (InputStreamReader et OutputStreamReader ou autres classes de flux).
6.4.1 La classe Socket
Elle est utilisée pour toute communication entre client et serveur. Ses principales méthodes sont :
6.4.2 La classe ServerSocket
Elle est utilisée par le serveur comme socket d'écoute. Ses principales méthodes sont :
6.4.3 Les flux associés aux sockets
Les méthodes getInputStream() et getOutputStream() retournent des flux de classe InputStream et OutputStream. On peut ensuite, à partir de ces flux, en créer d'autres selon le mode de communication que l'on désire employer (chaînes de caractères, types primitifs, objets ...)
Exemple, pour une communication par chaînes de caractères :
En entrée : BufferedReader lire=new BufferedReader(new InputStreamReader(maSocket.getInputStream())); En sortie : PrintWriter ecrire=new PrintWriter(new BufferedOutputStream(maSocket.getOutputStream())); Ne pas oublier d'utiliser, à la fin de la communication, la méthode close des flux ainsi créés pour les fermer.
6.5 Les Fichiers
Ils sont représentés par la classe File. Ses principales méthodes sont :
File(String) construction avec le nom passé en paramètre.
createNewFile() création d'un nouveau fichier physique (il faut que le nom donné à la construction ne corresponde pas déjà à un fichier). Cette méthode peut lever une exception de classe IOException.
boolean mkdir() création d'un nouveau répertoire la valeur en retour est true si la création a été faite
boolean mkdirs() création d'un nouveau répertoire avec tous les sous répertoires en amont la valeur en retour
est true si la création a été faite
boolean canRead() indique si le fichier peut être lu
boolean canWrite() indique si le fichier peut être écrit.
boolean delete() destruction du fichier la valeur en retour est true si la destruction a été faite.
deleteOnExit() destruction du fichier lors de l'arrêt de la machine virtuelle java.
boolean exists() indique si le fichier existe.
String getAbsolutePath() retourne le chemin absolu du fichier
boolean isDirectory() indique si le nom correspond à un répertoire.
boolean isFile() indique si le nom correspond à un fichier.
boolean isflidden() indique si le nom correspond à un répertoire ou fichier caché.
long length() retourne la taille du fichier.
boolean setReadOnly() met le fichier en mode lecture seule la valeur en retour est true si l'opération a été
faite.
URL toURL() convertit le nom du fichier en URL. Cette méthode peut lever une exception de classe
MalformedURLException
Remarque : la plupart de ces méthodes peuvent lever une exception de classe SecurityException.
Les accès aux fichiers font appel à des flots (voir 6.1) de classe FileOutputStream et FileInputStream. On les obtient en passant en paramètre à leur constructeur un l'objet de classe File.
FileoutputStream hérite de OutputStream tandis que FileInputStream hérite de InputStream. Ils offrent des accès à l'information en mode octet. Et possèdent une méthode close() .
