Introduction

Le développement de projets informatiques répond à tout type de besoin. De la création d’un outil personnel automatisant une tâche quotidienne répétitive au développement de logiciels complexes utilisés par des centaines d’employés, l’environnement de développement intégré NetBeans peut être utilisé pour réaliser ces différents projets. Par conséquent, afin de sélectionner le projet le plus adapté au cahier des charges, il est nécessaire de découvrir les possibilités offertes par NetBeans.

Ce chapitre a pour objet de présenter les différents types de projets mis à disposition des développeurs, créer un projet Java simple, définir les bases de la programmation orientée objet à travers ce projet, présenter les vues de développement de NetBeans, développer une classe, rendre le projet exécutable, compiler le projet, l’exécuter, le documenter et proposer un exercice corrigé.

Les types de projets Java

Dans le monde professionnel, les projets Java sont régulièrement utilisés pour développer des applications de gestion web ou de bureau et pour réaliser des traitements manipulant un nombre important de données.

Le framework Java le plus récent régulièrement utilisé pour développer des applications de bureau est JavaFX . Sa mise en service a été réalisée pour remplacer les anciennes bibliothèques Swing et Abstract Window Toolkit (AWT). Les applications web actuelles sont fréquemment développées en deux parties distinctes : la partie interface utilisateur, en Angular, React ou Vue.js, et la partie serveur, en Java avec des micro-services Rest et les différentes bibliothèques Spring. Les traitements gérant un nombre conséquent de données sont ordinairement des projets Java utilisant la bibliothèque Springbatch.

NetBeans offre un choix important de projets ; dans un premier temps, leurs caractéristiques principales seront présentées.

Note sur les projets NetBeans

NetBeans permet de créer un très grand panel de projets et contrairement à d’autres IDE, NetBeans force le développeur à utiliser un standard pour sa gestion de configuration.

Parmi les standards disponibles en Java, les trois majeurs sont Ant, Maven et Gradle (dans leur ordre historique d’apparition). L’utilisation de l’un de ces gestionnaires de configuration est une bonne approche, cela rend le projet indépendant de l’IDE utilisé et facilite ainsi la reprise de code par des gens habitués à ces standards.

L’installation de l’IDE terminée, à partir de l’écran d’accueil de NetBeans, effectuez la manipulation suivant.

Cliquez sur le menu File - New Project : l’écran ci-dessous vous permet de sélectionner le type de projet Maven que vous souhaitez créer.

La première catégorie, Java with Maven, est composée de quinze types de projets différents. Maven est un outil open source d’Apache permettant de faciliter la gestion d’un projet. Il permet par exemple d’automatiser des tâches de compilation, de déploiement ou bien de gérer...

Création d’un projet Java simple avec Maven

La création d’un projet Java basique nécessite au préalable de suivre la manipulation décrite ci-après.

Maven est un standard polyvalent de gestion de configuration pour les projets Java. Son fonctionnement détaillé sera développé dans le chapitre Vers l’industrialisation du logiciel.

À partir de l’écran d’accueil, cliquez sur le menu File - New Project, sélectionnez le projet Java Application et cliquez sur le bouton Next.

Saisissez un nom de projet, par exemple myfirstproject.

Saisissez le chemin où sera déposé votre projet, par exemple C:\NetBeansProjects.

Saisissez l’identifiant de groupe, par exemple fr.eni.

Saisissez la version du projet, par exemple 1.0.0-SNAPSHOT pour une première version.

Cliquez sur le bouton Finish ; le projet créé est disponible dans l’onglet Projects de NetBeans.

Le projet généré se compose de plusieurs dossiers :

Le répertoire Source Packages est destiné à contenir les différentes classes Java de l’application.
Le répertoire Dependencies liste les dépendances ajoutées dans le pom.xml nécessaires au bon fonctionnement de l’application.
Le répertoire Java Dependencies contient le kit de développement...

Notions de programmation orientée objet

Cette section a pour but de définir les principes de la programmation orientée objet, c’est-à-dire définir une classe, présenter les concepts de classes et types et introduire la notion de package.

1. Définition d’une classe

Une classe est un ensemble d’attributs et de méthodes. Les attributs forment l’état de cette classe et les méthodes définissent ses comportements.

Une classe permet de regrouper des occurrences d’une population partageant de mêmes caractéristiques d’état et de comportement (donc d’attributs et de méthodes). Les instances sont des occurrences d’une classe, donnant des valeurs concrètes aux attributs définis par cette dernière. Il est possible de créer une instance à partir d’une classe grâce au mécanisme d’instanciation, autrement appelé construction (d’où la notion de constructeur définie dans la classe, et qui sera assez largement utilisée dans les exemples de ce livre). Voici un exemple possible pour bien comprendre la différence entre classe et instance : il est possible de percevoir la classe comme le plan de construction d’une voiture (les caractéristiques et le mode de fonctionnement) et les instances comme les occurrences de voiture ayant été conçues selon ce plan. Les occurrences possèdent toutes des traits qui les différencient les unes des autres (couleur, puissance moteur, année de fabrication), elles sont pourtant toutes régies par le même fonctionnement (équipement de base, dimensions, etc.) défini par la plan. Dans cet exemple, la classe est le plan et les occurrences des voitures produites selon ce plan sont les instances. Il y a donc une différence fondamentale entre les classes et les instances, et il faudra veiller à ne pas confondre les deux, sous peine de faire des erreurs dramatiques. Comme vu plus tard dans ce chapitre, les deux concepts, classes et instances, peuvent être manipulés par l’intermédiaire...

Présentation de l’interface de NetBeans

NetBeans permet, grâce à différents onglets, la visualisation simultanée du projet et de son arborescence, et du contenu d’une classe.

Les onglets Projects et Files, situés en haut à gauche de NetBeans présentent les différents répertoires du projet. L’onglet Projects regroupe les différents fichiers par packages alors que l’onglet Files présente les dossiers et fichiers de façon hiérarchique, c’est-à-dire comme ils sont enregistrés sur le poste de l’utilisateur.

L’onglet Navigator, situé en bas à gauche de l’IDE, liste les différents attributs et méthodes créés dans la classe ouverte dans NetBeans.

Un double clic sur un attribut ou sur une méthode de la liste de cet onglet positionne le curseur sur la première ligne de cet attribut ou méthode dans la classe Java. Ceci peut être très utile pour accéder à du code dans une classe contenant un nombre important d’éléments.

L’onglet Properties présente les propriétés techniques de la classe ouverte dans NetBeans, par exemple sa date de modification, sa taille et son emplacement sur le poste du développeur.
L’encadré situé en bas de l’interface contient :...

Création d’une classe Java avec NetBeans

Cette section a pour but de créer une première classe Java, d’en développer son contenu en créant un attribut, un accesseur et un mutateur, et une méthode.

1. Création d’une classe

Effectuez un clic droit sur le package fr.eni.myfirstproject et sélectionnez le menu New - Java Class.

Renseignez le nom de cette classe, ici HelloWorld.

Cette classe est créée physiquement sur la machine. Le champ Created File donne son chemin complet afin d’y accéder.

Cliquez sur le bouton Finish ; la classe est présente dans le package créé précédemment et s’ouvre automatiquement dans NetBeans.

À sa création, la classe ne contient que le package dans lequel elle a été créée, son nom et son état "public". Son état public signifie qu’elle est accessible à toutes les autres classes du projet.

Les attributs, accesseurs, mutateurs et méthodes sont développés entre les accolades de cette classe, formant ainsi son corps.

2. Création d’un attribut

L’attribut est une propriété d’une classe. Il est défini par un état, un type et un nom. Les états d’un attribut sont private, protected ou public.

L’état private signifie que l’attribut est visible seulement dans sa classe.
L’état protected signifie que l’attribut est accessible par tout le package et par les sous-classes dans le cadre de l’héritage. La notion d’héritage fera l’objet d’un chapitre détaillé plus loin dans ce livre.
L’état public signifie que l’attribut est accessible par tout le projet.

Les types de base en Java, dits primitifs car ils font partie du langage, sont au nombre de huit : quatre de type entier, deux de type flottant, un de type caractère et un de type booléen. Le tableau ci-dessous les récapitule, présente leur taille et leur intervalle de valeurs possibles.

Type de base	Type	Taille (en octets)	Valeurs possibles
byte	Entier	1	-128 à 127
short	Entier	2	-32 768 à 32 767
int	Entier	4	-231 à 231 - 1
long	Entier	8	-263 à 263 - 1
float	Flottant	4	1.4*10-45 à...

Définition d’un point d’entrée pour l’exécution de son programme

L’application produite par le projet se lance par l’exécution d’une méthode public static void main(String[] args).

Le développement ci-dessous décrit la création de cette méthode main ainsi que l’appel d’une méthode.

Créez une classe Main dans le package fr.eni.myfirstproject.

Créez la méthode main à l’aide du code suivant :

public static void main(String[] args){ 
   HelloWorld myObj = new HelloWorld(); 
   HelloWorld.afficheConsole(myObj.getChaine());   
}

La méthode afficheConsole est définie comme static, cela signifie que la méthode est chargée en mémoire et est par conséquent accessible sans instanciation de la classe HelloWorld. Contrairement à l’attribut chaine, qui est un attribut d’instance encapsulé et donc utilisable uniquement grâce à son accesseur.

Une fois la phase de développement réalisée, le projet doit être compilé avant son exécution.

Compilation d’un projet

Cette partie a pour objet de définir la notion de compilateur et de décrire l’action de compilation d’un projet avec NetBeans.

1. Définition du compilateur

Un compilateur est un programme traitant les instructions, écrites dans un langage de programmation donné, pour les traduire en langage machine, ou "code", utilisé par le processeur d’un ordinateur.

Dans la pratique, l’action de compilation est l’étape préalable et nécessaire à l’exécution du projet, permettant de vérifier la justesse et la cohérence du code écrit par le développeur.

2. Compilation d’un projet avec NetBeans

La compilation sous NetBeans s’effectue grâce à un clic droit sur le nom du projet et en sélectionnant le menu Build.

Faites un clic droit sur myfirstproject, et cliquez sur le menu Build.

Le résultat et le détail de la compilation sont affichés dans la console. Le code développé ne contenant aucune erreur, la compilation est un succès. L’archive Java de la version 1.0.0-SNAPSHOT a été construite dans le répertoire cible (target).

Une fois le projet compilé et l’archive Java créée, la phase d’exécution peut démarrer.

Exécution d’un projet

Cette section a pour but de présenter les étapes d’exécution puis de construction du binaire du programme en vue de sa mise à disposition.

1. Sélectionner le point d’entrée du programme

Lors de l’exécution d’un projet, la sélection de la classe principale contenant le point d’entrée main est nécessaire. La manipulation ci-dessous décrit comment réaliser cette action avec NetBeans.

Exécutez la classe Main avec le bouton Run Project ou en effectuant un clic droit sur la classe pour sélectionner le menu Run File.

Lors de la première exécution du projet, la fenêtre de sélection de la classe principale du projet apparaît. Dans ce cas, sélectionnez la classe Main, le radio bouton Remember permanently et cliquez sur Select Main Class. Cette sélection est modifiable dans les propriétés du projet.

Le projet se construit sans erreur et la console affiche bien la ligne Hello World ! L’exécution du premier projet Java avec NetBeans se déroule correctement.

La compilation du projet étant réalisée, sa construction en vue de la mise à disposition de l’application est maintenant réalisable.

2. Construire son projet avec NetBeans

Lorsque le développeur souhaite mettre à...

Documentation d’une application

L’utilisation de la Java documentation, couramment appelée Javadoc, donne la possibilité au développeur de documenter son code. Cette documentation lui permet de mieux comprendre son code, mais surtout permet aux différents développeurs qui maintiendront par la suite l’application de comprendre et prendre en main le code beaucoup plus rapidement.

L’utilisation de ce type de documentation est préférable à la présence de simples commentaires. En effet, cette documentation permet d’accéder à la description d’une méthode sans avoir à effectuer des recherches supplémentaires sur celle-ci, ce qui est par conséquent un gain de temps considérable lors de développements volumineux.

La Javadoc est en réalité l’ensemble des pages HMTL générées par l’outil, également appelé Javadoc, développé par la société Sun Microsystems. Cet outil est disponible par défaut dans le kit de développement Java.

La Javadoc liste au minimum l’ensemble des classes et leur contenu, attributs et méthodes, d’un projet Java. Des descriptions peuvent également être saisies afin de détailler chacun de ces éléments.

L’ajout d’informations détaillées sur des classes, méthodes ou variables s’effectue grâce à des tags spécifiques définis par Sun.

1. Tags Javadoc

Les tags mis à disposition par l’outil Javadoc sont les suivants.

Le tag @param est utilisé pour documenter les paramètres d’une méthode.

/** 
* Affiche une chaîne de caractères dans la console 
*  
* @param param1 : chaîne de caractères à afficher   
*/ 
public static void afficheConsole(String param1){ 
   System.out.println(param1); 
}

Le tag @return est utilisé pour documenter l’objet retourné par la méthode.

/** 
* Retourne l'attribut privé chaine 
*  
* @return une instance de l'attribut chaine  
*/ 
public String getChaine() { 
   return chaine; 
}

Les tags @throws ou @exception sont utilisés...

Exercice corrigé : Calcul géométrique

Le but de cet exercice est de développer un programme Java destiné à calculer le périmètre et l’aire d’un cercle et d’un carré. Les principales étapes de cette réalisation sont les suivantes :

Développer deux classes représentant un cercle et un carré.
Développer les méthodes calculant le périmètre et l’aire pour chaque forme.
Documenter ces méthodes à l’aide des balises Javadoc.
Développer une méthode principale affichant les résultats des calculs dans la console.

La première étape de cet exercice est par conséquent la création d’un projet Java. Pour ce correctif, un projet de type Maven est utilisé.

Pour ce faire, créez un projet de type Java Application situé dans la catégorie Java with Maven.

Créez une première classe Cercle.

La classe Java créée, il est important, avant de développer, de se poser la question : "Quelles sont les propriétés nécessaires au calcul de l’aire et du périmètre d’un cercle ?"

Les formules mathématiques nécessaires à ces calculs sont les suivantes :

Aire = PI * rayon²
Périmètre = 2 * PI * rayon

D’après ces formules, il est nécessaire de définir une constante PI et un attribut de type numérique qui représentera le rayon du cercle.

Une constante, en Java, est définie de la même manière qu’un attribut, mais en ajoutant les propriétés static et final.

static devant la variable (ou méthode) signifie qu’elle n’appartient pas à une instance de la classe, mais directement à cette classe. Cela signifie qu’une variable ou méthode peut être utilisée sans instanciation de la classe.

Le mot-clé final devant une variable signifie que celle-ci ne peut pas être modifiée après son initialisation.

Le développement de la classe Cercle est dans un premier temps le suivant :

package fr.eni.calculgeometrique; 
 
/** 
* Classe Cercle contenant deux méthodes nécessaires au calcul de  ...

Créer son premier projet avec NetBeans