Document de Synthèse 3 & 4

JAVA SE

MOHAMED KONATE
TECHNOLAB-ISTA
 Java - Méthodes
Une méthode Java est une collection d'instructions qui sont regroupées pour
effectuer une opération. Lorsque vous appelez le System.out. println() , par exemple,
le système exécute en fait plusieurs instructions afin d'afficher un message sur la
console.
Vous allez maintenant apprendre à créer vos propres méthodes avec ou sans valeurs
de retour, à invoquer une méthode avec ou sans paramètres et à appliquer
l'abstraction de méthode dans la conception du programme.

Méthode de création
Considérant l'exemple suivant pour expliquer la syntaxe d'une méthode -
Syntaxe
public static int methodName(int a, int b) {
// body
}
Ici,
• public static − modificateur
• int - type de retour
• methodName - nom de la méthode
• a, b − paramètres formels
• int a, int b − liste de paramètres
La définition de méthode se compose d'un en-tête de méthode et d'un corps de
méthode. La même chose est montrée dans la syntaxe suivante -
Syntaxe
modifier returnType nameOfMethod (Parameter List) {
// method body
}
La syntaxe ci-dessus comprend -
• modifier - Il définit le type d'accès de la méthode et son utilisation est
facultative.
• returnType - La méthode peut renvoyer une valeur.
• nameOfMethod - Il s'agit du nom de la méthode. La signature de la
méthode se compose du nom de la méthode et de la liste des
paramètres.
 • Liste de paramètres - La liste des paramètres, c'est le type, l'ordre et le
nombre de paramètres d'une méthode. Ceux-ci sont facultatifs, la
méthode peut contenir zéro paramètre.
• corps de la méthode - Le corps de la méthode définit ce que la méthode
fait avec les instructions.
Exemple
Voici le code source de la méthode définie ci-dessus appelée min() . Cette méthode
prend deux paramètres num1 et num2 et renvoie le maximum entre les deux -

/** the snippet returns the minimum between two numbers */

public static int minFunction(int n1, int n2) {

int min;
if (n1 > n2)
min = n2;
else
min = n1;

return min;
}

Appel de méthode
Pour utiliser une méthode, il faut l'appeler. Il existe deux manières d'appeler une
méthode, c'est-à-dire que la méthode renvoie une valeur ou ne renvoie rien (pas de
valeur de retour).
Le processus d'appel de méthode est simple. Lorsqu'un programme invoque une
méthode, le contrôle du programme est transféré à la méthode appelée. Cette
méthode appelée rend ensuite le contrôle à l'appelant dans deux conditions, lorsque
-

• l'instruction return est exécutée.

• il atteint l'accolade fermante de fin de méthode.
Les méthodes renvoyant void sont considérées comme un appel à une
instruction. Prenons un exemple -

System.out.println("This is tutorialspoint.com!");

La méthode renvoyant la valeur peut être comprise par l'exemple suivant -

int result = sum(6, 9);

Voici l'exemple pour montrer comment définir une méthode et comment l'appeler -
Exemple
public class ExampleMinNumber {

public static void main(String[] args) {

int a = 11;
int b = 6;
int c = minFunction(a, b);
System.out.println("Minimum Value = " + c);
}

/** returns the minimum of two numbers */

public static int minFunction(int n1, int n2) {
int min;
if (n1 > n2)
min = n2;
else
min = n1;

return min;
}
}

Cela produira le résultat suivant -

Production
Minimum value = 6
Le mot void
Le mot-clé void nous permet de créer des méthodes qui ne retournent pas de
valeur. Ici, dans l'exemple suivant, nous considérons une méthode
vide methodRankPoints . Cette méthode est une méthode void, qui ne renvoie
aucune valeur. L'appel à une méthode void doit être une instruction, c'est-à-
dire methodRankPoints(255.7); . Il s'agit d'une instruction Java qui se termine par un
point-virgule, comme illustré dans l'exemple suivant.
Exemple

public class ExampleVoid {

public static void main(String[] args) {

methodRankPoints(255.7);
}

public static void methodRankPoints(double points) {

if (points >= 202.5) {
System.out.println("Rank:A1");
}else if (points >= 122.4) {
System.out.println("Rank:A2");
 }else {
System.out.println("Rank:A3");
}
}
}

Cela produira le résultat suivant -

Production
Rank:A1

Passer des paramètres par valeur

Tout en travaillant sous le processus d'appel, les arguments doivent être
passés. Ceux-ci doivent être dans le même ordre que leurs paramètres respectifs
dans la spécification de la méthode. Les paramètres peuvent être passés par valeur
ou par référence.
Passer des paramètres par valeur signifie appeler une méthode avec un
paramètre. Grâce à cela, la valeur de l'argument est transmise au paramètre.
Exemple
Le programme suivant montre un exemple de passage de paramètre par valeur. Les
valeurs des arguments restent les mêmes même après l'invocation de la méthode.

public class swappingExample {

public static void main(String[] args) {

int a = 30;
int b = 45;
System.out.println("Before swapping, a = " + a + " and b = " + b);

// Invoke the swap method

swapFunction(a, b);
System.out.println("\n**Now, Before and After swapping values will be same here**:");
System.out.println("After swapping, a = " + a + " and b is " + b);
}

public static void swapFunction(int a, int b) {

System.out.println("Before swapping(Inside), a = " + a + " b = " + b);

// Swap n1 with n2
int c = a;
a = b;
b = c;
System.out.println("After swapping(Inside), a = " + a + " b = " + b);
}
}
Cela produira le résultat suivant -
Production
Before swapping, a = 30 and b = 45
Before swapping(Inside), a = 30 b = 45
After swapping(Inside), a = 45 b = 30

**Now, Before and After swapping values will be same here**:

After swapping, a = 30 and b is 45
Surcharge de méthode
Lorsqu'une classe a deux méthodes ou plus portant le même nom mais des
paramètres différents, on parle de surcharge de méthode. C'est différent de
l'écrasement. En surcharge, une méthode a le même nom de méthode, le même type,
le même nombre de paramètres, etc.
Considérons l'exemple discuté précédemment pour trouver des nombres minimaux
de type entier. Si, disons que nous voulons trouver le nombre minimum de type
double. Ensuite, le concept de surcharge sera introduit pour créer deux ou plusieurs
méthodes avec le même nom mais des paramètres différents.
L'exemple suivant explique la même chose -
Exemple

public class ExampleOverloading {

public static void main(String[] args) {

int a = 11;
int b = 6;
double c = 7.3;
double d = 9.4;
int result1 = minFunction(a, b);

// same function name with different parameters

double result2 = minFunction(c, d);
System.out.println("Minimum Value = " + result1);
System.out.println("Minimum Value = " + result2);
}

// for integer
public static int minFunction(int n1, int n2) {
int min;
if (n1 > n2)
min = n2;
else
min = n1;

return min;
}

// for double
public static double minFunction(double n1, double n2) {
double min;
if (n1 > n2)
min = n2;
else
min = n1;

return min;
}
}

Cela produira le résultat suivant -

Production
Minimum Value = 6
Minimum Value = 7.3
La surcharge des méthodes rend le programme lisible. Ici, deux méthodes portent le
même nom mais avec des paramètres différents. Le nombre minimum de types
entiers et doubles est le résultat.
Le mot-clé this
this est un mot clé en Java qui sert de référence à l'objet de la classe courante, avec
dans une instance une méthode ou un constructeur. En utilisant cela , vous pouvez
référencer les membres d'une classe tels que les constructeurs, les variables et les
méthodes.
Remarque - Le mot clé this est utilisé uniquement dans les méthodes d'instance ou
les constructeurs

En général, le mot-clé this est utilisé pour −

• Différenciez les variables d'instance des variables locales si elles
portent le même nom, au sein d'un constructeur ou d'une méthode.
class Student {
int age;
Student(int age) {
this.age = age;
}
}
• Appelez un type de constructeur (constructeur paramétré ou par défaut)
à partir d'un autre dans une classe. C'est ce qu'on appelle l'invocation
explicite du constructeur.
class Student {
int age
Student() {
this(20);
}

Student(int age) {
this.age = age;
}
}
Exemple
Voici un exemple qui utilise ce mot clé pour accéder aux membres d'une
classe. Copiez et collez le programme suivant dans un fichier
nommé This_Example.java .

public class This_Example {

// Instance variable num
int num = 10;

This_Example() {
System.out.println("This is an example program on keyword this");
}

This_Example(int num) {
// Invoking the default constructor
this();

// Assigning the local variable num to the instance variable num

this.num = num;
}

public void greet() {

System.out.println("Hi Welcome to Tutorialspoint");
}

public void print() {

// Local variable num
int num = 20;

// Printing the local variable

System.out.println("value of local variable num is : "+num);

// Printing the instance variable

System.out.println("value of instance variable num is : "+this.num);

// Invoking the greet method of a class

this.greet();
}

public static void main(String[] args) {

// Instantiating the class
This_Example obj1 = new This_Example();

// Invoking the print method

obj1.print();

// Passing a new value to the num variable through parametrized constructor

This_Example obj2 = new This_Example(30);
 // Invoking the print method again
obj2.print();
}
}

Cela produira le résultat suivant -

Production
This is an example program on keyword this
value of local variable num is : 20
value of instance variable num is : 10
Hi Welcome to Tutorialspoint
This is an example program on keyword this
value of local variable num is : 20
value of instance variable num is : 30
Hi Welcome to Tutorialspoint

La méthode finalize( )
Il est possible de définir une méthode qui sera appelée juste avant la destruction
finale d'un objet par le ramasse-miettes. Cette méthode s'appelle finalize( ) et peut
être utilisée pour s'assurer qu'un objet se termine proprement.
Par exemple, vous pouvez utiliser finalize( ) pour vous assurer qu'un fichier ouvert
appartenant à cet objet est fermé.
Pour ajouter un finaliseur à une classe, il vous suffit de définir la méthode finalize(
). Le runtime Java appelle cette méthode chaque fois qu'il est sur le point de recycler
un objet de cette classe.
Dans la méthode finalize( ), vous spécifierez les actions qui doivent être effectuées
avant qu'un objet ne soit détruit.
La méthode finalize( ) a cette forme générale −
protected void finalize( ) {
// finalization code here
}
Ici, le mot clé protected est un spécificateur qui empêche l'accès à finalize( ) par du
code défini en dehors de sa classe.
Cela signifie que vous ne pouvez pas savoir quand ou même si finalize( ) sera
exécuté. Par exemple, si votre programme se termine avant le nettoyage de la
mémoire, finalize( ) ne s'exécutera pas.
 Java - Fichiers et E/S
Le package java.io contient presque toutes les classes dont vous pourriez avoir besoin
pour effectuer des entrées et des sorties (E/S) en Java. Tous ces flux représentent une
source d'entrée et une destination de sortie. Le flux du package java.io prend en
charge de nombreuses données telles que les primitives, les objets, les caractères
localisés, etc.

Flux
Un flux peut être défini comme une séquence de données. Il existe deux types de flux
-
• InPutStream - Le InputStream est utilisé pour lire des données à partir
d'une source.
• OutPutStream - Le OutputStream est utilisé pour écrire des données
vers une destination.

Java fournit une prise en charge solide mais flexible des E/S liées aux fichiers et aux
réseaux, mais ce didacticiel couvre des fonctionnalités très basiques liées aux flux et
aux E/S. Nous verrons les exemples les plus couramment utilisés un par un −

Flux d'octets
Les flux d'octets Java sont utilisés pour effectuer l'entrée et la sortie d'octets 8
bits. Bien qu'il existe de nombreuses classes liées aux flux d'octets, les classes les
plus fréquemment utilisées sont FileInputStream et FileOutputStream . Voici un
exemple qui utilise ces deux classes pour copier un fichier d'entrée dans un fichier de
sortie -
Exemple

import java.io.*;
public class CopyFile {

public static void main(String args[]) throws IOException {

FileInputStream in = null;
FileOutputStream out = null;

try {
in = new FileInputStream("input.txt");
out = new FileOutputStream("output.txt");

int c;
while ((c = in.read()) != -1) {
out.write(c);
}
}finally {
if (in != null) {
in.close();
}
if (out != null) {
out.close();
}
}
}
}

Prenons maintenant un fichier input.txt avec le contenu suivant -

This is test for copy file.
Dans une prochaine étape, compilez le programme ci-dessus et exécutez-le, ce qui
entraînera la création d'un fichier output.txt avec le même contenu que celui que nous
avons dans input.txt. Mettons donc le code ci-dessus dans le fichier CopyFile.java et
procédons comme suit -
$javac CopyFile.java
$java CopyFile
Flux de personnages
Les flux Java Byte sont utilisés pour effectuer l'entrée et la sortie d'octets 8 bits,
tandis que les flux Java Character sont utilisés pour effectuer l'entrée et la sortie pour
l'unicode 16 bits. Bien qu'il existe de nombreuses classes liées aux flux de caractères,
les classes les plus fréquemment utilisées sont FileReader et FileWriter . Bien qu'en
interne FileReader utilise FileInputStream et FileWriter utilise FileOutputStream mais
ici la principale différence est que FileReader lit deux octets à la fois et FileWriter
écrit deux octets à la fois.
Nous pouvons réécrire l'exemple ci-dessus, qui utilise ces deux classes pour copier
un fichier d'entrée (ayant des caractères unicode) dans un fichier de sortie -
Exemple

import java.io.*;
public class CopyFile {

public static void main(String args[]) throws IOException {

FileReader in = null;
FileWriter out = null;

try {
in = new FileReader("input.txt");
out = new FileWriter("output.txt");

int c;
while ((c = in.read()) != -1) {
out.write(c);
}
}finally {
if (in != null) {
in.close();
}
if (out != null) {
out.close();
}
}
}
}

Prenons maintenant un fichier input.txt avec le contenu suivant -

This is test for copy file.
Dans une prochaine étape, compilez le programme ci-dessus et exécutez-le, ce qui
entraînera la création d'un fichier output.txt avec le même contenu que celui que nous
avons dans input.txt. Mettons donc le code ci-dessus dans le fichier CopyFile.java et
procédons comme suit -
$javac CopyFile.java
$java CopyFile
Flux standards
Tous les langages de programmation prennent en charge les E/S standard où le
programme de l'utilisateur peut prendre une entrée à partir d'un clavier, puis produire
une sortie sur l'écran de l'ordinateur. Si vous connaissez les langages de
programmation C ou C++, vous devez connaître trois dispositifs standard STDIN,
STDOUT et STDERR. De même, Java fournit les trois flux standard suivants -
• Entrée standard - Ceci est utilisé pour alimenter les données au
programme de l'utilisateur et généralement un clavier est utilisé comme
flux d'entrée standard et représenté comme System.in .
 • Sortie standard - Ceci est utilisé pour sortir les données produites par
le programme de l'utilisateur et généralement un écran d'ordinateur est
utilisé pour le flux de sortie standard et représenté comme System.out .
• Erreur standard - Ceci est utilisé pour sortir les données d'erreur
produites par le programme de l'utilisateur et généralement un écran
d'ordinateur est utilisé pour le flux d'erreur standard et représenté
comme System.err .
Voici un programme simple, qui crée InputStreamReader pour lire le flux d'entrée
standard jusqu'à ce que l'utilisateur tape un "q" -
Exemple

import java.io.*;
public class ReadConsole {

public static void main(String args[]) throws IOException {

InputStreamReader cin = null;

try {
cin = new InputStreamReader(System.in);
System.out.println("Enter characters, 'q' to quit.");
char c;
do {
c = (char) cin.read();
System.out.print(c);
} while(c != 'q');
}finally {
if (cin != null) {
cin.close();
}
}
}
}

Conservons le code ci-dessus dans le fichier ReadConsole.java et essayons de le

compiler et de l'exécuter comme indiqué dans le programme suivant. Ce programme
continue à lire et à sortir le même caractère jusqu'à ce que nous appuyions sur 'q' -
$javac ReadConsole.java
$java ReadConsole
Enter characters, 'q' to quit.
1
1
e
e
q
q
Lecture et écriture de fichiers
Comme décrit précédemment, un flux peut être défini comme une séquence de
données. L' InputStream est utilisé pour lire des données à partir d'une source et
l' OutputStream est utilisé pour écrire des données vers une destination.
Voici une hiérarchie de classes pour gérer les flux d'entrée et de sortie.

Les deux flux importants sont FileInputStream et FileOutputStream , qui seront

abordés dans ce didacticiel.

FileInputStream
Ce flux est utilisé pour lire les données des fichiers. Les objets peuvent être créés à
l'aide du mot-clé new et plusieurs types de constructeurs sont disponibles.
Le constructeur suivant prend un nom de fichier sous forme de chaîne pour créer un
objet de flux d'entrée pour lire le fichier -
InputStream f = new FileInputStream("C:/java/hello");
Le constructeur suivant prend un objet de fichier pour créer un objet de flux d'entrée
pour lire le fichier. Nous créons d'abord un objet fichier en utilisant la méthode File ()
comme suit -
File f = new File("C:/java/hello");
InputStream f = new FileInputStream(f);
Une fois que vous avez l'objet InputStream en main, il existe une liste de méthodes
d'assistance qui peuvent être utilisées pour lire dans le flux ou pour effectuer d'autres
opérations sur le flux.

Sr.No. Méthode et description

1 public void close() throws IOException{}

Cette méthode ferme le flux de sortie du fichier. Libère toutes les
ressources système associées au fichier. Lance une exception
IOException.

2
protected void finalize() throws IOException {}
Cette méthode nettoie la connexion au fichier. Garantit que la
méthode close de ce flux de sortie de fichier est appelée lorsqu'il n'y
a plus de références à ce flux. Lance une exception IOException.

3
public int read(int r) throws IOException{}
Cette méthode lit l'octet de données spécifié à partir de
InputStream. Renvoie un int. Renvoie le prochain octet de données
et -1 sera renvoyé s'il s'agit de la fin du fichier.

4
public int read(byte[] r) throws IOException{}
Cette méthode lit r.length octets du flux d'entrée dans un
tableau. Renvoie le nombre total d'octets lus. S'il s'agit de la fin du
fichier, -1 sera renvoyé.

5
public int available () throws IOException {}
Donne le nombre d'octets pouvant être lus à partir de ce flux
d'entrée de fichier. Renvoie un int.

Il existe d'autres flux d'entrée importants disponibles, pour plus de détails, vous
pouvez vous référer aux liens suivants -
• ByteArrayInputStream
• DataInputStream
FileOutputStream
FileOutputStream est utilisé pour créer un fichier et y écrire des données. Le flux
créerait un fichier, s'il n'existe pas déjà, avant de l'ouvrir pour la sortie.
Voici deux constructeurs qui peuvent être utilisés pour créer un objet
FileOutputStream.
Le constructeur suivant prend un nom de fichier sous forme de chaîne pour créer un
objet de flux d'entrée pour écrire le fichier -
OutputStream f = new FileOutputStream("C:/java/hello")
Le constructeur suivant prend un objet fichier pour créer un objet flux de sortie pour
écrire le fichier. Tout d'abord, nous créons un objet fichier en utilisant la méthode File
() comme suit -
File f = new File("C:/java/hello");
OutputStream f = new FileOutputStream(f);
Une fois que vous avez l'objet OutputStream en main, il existe une liste de méthodes
d'assistance, qui peuvent être utilisées pour écrire dans le flux ou pour effectuer
d'autres opérations sur le flux.

Sr.No. Méthode et description

1
public void close() throws IOException{}
Cette méthode ferme le flux de sortie du fichier. Libère toutes les
ressources système associées au fichier. Lance une exception
IOException.

2
protected void finalize() throws IOException {}
Cette méthode nettoie la connexion au fichier. Garantit que la
méthode close de ce flux de sortie de fichier est appelée lorsqu'il n'y
a plus de références à ce flux. Lance une exception IOException.

3
public void write(int w) throws IOException{}
Cette méthode écrit l'octet spécifié dans le flux de sortie.

4
public void écrire (octet [] w)
Écrit w.length octets du tableau d'octets mentionné dans
OutputStream.
Il existe d'autres flux de sortie importants disponibles, pour plus de détails, vous
pouvez vous référer aux liens suivants -
• ByteArrayOutputStream
• DataOutputStream
Exemple
Voici l'exemple pour démontrer InputStream et OutputStream -

import java.io.*;
public class fileStreamTest {

public static void main(String args[]) {

try {
byte bWrite [] = {11,21,3,40,5};
OutputStream os = new FileOutputStream("test.txt");
for(int x = 0; x < bWrite.length ; x++) {
os.write( bWrite[x] ); // writes the bytes
}
os.close();

InputStream is = new FileInputStream("test.txt");

int size = is.available();

for(int i = 0; i < size; i++) {

System.out.print((char)is.read() + " ");
}
is.close();
} catch (IOException e) {
System.out.print("Exception");
}
}
}

Le code ci-dessus créerait un fichier test.txt et écrirait des nombres donnés au format
binaire. La même chose serait la sortie sur l'écran stdout.

Navigation dans les fichiers et E/S

Il existe plusieurs autres cours que nous suivrions pour connaître les bases de la
navigation dans les fichiers et des E / S.
• Classe de fichier
• Classe FileReaderFileReader Class
• Classe FileWriterFileWriter Class
Annuaires en Java
Un répertoire est un fichier qui peut contenir une liste d'autres fichiers et
répertoires. Vous utilisez l'objet File pour créer des répertoires, pour répertorier les
fichiers disponibles dans un répertoire. Pour plus de détails, consultez une liste de
toutes les méthodes que vous pouvez appeler sur l'objet File et celles qui sont liées
aux répertoires.

Création de répertoires
Il existe deux méthodes utiles de l'utilitaire File , qui peuvent être utilisées pour créer
des répertoires -
• La méthode mkdir( ) crée un répertoire, renvoyant true en cas de succès
et false en cas d'échec. Un échec indique que le chemin spécifié dans
l'objet File existe déjà ou que le répertoire ne peut pas être créé car le
chemin complet n'existe pas encore.
• La méthode mkdirs() crée à la fois un répertoire et tous les parents du
répertoire.
L'exemple suivant crée le répertoire "/tmp/user/java/bin" −
Exemple

import java.io.File;
public class CreateDir {

public static void main(String args[]) {

String dirname = "/tmp/user/java/bin";
File d = new File(dirname);

// Create directory now.

d.mkdirs();
}
}

Compilez et exécutez le code ci-dessus pour créer "/tmp/user/java/bin".

Remarque - Java prend automatiquement en charge les séparateurs de chemin sous
UNIX et Windows conformément aux conventions. Si vous utilisez une barre oblique
(/) sur une version Windows de Java, le chemin sera toujours résolu correctement.
Liste des répertoires
Vous pouvez utiliser la méthode list () fournie par l'objet File pour répertorier tous
les fichiers et répertoires disponibles dans un répertoire comme suit -
Exemple

import java.io.File;
public class ReadDir {

public static void main(String[] args) {

File file = null;
String[] paths;

try {
// create new file object
file = new File("/tmp");

// array of files and directory

paths = file.list();

// for each name in the path array

for(String path:paths) {
// prints filename and directory name
System.out.println(path);
}
} catch (Exception e) {
// if any error occurs
e.printStackTrace();
}
}
}

Cela produira le résultat suivant basé sur les répertoires et fichiers disponibles dans
votre répertoire /tmp -
Production
test1.txt
test2.txt
ReadDir.java
ReadDir.class