1 – La classe File Java

La classe File Java  permet de gérer les fichiers, les noms de chemins de fichiers et de répertoires de manière abstraite. Cette classe est utilisée pour la création de fichiers et de répertoires, la recherche de fichiers, la suppression de fichiers, etc. Nous verrons plus loin dans les  prochains tutoriels que de nombreuses méthodes sont associées à cette classe.

Dans ce tutoriel, nous verrons comment créer un fichier en Java à l’aide de  la classe File et la méthode  createNewFile(). Cette méthode crée un fichier vide, s’il n’existe pas à l’emplacement spécifié et renvoie true. Si le fichier est déjà présent, cette méthode renvoie false.

IOException : Si une erreur d’entrée / sortie survient lors de la création du fichier.
SecurityException : Si un gestionnaire de sécurité existe et que sa méthode SecurityManager.checkWrite (java.lang.String) refuse l’accès en écriture au fichier.

Pour faire simple, nous allons essayer de créer un  simple fichier texte sur le bureau. Pour ce faire :

1. On doit préalablement importer les bibliothèques File et IOException qui se trouvent dans le package java.io
2. On fait une instanciation sur la classe File pour créer un nouveau objet myFile du type file
3. On crée le fichier avec la méthode  createNewFile() ( myFile.createNewFile() )

2 – Création d’un fichier avec la classe File Java

Le code ci-dessous créerait un fichier txt nommé  newfile.txt dans le bureau de l’utilisateur acer. Vous pouvez modifier le chemin dans le code ci-dessous afin de créer le fichier dans un répertoire ou un lecteur différent.

import java.io.File;
import java.io.IOException;

public class NewFile
{
   public static void main( String[] args )
   {
	   try {
		     File myFile = new File("C:/Users/acer/Desktop/newFile.txt");
		     /* Si le fichier est créé, alors la méthode createNewFile() renverrait 
		      true et  si le fichier est déjà présent il retournerait faux */
		     
	             boolean varF = myFile.createNewFile();
		     if (varF){
		          System.out.println("Fichier crée avec succés");
		     }
		     else{
		          System.out.println("Le fichier existe déjà");
		     }
	    	} catch (IOException e) {
	    		System.out.println("Exception Occurred:");
		        e.printStackTrace();
		  }

   }
}

3 – Ecrire dans un fichier existant à l’aide de la classe  FileWriter

La classe FileWriter permet d’ouvrir un flux d’écriture sur un fichier via son constructeur  :

FileWriter( String nom_du_fichier, boolean append )

1. Si la valeur du boolean append est mis à false, le contenu du fichier sera écrasé par le nouveau contenu
2. Si la valeur du boolean append est mis à true, le nouveau contenu sera ajouté à l’ancien

Exemple

	try
	{
	    String filename= "C:/Users/acer/Desktop/newFile.txt";
	    FileWriter fw = new FileWriter(filename,true); 
		//la valeur true entraine l'ajout du nouveau contenu à l'ancien
	    fw.write("Voici le contenu qui va être ajouté au fichier ");//appends the string to the file
	    fw.close();
	}
	catch(IOException ioe)
	{
	    System.err.println("IOException: " + ioe.getMessage());
	}
}

4 – Supprimer un fichier existant avec la méthode delete()

Pour supprimer un fichier existant en Java, il suffit d’instancier la classe FileWriter et pointer vers le fichier, et appliquer ensuite la méthode delete() à l’objet :

String filename= "C:/Users/acer/Desktop/newFile.txt";
File myFile = new File(filename); 
myFile.delete();

Nous allons vous présenter un guide complet  étape par étape pour créer une connexion Java avec une base de donnée MySql en utilisant l’IDE Eclipse et le driver JBDC pour MySql.

1 – Créer un projet Eclipse

Un projet dans Eclipse est essentiellement un dossier contenant tout le code source et d’autres fichiers nécessaires.
construisez votre programme. Commençons par créer un projet pour votre programme.

1. Ouvrez Eclipse
2. Dans le menu Fichier, sélectionnez  New → Java Project

3. Donnez un nom à votre projet, par exemple DBDemo.
Vous pouvez utiliser les valeurs par défaut pour tous les autres paramètres. Notez le dossier du projet, vous devrez vous en souvenir plus tard.

Cliquez ensuite sur le bouton Finish, pour créer le projet. Vous devriez à ce moment là voir un projet Java vide qui ressemble à ceux-ci :

4 – Créer  un package et une classe Java

Choisissez depuis le menu  File  ->New ->package

et puis donnez un nom à votre package  demojdbc par exemple

Choisissez ensuite depuis le menu  File  ->New ->Class

Donnez ensuite un nom à la classe  DemoJdbc par exemple. Vous obtenez un projet de ce type :

2 – Téléchargement et installation du driver JDBC pour mysql

2.1 – Téléchargement du driver JDBC pour mysql

Pour pouvoir connecter Java avec mysql, il nécessaire, télécharger et installer mysql connector for Java. Ce dernier est téléchargeable depuis l’adesse:  https://dev.mysql.com/downloads/file/?id=480091

Cette page, vous invite à créer un compte et à vous connecter. Mais vous pouvez surpasser cette étape en cliquent sur le lien en bas :

No thanks, just start my download

Après avoir télécharger l’archive, décompressez la et vous allez trouver à l’intérieur un fichier jar nommé : mysql-connector-java-5.1.47-bin.jar :

Sélectionnez votre projet sur Eclipse, et cliquez sur  le menu File  ->New -> Folder, pour créez un nouveau dossier, donnez le un nom lib  par exemple :

Maintenant à l’aide de la sourie, faite un click droit sur le dossier lib et pointez sur le menu import:

Ensuite depuis le menu General, choisissez le sous menu File System:

Continuez ensuite votre navigation jusqu’à ce que vous trouviez le fichier  mysql-connector-java-5.1.47-bin.jar  , séléctionnez le et cliquez sur le bouton Finish:

Le fichier est maintenant visible sur l’explorateur de fichier d’Eclipse :

Veuillez ensuite informer Eclipse du fichier  : mysql-connector-java-5.1.47-bin.jar, afin de le prendre en compte :

A l’aide du bouton droit de la sourie sur le dossier lib de votre projet Eclipse, cliquez sur Properties  et choisissez ensuite le menu Java Build Path:

Sélectionnez ensuite l’archive jar qui se trouve dans le dossier  lib du projet Eclipse :

Si les étapes sont correctement exécutés vous devriez voir l’archive jar dans Referenced Librairies:

3 – Connexion de Java avec Mysql en utilisant le driver JDBC

3.1 – Lecture et affichage des données

Afin de pouvoir créer un test de connexion  de Java avec MySql, il va falloir installer un serveur MySql. Plusieurs choix s’offrent à vous WampServer , xampp, EasyPHP…Nous vous recommandons pour cela d’utiliser WampServer.

Voici un  tutoriel vidéo qui vous explique comment utiliser wampserver. Commencez par lancer votre serveur  et  créez ensuite une base de donnée, nommez la school par exemple et au sein de laquelle créer une table MySql comportant les champs :  id,  nom, email, age… nommez la students par exemple :

Maintenant, tout est près, vous pouvez  donc commencer à communique le langage Java avec les bases de données MySql. Pour cela  veuillez suivre les étapes suivantes :

1 – Charger le driver mysql 

Class.forName("com.mysql.jdbc.Driver");

2 – Créer un objet connection en utilisant la classe Connection:

Connection con=DriverManager.getConnection("jdbc:mysql://localhost/school","root","");

3 – Créer un  état de connexion 

Statement stm=con.createStatement();

4 – Créer et exécuter une requete  sql  en utilisant la classe  ResultSet 

ResultSet res=stm.executeQuery("select * from students");

5 – parcourir les données de la table res    

Les données sont maintenant récupérées sur l’objet res pour accéder à la valeur d’un champ on utilise les méthodes getInt(numéro de la colonne), getDouble(numéro de la colonne), getString( numéro de la colonne)… selon le type du champ de la table ( int, double, String…).

Exemple pour la 2ème colonne qui contient les noms du type String on utilise la syntaxe :

res.getString(2);

Et afin de parcourir les données successivement une après l’autre du début de la sélection jusqu’à la fin de la sélection, on utilise la boucle while :

while (res.next()){ 
	System.out.println("id :"+res.getInt(1)+"   nom : "+res.getString(2) 
//Cet exemple affiche les données de la 1ère colonne et les données de la 2ème colonne
}

6 – Fermer la connection

con.close(); 

Finalement pour que le code fonctionne correctement sans aucun problème, il doit être encadré dans un try-catch:

Exemple avec code complet

import java.sql.*;
public class DemoJdbc {
	   public  static  void main (String[] args) {
		    try{
		        // 1 - charger le driver mysql
		        Class.forName("com.mysql.jdbc.Driver");
		        // 2 - créer la connection
		        Connection con=DriverManager.getConnection("jdbc:mysql://localhost/school","root","");
		        // 3 - créer un état de connexion
		        Statement stm=con.createStatement();
		        // 4 - Créer et exécuter une requette
		        ResultSet res=stm.executeQuery("select * from students");
		        // 5 - parcour les données de la table res
		       while (res.next()){
		            System.out.println("id :"+res.getInt(1)+"   nom : "+res.getString(2) +"     Email : "+ res.getString(3));
		            System.out.println("-----------------------------------------------");
		        }  
		    //  6 - Fermer la connection
		      con.close();
		    // 7..traitement des exeption
		        }catch (Exception e) {
		            System.out.println("ERROR :"+e.getMessage());
		        }

		        }

}

Ce qui affiche après exécution :

id :1 nom : David Email : david@gmail.com
——————————————————
id :2 nom : Jessica Email : Jessica@gmail.com
——————————————————
id :3 nom : Robert Email : robert@gmail.com
——————————————————
id :4 nom : Alberto Email : Albert@gmail.com
——————————————————
id :5 nom : Paul Email : Paul@gmail.com
——————————————————
id :6 nom : Hilbert Email : Hilbert@gmail.com
——————————————————
id :7 nom : Catherine Email : catherine@gmail.com
——————————————————
id :8 nom : Jonathan Email : Jonathan@gmail.com
——————————————————
id :9 nom : Orlando Email : orlando@gmail.com
——————————————————
id :10 nom : Tobias Email : tobias@gmail.com
——————————————————
id :11 nom : Martin Email : martin@gmail.com
——————————————————
id :12 nom : Bernard Email : bernard@gmail.com
——————————————————

3.2 – Insertion des donnée

Pour insérer des données mysql avec Java, on procède de la même manière que précédemment avec une toute petite modification, oon remplace juste le code de sélection de la table par une requête d’insertion des données:

String query = "INSERT INTO students (`name` , `email`) " + "VALUES ( 'Robert', 'robert@gmail.com')";
	   stm.executeUpdate(query);

Code final

import java.sql.*;
public class AddStudents {

	public static void main(String[] args) {
		try{
	        // 1 - charger le driver mysql
	        Class.forName("com.mysql.jdbc.Driver");
	        // 2 - créer la connection
	        //:3306/Peoples?autoReconnect=true&useSSL=false
	        Connection con=DriverManager.getConnection("jdbc:mysql://localhost/mydatabase?&useSSL=false","root","root");
	        // 3 - créer un état de connexion
	        Statement stm=con.createStatement();
	        // 4 - Créer et exécuter une requette
	        String query = "INSERT INTO students (`name` , `email`) " + "VALUES ( 'Robert', 'robert@gmail.com')";
	        stm.executeUpdate(query);
	        // 5 - parcourir les données de la table 
	       /* 
	       while (res.next()){
	            System.out.println("id :"+res.getInt(1)+"   nom : "+res.getString(2) +"     Email : "+ res.getString(3));
	            System.out.println("-----------------------------------------------");
	        } 
	        */ 
	    //  6 - Fermer la connection
	      con.close();
	    // 7..traitement des exeption
	        }catch (Exception e) {
	            System.out.println("ERROR :"+e.getMessage());
	        }

	}

}

Le plugin Eclipse WindowBuilder est un concepteur Java GUI visuel, puissant et facile à utiliser permettant la création d’applications GUI Java sans vous casser la tête à écrire du code pour afficher des objets graphiques  simples comme fenêtres, bouton de commandes, champs de textes… Avec WindowBuilder, vous pouvez créer des fenêtres compliquées en quelques minutes, il suffit d’utiliser le concepteur visuel et le code Java sera automatiquement  généré pour vous. Vous pouvez facilement ajouter des contrôles à l’aide de glisser-déposer,  gérer les événements de vos contrôles, modifier diverses propriétés des contrôles à l’aide d’un éditeur de propriétés et bien plus encore. Le code généré ne nécessite aucune bibliothèque personnalisée supplémentaire pour compiler et exécuter: l’ensemble du code généré peut être utilisé sans installer WindowBuilder.  .

• L’éditeur est doté des principaux composants interface utilisateur (user interface ) suivants:
  •    Design View – la zone de présentation visuelle principale.
  •    Source View- code d’écriture et analyse du code généré
  •    Structure View- composée de l’arbre de composant et du volet Propriété.
  – Component Tree- montre la relation hiérarchique entre tous les composants.
  – Property Pane – affiche les propriétés et les événements des composants sélectionnés.
  •    Palette – permet un accès rapide aux composants spécifiques à une trousse d’outils.
  •     ToolBar – permet d’accéder aux commandes couramment utilisées.
  •     Context Menu – permet d’accéder aux commandes couramment utilisées.

2 – Installation de WindowBuilder

1. Copiez le lien approprié pour votre version d’Eclipse à partir de la colonne Site de mise à jour sur la page de téléchargement:
2. Depuis le menu Help d’Eclipse, choisissez  Help > Install new Software…
   .
   .
3. Dans la fenêtre qui apparait cliquez sur le bouton Add
   .
   
   .
4. Dans la boîte de dialogue apparue, dans le champ Name, saisissez un nom descriptif (comme “WindowBuilder Pro”) et collez le lien correct (voir étape 1) dans le champ Emplacement.  Cliquez ensuite  sur le bouton OK: .
   .
5.  Sélectionnez toutes les cases à cocher qui vont apparaître, puis cliquez sur Suivant pour installez WindowBuilder :
   :
   
   .

3 – Comment utiliser WindowBuilder ?

Pour utiliser WindowBuilder :

• Tapez la combinaison de touche Ctrl + N et vous allez voir apparaitre la fenêtre suivante :

• Choisissez ensuite comme type de projet  :  WindowBuilder  -> Application Window

• Après avoir cliquez sur le bouton  Finish vous obtenez votre premier projet WindowBuilder :

• Cliquez maintenant sur l’onglet Design  pour afficher la fenêtre crée automatiquement par WindowBuilder , ainsi que  les autres outils graphiques WYSIWYG : Containers, Layouts, Compoasants Swing et Awt …

Etape 1 : Avant de créer un JComboBox, il va falloire préalablement savoir qu’il s’agit d’un composant Swing.
Pour cela, on doit impérativement créer une fenêtre dotée d’un JPanel en instanciant les classes JFrame et JPanel:

 JFrame f=new JFrame();   
JPanel pan=new JPanel();
f.setContentPane(pan);    
pan.setLayout(null);    
f.setSize(250,200);

Etape 2 : Création des éléments qui vont constituer la JComboBox. Les éléments qui vont constituer la JComboBox, peuvent être créer et organiser sur un tableau d’objets

Object[] elements = new Object[]{"élément1", "élément2", "élément3"};

Exemple :

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;


public class ComboBox1 {


public static void main(String[] args) { 

//- 1) --- création d'une fenêtre JFrame Java    
JFrame f=new JFrame();    
JPanel pan=new JPanel();    
f.setContentPane(pan);    
pan.setLayout(null);    
f.setSize(250,200);


//- 2) --- définir les élément de la liste 
JComboBoxObject[] elements = new Object[]{"Laptop HP", "Laptop Acer", "Laptop Azus"};    

//- 3) --- Création d'une nouvelle liste 
JComboBox JComboBox<Object> liste = new JComboBox(elements); 
liste.setBounds(10, 10, 120, 23); 
pan.add(liste);           
f.setVisible(true);

3 – Ajout d’actions à la liste JComboBox

Après avoir créer une liste JomboBox, on peut lui associer une action qui se declenche au moment de la séléction à l’aide de la méthode addActionListener(). L’action ne peut être ajouter que si la séléction est récupérée via la méthode getSelectedItem().

//- 4) --- Ajout d'une action à la séléction
liste.addActionListener(new ActionListener() { 
public void actionPerformed(ActionEvent e) { 
e.getSource(); 

//- 5) --- récupération de la séléction sur une variable du type String
String s=(String) liste.getSelectedItem(); 
System.out.println("Vous avez séléctionné : "+s); 
} 
});

On peut également afficher les résultats sur un JLabel :

Exemple complet :

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;

public class ComboBox2 {

	public static void main(String[] args) {
		
//- 1) --- define new Window JFrame
		   JFrame f=new JFrame();
		   JPanel pan=new JPanel();
		   f.setContentPane(pan);
		   pan.setLayout(null);
		   f.setSize(400,300);

//- 2) --- Création des éléments de la JComboBox Java
Object[] elements = new Object[]{"Laptop HP", "Laptop Acer", "Laptop Azus"};

//- 3) --- Création d'une nouvelle liste JComboBox
	JComboBox<String> liste = new JComboBox(elements);
	liste.setBounds(10, 10, 120, 23);
		pan.add(liste);
		
//- 4) --- Création d'un  JLabel pour afficher les résultats de la séléction
		  JLabel label=new JLabel("View results here !");
		  pan.add(label);
		  label.setBounds(10,30,250,50);
		  
//- 5) --- appliquer une action listener à la liste  JComboBox
		liste.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				e.getSource();
				String s=(String) liste.getSelectedItem();
				label.setText("Vous avez séléctionné : "+s);
				}
		});
		 f.setVisible(true);

	}

}

Ce qui affiche après exécution :

Afin d’organiser les menus, Java est doté d’une barre susceptible d’être placée en haut de la fenêtre, permettant d’accueillir et organiser les menus Java. Pour cela le langage Java utilise une classe nommée JMenuBar est utilisée pour afficher la barre des menus dans la fenêtre JFrame.
Pour créer une barre de menu, il suffit de créer une fenêtre dotée d’un panneau ( JPanel), d’instancier la classe JMenuBar, et d’ajouter ensuite la barre de menu au JPanel.

a) Création d’une fenêtre dotée d’un JPanel

JFrame fen=new JFrame("Exemple de fenêtre avec menu"); 
JPanel panel=new JPanel(); 
panel.setLayout(null); 
fen.setSize(500, 400); 
fen.setContentPane(panel);

b. Création de la barre des menus avec la classe JMenuBar

//création de la barre des menus
JMenuBar myMenuBar=new JMenuBar();
//Ajout de la barre de menus au JPanel
panel.add(myMenuBar)

2- La classe JMenu

La classe JMenu permet via l’instanciation, de créer un menu. Nous allons à titre d’exemple l’utiliser pour créer un menu Fichier :

//Création du menu Fichier
JMenu menuFichier = new JMenu("Fichier");
//Ajout du menu à la barre des menus 
myMenuBar.add(menuFichier);

Code Complet

import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JPanel;

public class MyJMenu {

	public static void main(String[] args) {
		
			//création d'une fenêtre JFrame
			JFrame fen=new JFrame("Exemple de fenêtre avec menu");
			JPanel panel=new JPanel();
			//création d'un panneau (JPanel)
			panel.setLayout(null);
			fen.setSize(500, 400);
			fen.setContentPane(panel);
			
			//création de la barre des menus
			JMenuBar myMenuBar=new JMenuBar();

			//Ajout de la barre de menus au JPanel
			panel.add(myMenuBar);
			
			//Positionnement de la barre des menus avec la m"thode setBounds()
			myMenuBar.setBounds(0, 0, 500, 30);
			//Création du menu Fichier
			JMenu menuFichier = new JMenu("Fichier");

			//Ajout du menu à la barre des menus
			myMenuBar.add(menuFichier);
			fen.setVisible(true);
		}
	}

Voici un aperçu après exécution du code sur Eclipse

3 – Création des sous menus avec la classe JMenuItem

Pour créer un sous menu et l’ajouter à menu principal, il suffit d’instancier la classe JMenuItem et appliquer la méthode add(). La classe JMenuItem premet de créer des sous menus, ces sous menus peuvent être ajoutés au menu principal grâce à la méthode add(). Nous allons traiter un exemple simple qui permet d’insérer le menu “Nouveau” au menu principal “Fichier” :

//Ajout d'un sous menu "Nouveau"                      
JMenuItem menuNouveau = new JMenuItem("Nouveau");
//Ajout du sous menu "Nouveau" au menu principal Fichier                        
menuFichier.add(menuNouveau);

On peut également via la même méthode, ajouter d’autres sous menus : “Ouvrir”  “Enregistrer”  “Imprimer”  “Quitter” 

Exemple

//Création des sous menus                     
			JMenuItem menuNouveau = new JMenuItem("Nouveau"); 
			JMenuItem menuOuvrir = new JMenuItem("Ouvrir"); 
			JMenuItem menuEnregistrer = new JMenuItem("Enregistrer");
			JMenuItem menuImprimer = new JMenuItem("Imprimer"); 
			JMenuItem menuQuitter = new JMenuItem("Quitter"); 
			
			//Ajout des sous menus au menu principal Fichier 
			menuFichier.add(menuNouveau);
			menuFichier.add(menuOuvrir);
			menuFichier.add(menuEnregistrer);
			menuFichier.add(menuImprimer);
			menuFichier.add(menuQuitter);

Voici un aperçu de la fenêtre obtenue après exécution du code sur Eclipse

4 – Ajouter une action à un sous menu

Dans le paragraphe précédent, vous avez apris à créer des menus et des sous menus, et rien d’autre ! Mais quand vous cliquez  sur l’un de ces sous menus, il doit se produire une action ou un évenement : exemple nous allons voir comment associer l’action qui permet de fermer la fenêtre au sous menu “Quitter”.  Por cela nous allons utiliser la même méthode   addActionListener( )  que nous avons appliqué aux boutons de comandes, et au sein de cette dernière, nous devons appliquer la méthode dispose( )  pour fermer la fenêtre :

menuQuitter.addActionListener(new ActionListener() {
				public void actionPerformed(ActionEvent e) {
					fen.dispose();
				}
			});

1 – Déclaration de classe JTextArea via l’héritage de JTextComponent

public class JTextArea extends JTextComponent

2 – Constructeur de classe & description

JTextArea ()
Construit une nouvelle TextArea.
JTextArea (Document doc)
Construit un nouveau JTextArea avec le modèle de document donné, et par défaut pour tous les autres arguments (null, 0, 0).
JTextArea (Document , String  texte, lignes int, colonnes int)
Construit un nouvel JTextArea avec le nombre spécifié de lignes et de colonnes, et le modèle donné.
JTextArea (int rows, int columns)
Construit une nouvelle TextArea vide avec le nombre de lignes et de colonnes spécifié.
JTextArea (String texte)
Construit une nouvelle TextArea avec le texte spécifié affiché.
JTextArea (String texte , lignes int, colonnes int)
Construit une nouvelle TextArea avec le texte et le nombre de lignes et de colonnes spécifiés.

3 – Méthodes de classe & description

void append (String str)
Ajoute le texte donné à la fin du document.
protected Document createDefaultModel ()
Crée l’implémentation par défaut du modèle à utiliser lors de la construction si aucune n’est explicitement donnée.
AccessibleContext getAccessibleContext ()
Obtient le AccessibleContext associé à cette JTextArea.
int getColumns ()
Renvoie le nombre de colonnes dans TextArea.
protected int getColumnWidth ()
Obtient la largeur de colonne.
int getLineCount ()
Détermine le nombre de lignes contenues dans la zone.
int getLineEndOffset (ligne int)
Détermine le décalage de la fin de la ligne donnée.
int getLineOfOffset (décalage int)
Traduit un décalage dans le texte des composants en un numéro de ligne.
int getLineStartOffset (ligne int)
Détermine le décalage du début de la ligne donnée.
boolean getLineWrap ()
Obtient la politique de retour à la ligne de la zone de texte.
Dimension getPreferredScrollableViewportSize ()
Renvoie la taille préférée de la fenêtre si ce composant est incorporé dans un JScrollPane.
Dimension getPreferredSize ()
Renvoie la taille préférée de TextArea.
protected int getRowHeight ()
Définit la signification de la hauteur d’une ligne.
int getRows ()
Renvoie le nombre de lignes dans TextArea.
boolean getScrollableTracksViewportWidth()
Renvoie true si une fenêtre doit toujours forcer la largeur de ce défilement pour correspondre à la largeur de la fenêtre.
int getScrollableUnitIncrement (Rectangle visibleRect, orientation int, int direction)
Les composants qui affichent des lignes logiques ou des colonnes doivent calculer l’incrément de défilement qui va complètement exposer une nouvelle ligne ou une colonne, en fonction de la valeur de l’orientation.
int getTabSize ()
Obtient le nombre de caractères utilisés pour développer les onglets.
String getUIClassID ()
Renvoie l’ID de la classe pour l’interface utilisateur.
boolean getWrapStyleWord ()
Obtient le style de retour utilisé si la zone de texte est en train d’encapsuler des lignes.
void Insert(String str, int pos)
Insère le texte spécifié à la position spécifiée.
protected String paramString ()
Renvoie une représentation sous forme de chaîne de cette JTextArea.
void replaceRange (Chaîne str, int début, int fin)
Remplace le texte de la position de début à la fin indiquée par le nouveau texte spécifié.
void setColumns (colonnes int)
Définit le nombre de colonnes pour ce TextArea.
void setFont (Police f)
Définit la police actuelle.
void setLineWrap (enveloppe booléenne)
Définit la politique de retour à la ligne de la zone de texte.
void setRows (int rangées)
Définit le nombre de lignes pour cette TextArea.
void setTabSize (taille int)
Définit le nombre de caractères pour développer les onglets.
void setWrapStyleWord (mot booléen)
Définit le style d’habillage utilisé, si la zone de texte est en train d’encapsuler des lignes.

Java Swing constitue l’une des plus récentes bibliothèque graphique et la plus utilisée pour le langage Java, Java Swing  fait partie du package Java Foundation Classes (JFC) qui elle même fait partie de J2SE.

2 – Première Fenêtre avec Java Swing

Dans ce tutoriel nous allons montrer comment créer une fenêtre avec la classe JFrame qui se trouve dans la bibliothèque  Javax.Swing.

Pour ce faire nous devons préalablement importer la bibliothèque javax.swing.JFrame; et faire ensuite l’instanciation sur la classe JFrame pour créer une fenêtre.

import javax.swing.JFrame;
public class maFenetre {
	
  public static void main(String[] args) {
		JFrame f=new JFrame();
		}
}

Ce qui n’affiche rien après exécution bien sûr, puisqu’on a pas invoquer la méthode setVisible( )  qui permet de visualiser la fenêtre. On peut donc améliorer le code en ajoutant cette dernière et celle qui définit les dimensions de la façon suivante :

import javax.swing.JFrame;
public class maFenetre {
	
  public static void main(String[] args) {
		JFrame f=new JFrame();
	    f.setVisible(true);
	    f.setTitle("Une Fenetre tout simplement");
	    f.setSize(400,200);
		}
}

Ce qui affiche une fenêtre de taille 400 x 200 :

Afin de pouvoir améliorer la classe JFrame il vaut mieux créer une sous classe via l’instruction extends !

import javax.swing.JFrame;
public class maFenetre extends JFrame{
	//création du constructeur
  public maFenetre(){
//Titre de la fenêtre
this.setTitle("Ma propre fenêtre");
  }
}

Maintenant pour créer et afficher la fenêtre nous devons :

1. Créer une méthode afficher( ) permettant d’afficher la fenêtre
2. Créer une méthode main( ) pour instancier la classe maFenêtre et afficher l’objet fenêtre

import javax.swing.JFrame;
public class maFenetre extends JFrame{
	//création du constructeur
  public maFenetre(){
this.setTitle("Ma propre fenêtre");
  }
  //création de la fonction d'affichage
  public void afficher(){
	  this.setVisible(true);
  }
  public static void main(String[] args) {
		maFenetre f=new maFenetre();
	    f.afficher();
		}
}

En exécutant ce code vous obtenez une petite fenêtre de dimensions nulles, par ce qu’on a pas préciser ses dimensions

Nous pouvons maintenant améliorer le code en ajoutant au constructeur, les dimensions de la fenêtre :

this.setSize(largeur en pixels , hauteur en pixel);

Exemple

import javax.swing.JFrame;
public class maFenetre extends JFrame{
	//création du constructeur
  public maFenetre(){
// Titre de la fenêtre	  
this.setTitle("Ma propre fenêtre");
// dimensions de la fenêtre :
this.setSize(300, 200);
  }
  //création de la fonction d'affichage
  public void afficher(){
	  this.setVisible(true);
  }
  public static void main(String[] args) {
		maFenetre f=new maFenetre();
	    f.afficher();
		}
}

Ce qui affiche après exécution, une fenêtre de taille 300 x 200

3 – Les conteneurs Java Swing ( Swing Containers )

Les composants Swing dans lesquels sont incorporés les composants de la GUI comme par exemple : JFrame, JDialog, JPanel, JScrollPane…sont appelé les conteneurs Swing ( Swing containers en anglais)

4 – Les composants  Java Swing

Les composants de la bibliothèque Swing presque identiques à ceux de Awt :

• JButton
• JLabel
• JTextArea
• JTextField
• JRadioButton
• JCheckBox
• JPasswordField
• JComboBox
• JList
• JScrollBar

5 – Ajout de composants Swing à la fenêtre

5 – 1 – Ajout d’un bouton

Avant d’ajouter un bouton à une fenêtre il faut préalablement créer un panneau ( Panel ) en faisant une instanciation sur la classe JPanel  et d’associer le contenu de ce panel à la fenêtre via l’instruction :

fenêtre.setContentPane(panel);

Voici le code :

JFrame f=new JFrame("Ma Fenêtre");
f.setSize(500, 400);
JPanel pan=new JPanel();
f.setContentPane(pan);

Explication : dans ce code on créer une fenêtre nommée f contenant un  panel nommé pan

A e moment là il est temps de créer un bouton à l’aide d’une instanciation sur la classe JButton :

JButton b=new JButton("Voici un Bouton");

Le bouton ne sera pas visible à ce moment là ! Il va falloir l’ajouter à la fenêtre f l’aide de la méthode :

f.getContentPane().add(b);

Voici le code final :

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
public class AppGaphique {
	public static void main(String[] args) {
	JFrame f=new JFrame("Ma Fenêtre");
	f.setSize(500, 400);
	JPanel pan=new JPanel();
	f.setContentPane(pan);
	//ajout de bouton
	JButton b=new JButton("Voici un Bouton");
	f.getContentPane().add(b);
	f.setVisible(true);
	} }

Ce qui affiche après exécution :

Remarque

On ajoute les autres composants Label, TextField… de la même façon en faisant une instanciation sur les classes JLabel, JTextField…

6 – Les événements Java Swing

Exemple avec ActionListener appliquer à JButton

monBouton.addActionListener(new ActionListener(){  
public void actionPerformed(ActionEvent e){  
   [ensemble d'actions ici ]  
        }  
    });  

Exemple

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
public class AppGaphique {
	public static void main(String[] args) {
	JFrame f=new JFrame("Ma Fenêtre");
	f.setSize(500, 400);
	JPanel pan=new JPanel();
	f.setContentPane(pan);
	//ajout de bouton
	JButton b=new JButton("Voici un Bouton");
	f.getContentPane().add(b);
	JLabel l=new JLabel("");
	f.getContentPane().add(l);
	f.setVisible(true);
	b.addActionListener(new ActionListener(){  
		public void actionPerformed(ActionEvent e){  
		            l.setText("J'ai cliqué sur le bouton");  }  
		    });  
	} 
}

Ce qui affiche après exécution et après avoir cliqué sur le bouton :

5 – Le composant JTable

Dans cette partie, nous allons voir comment créer un tableau pour afficher des données tabulaires en utilisant la classe JTable au sein de  la bibliothèque Java swing. La classe JTable représente le composant Swing table. JTable offre une fonctionnalité riche pour gérer l’apparence et le comportement du composant table.  JTable étend directement JComponent et implémente plusieurs interfaces d’auditeurs de modèles telles que TableModelListener,  TableColumnModelListener,  ListSelectionListener … etc. JTable implémente également une interface défilable; par conséquent, le tableau est généralement placé dans un JScrollPane.

Chaque JTable comporte trois modèles :

• TableModel
• TableColumnModel
• ListSelectionModel.

TableModel  :  est utilisé pour spécifier comment les données de la table sont stockées et la récupération de ces données. Les données de JTable sont souvent en structure bidimensionnelle telle qu’un tableau à deux dimensions ou un vecteur de vecteurs. TableModel est également utilisé pour spécifier comment les données peuvent être modifiées dans la table.

TableColumnModel  : est utilisé pour gérer tout TableColumn en terme de sélection de colonne, d’ordre de colonne et de taille de marge.

ListSelectionModel : permet au tableau d’avoir un mode de sélection différent, tel qu’un sélecteur unique, un intervalle unique et plusieurs sélections d’intervalles.
Nous pouvons créer une table en utilisant ses constructeurs comme suit:

Exemple

Nous verrons ici un exemple d’utilisation de JTable pour afficher les achats de matériels informatiques :

• Nous commençons par spécifier l’en-tête de colonne dans le tableau des colonnes.
• Nous utilisons ensuite  des données de tableau bidimensionnel pour stocker des données.
• Nous créons ensuite une instance de JTable en transmettant les données du tableau et l’en-tête de colonne au constructeur.
• Enfin, nous plaçons la table JScrollPane et l’ajoutons au cadre principal.

package JTableTest;

import javax.swing.*;
import java.awt.*;

public class MainClass {
 
	    public static void main(String[] args) {
	        final JFrame frame = new JFrame("JTable Demo");
	        
        String[] columns = {"id", "Matérièl Informatiques ", "Quantité"};

            Object[][] data = {
        {1,"PC ","30"},
        {2,"Tabettes","45"},
        {3, "Imprimantes", "10"}
};          
	        
	        JTable table = new JTable(data, columns);
	        JScrollPane scrollPane = new JScrollPane(table);
	        JLabel lblHeading = new JLabel("Achat de matériels informatiques");
	        lblHeading.setFont(new Font("Arial",Font.TRUETYPE_FONT,20));
	        frame.getContentPane().setLayout(new BorderLayout());
	        frame.getContentPane().add(lblHeading,BorderLayout.PAGE_START);
	        frame.getContentPane().add(scrollPane,BorderLayout.CENTER);
	        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	        frame.setSize(450, 250);
	        frame.setVisible(true);
	    }
	}

En exécutant le code ci-dessus vous obtenez la fenêtre suivante :

1 – Qu’est ce qu’une interface en Java ?

Une interface du langage de programmation Java est un type abstrait utilisé pour spécifier un comportement que les classes doivent implémenter. Ils sont similaires aux protocoles. Les interfaces sont déclarées à l’aide du mot-clé interface et ne peuvent contenir que des déclarations de méthode et des déclarations de constante (variable declaratire déclarée à la fois statique et finale). Toutes les méthodes d’une interface ne contiennent pas d’implémentation (corps de méthodes) de toutes les versions antérieures à Java 11. À partir de Java 8, les méthodes par défaut et les méthodes statiques peuvent avoir une implémentation dans la définition d’interface.

Les interfaces ne peuvent pas être instanciées, mais sont plutôt implémentées. Une classe qui implémente une interface doit implémenter toutes les méthodes non définies par défaut décrites dans l’interface ou être une classe abstraite. Les références d’objet en Java peuvent être spécifiées comme étant d’un type d’interface; dans chaque cas, ils doivent être nuls ou être liés à un objet qui implémente l’interface.

L’un des avantages de l’utilisation des interfaces est qu’elles simulent un héritage multiple. Toutes les classes en Java doivent avoir exactement une classe de base, la seule exception étant java.lang.Object (la classe racine du système de types Java); l’héritage multiple de classes n’est pas autorisé. Cependant, une interface peut hériter de plusieurs interfaces et une classe peut implémenter plusieurs interfaces.

2 – Une interface est crée pour quelle raison ?

Pour bien comprendre l’utilité des interfaces en Java, prenons un exemple simple :

• On souhaite par exemple créer une classe Rectangle qui permet de générer un objet rectangle
• On souhaite aussi créer une classe triangle permettant de générer un objet triangle
• On souhaite créer une classe trapèze permettant de généer un objet trapèze
•    …………………….

Les objets rectangle, triangle et trapèze  possèdent tous des propriétés communes comme : surface, perimètre, nombre de cotés… Et on souhaite créer un moyen qui permet de gérer ce processus c.a.d un triangle doit obligatoirement posséder une méthode qui calcule le périmètre et une méthode qui calcul la surface, faute de quoi le développeur  rencontre un message d’erreur lui indiquant qu’il doit obligatoirement insérer les méthodes perimetre() et surface()

C’est à ce niveau là qu’une interface intervient ! On doit créer une et appelons la par exemple interface polygone qui contient l’ensemble des  méthodes communes aux formes géométriques cités ci-dessus :

3 – Comment créer et utiliser une interface

En pratique, la création et la declaration d’une interface est semblable à une classe, à la différence que l’on remplace le mot-clé class par interface.

public interface Polygone {
	public double périmètre();
	public int nombreCotes();
}

Les classes  rectangle, triangle et trapèze vont être maintenant declarées de la même façon comme celle de l’héritage, à l a différence de remplacer le mot clé extends par implement:

Class Rectagle

public class Rectangle implements Polygone {
public double Longueur;
public double largeur;
public Rectangle(double L,double l){
	this.Longueur=L;
	this.largeur=l;
}

	public double périmètre(){
		return 2*(this.Longueur+this.largeur);
	}
    public int nombreCotes(){
		return 4;
	}

	public void afficher(){
 System.out.println("La périmètre du rectangle est : "+ this.périmètre());
	}
	public static void main(String[] args) {
	Polygone R1=new Rectangle(7,4);
	Rectangle R2=new Rectangle(9,3);
	R1.afficher();
	R2.afficher();
	}
}

Class Triangle

public class Triangle implements Polygone{
	public double coté1;
	public double coté2;
	public double coté3;
	//création du constructeur
	public Triangle(double c1,double c2,double c3){
		this.coté1=c1;
		this.coté2=c2;
		this.coté3=c3;
	}
	
	public double périmètre(){
		return this.coté1+this.coté2+this.coté3;
	}
	public int nombreCotes(){
		return 3;
	}
	public void afficher(){
    System.out.println("La périmètre du triangle est : "+ this.périmètre());	
	}
	public static void main(String[] args) {
	Polygone T1=new Triangle(2,3,5);
	Triangle T2=new Triangle(4,4,5);
	T1.afficher();
	T2.afficher();

	}

}

1 – 1 Exemple d’une classe prédéfinie : classe String

Le but de la  programmation orienté objet est de facilité la programmation en créant des classes qui à travers auxquelles on crée un nouveau objet chaque fois qu’on a besoin à l’aide de ce qu’on appelle l’instanciation.

Exemple

String myString=new String(" salut ");  

Ici on crée un objet du type chaine de caractère nommé myString à l’aide du modèle String la méthode par laquelle on a crée l’objet : Objet monObjet=new Objet est appelé l’instanciation
Un objet est doté des propriétés et méthodes qui fournissent des informations sur l’objet.

Exemple :

myString.length() ; 

qui fournit ici la longueur (length en anglais ) de la chaine de caractères myString= “salut” qui est égale ici à 5.
Pour créer une classe en Java on utilise la syntaxe :

classe nom_classe{
//code de la classe  ici
}

2 – Les classes et les objets Java

2 – 1 Déclaration d’une classe Java

Pour bien faciliter l’apprentissage nous allons traiter un exemple simple d’une classe permettant de générer des objets voitures ayant tous la même marque et le même prix :

Exemple

class voiture{
String marque ;
double prix ;
}

2 – 2 Constructeur  sans paramètres ( constructeur par défaut )

Afin de pouvoir créer des objets pour une classe Java, il faut associer à cette dernière  une méthode (fonction)qui porte le même nom que la classe appelé  constructeur :

voiture(){
}

Nous pouvons aussi attribuer des valeurs aux variables marque et prix :

class voiture {
	String marque="Renault";
	double prix=20000;
voiture(){
}

Et maintenant pour créer un objet voiture il suffit de faire l’instanciation : par exemple si on veut créer un objet voiture nommé maVoiture  on utilise le code :

voiture maVoiture = new  voiture();

L’objet maVoiture qu’on vient de créer est une voiture de marque Renault et de prix 20000 ( Euro )

Et maintenant si on veut accéder à la marque de l’objet maVoiture et de la récupérer sur une variable String on utilise le code :

String marque = maVoiture.marque ;

Voici le code final de la classe voiture :

class voiture {
	String marque="Renault";
	double prix=20000;
    voiture(){
    }
	public static void main(String[] args) {
		voiture maVoiture=new voiture();
		System.out.println("La marque de maVoiture est : "+ maVoiture.marque);
		System.out.println("Le prix de maVoiture est : "+ maVoiture.prix + " Euro");
	}
}

Ce qui affiche à l’exécution :

La marque de maVoiture est : Renault
Le prix de maVoiture est : 20000.0 Euro

 2 – 3 Constructeur avec paramètres

On peut aussi donner la possibilité à l’utilisateur de choisir lui même la marque et le prix de la voiture en ajoutant  des paramètres au constructeur :

voiture ( String mq , double pr ) {
    	this.marque=mq ;
    	this.prix=pr ;
    }

Et maintenant l’utilisateur du modèle voiture est libre de choisir la marque qu’il souhaite avec le prix qui qui lui convient au moment de l’instanciation , par exemple s’il souhaite créer une voiture de marque Peugeot et de prix 25000 Euro il n’a qu’à instancier avec ces paramètres :

voiture saVoiture=new voiture( "Peugeot" , 25000 ) ;

Voici le code final de la classe :

class voiture {
	String marque;
	double prix;
    voiture(String mq,double pr){
    	this.marque=mq;
    	this.prix=pr;
    }
	public static void main(String[] args) {
		voiture saVoiture=new voiture("Peugeot",25000);
		System.out.println("La marque de  saVoiture est : "+ saVoiture.marque);
		System.out.println("Le prix de saVoiture est : "+ saVoiture.prix + " Euro");
	}
}

Ce qui affiche à l’exécution :

La marque de  saVoiture est : Peugeot
Le prix de saVoiture est : 25000.0 Euro

3 – Modificateurs d’accès

Vous auriez sûrement déjà remarqué les mots public, protected et private au début des déclarations des méthodes de classe. Ces mots-clés sont appelés les modificateurs d’accès dans la syntaxe du langage Java, et ils définissent la portée d’un constituant de la classe.

3 – 1 – Cas d’une classe

• Si une classe a une visibilité public (publique), la classe peut être appelée  depuis n’importe où dans le programme.
• Si une classe possède une visibilité du package, la classe ne peut être appelée que dans le package où la classe est définie.
• Si une classe a une visibilité private (privée) (elle ne peut se produire que si la classe est définie imbriquée dans une autre classe), la classe ne peut être consultée que dans la classe externe.

3 – 2 – Cas d’un attribut

•     Si une variable est définie dans une classe publique et qu’elle a une visibilité publique, la variable peut être appelée n’importe où dans l’application par la classe dans laquelle elle est définie.
• Si une variable a une visibilité protected (protégée) , la variable ne peut être appelée que dans les sous-classes et dans le même paquet dans la classe dans laquelle elle est définie.
• Si une variable a une visibilité du package , la variable ne peut être référencée que dans le même paquet dans la classe dans laquelle elle est définie.
• Si une variable a une visibilité private (privée), la variable ne peut être accessible que dans la classe dans laquelle elle est définie.

3 – 3 – Cas d’une méthode Java

•     Si une méthode est définie dans une classe publique et qu’elle a une visibilité publique, la méthode peut être appelée n’importe où dans l’application à travers la classe dans laquelle elle est définie.
• Si une méthode est déclarée protected  elle a une visibilité protégé, la méthode peut être appelée uniquement dans les sous-classes et dans le même paquetage à travers la classe dans laquelle elle est définie.
• Si une méthode est déclarée private elle a une visibilité privée, la méthode peut être appelée uniquement dans la classe dans laquelle elle est définie.

3 – 4 – Le modificateur abstract

Le modificateur abstract est utilisé devant les classes  Java pour définir les classes abstraites ( les classes abstraite sont des classes non instanciables et par suite non exécutables directement, elle ne peuvent être utiliser qu’en héritage )

3 – 5 – Le modificateur Final

• En Java le mot clé final s’il est ajouté devant un  attribut, il le rend non modifiable, il prend toujours la valeur par laquelle il est initialisé.
• Le mot clé final s’il est ajouté devant une méthode, il indique que cette dernière  ne peut pas être modifiée pendant l’héritage. Les méthodes static et private sont considérées automatiquement  final.
• Le mot clé final s’il est ajouté devant une classe, il indique que cette dernière ne peut pas avoir de classes filles.

3 – 6 – – Le modificateur Static

Pour un attribut ou une méthode  Java, le modificateur static indique, que la méthode ou l’attribut   peut être appelé sans faire une  instanciation sur  sa classe.

En Java, une instruction if est une instruction conditionnelle qui exécute un ensemble d’instructions selon une condition si elle est réalisée ou non.
Syntaxe:

Exemple

import java.util.Scanner;
public class si {

	public static void main(String[] args) {
		System.out.println("Veuillez saisir votre age !");
	Scanner age=new Scanner(System.in);
	int tonAge=age.nextInt();
	if ( tonAge < 18 ) {
System.out.println("vous êtes mineur"+" Ton age est : "+tonAge);
	}
	else{
		System.out.println("vous êtes Majeur"+" Ton age est : "+tonAge);	
	}
	age.close();
}
}

Ce qui affiche :

Vous êtes majeur si l’âge tapé est >=18
Vous êtes mineur si l’âge tapé est < 18

Remarque :

La commande else {  n’est pas obligatoire

2 – Boucle For Java

Il existe de nombreuses  situations qui vous oblige à exécuter un bloc d’instructions plusieurs fois dans vos applications. Les boucles peuvent exécuter un bloc de code un certain nombre de fois. La boucle for de Java vous sera  utile dans ce cas
Syntaxe:

 
for (début compteur ;  termination;     incrémentation du compteur) {
   Bloc d'instructons
}

Exemple :

for ( int i = 1 ; i<=10 ; i++){
System.out.println("bonjour !");
}

L’exemple ci dessus affiche 10 fois le message  bonjour !

3 – Boucle while Java

La  boucle while est une instruction  de contrôle qui permet d’exécuter le code à plusieurs reprises en fonction d’une condition booléenne donnée, chaque fois que la condition est réalisée l’instruction est exécutée.
Syntaxe:

while ( condition ) {

bloc d'instructions ...

}

Exemple

int i = 1 ;
while ( i<=10 ) {
System.out.println(" bonjour !");
i ++;
}

L’exemple ci dessus affiche 10 le message bonjour !  et s’arrête, puis qu’à chaque affichage du message i est incrémenté de +1 et à la 10 ème fois il prends la valeur 10 + 1 = 11 et donc la condition i <=10 n’est plus réalisée ce qui entraine l’arrêt de l’instruction :

System.out.println(" bonjour !") ;