Logs
Consultez les logs.
OK
Liste des données
Consultez la liste des données.
OK
Loading...
Formulaire
Saisissez vos données.
Enregistrer
Annuler
ReadyDev
Présentation
Admin
Le but de ce tutoriel est vous apprendre à programmer en Java.
Produit par Gérard KESSE.
Introduction
Java est un langage de programmation de haut niveau, basé sur des classes et orienté objet, conçu pour avoir le moins de dépendances d'implémentation possible. Il s'agit d'un langage de programmation à usage général destiné à permettre aux programmeurs d'écrire une fois, de s'exécuter n'importe où (WORA), ce qui signifie que le code Java compilé peut s'exécuter sur toutes les plates-formes prenant en charge Java sans qu'il soit nécessaire de recompiler. Les applications Java sont généralement compilées en bytecode qui peut s'exécuter sur n'importe quelle machine virtuelle Java (JVM) quel que soit l'architecture informatique sous-jacente. La syntaxe de Java est similaire à C et C++ , mais a moins de fonctionnalités de bas niveau que l'un ou l'autre. Le runtime Java fournit des fonctionnalités dynamiques (telles que la réflexion et la modification du code d'exécution) qui ne sont généralement pas disponibles dans les langages compilés traditionnels.
Programme principal
La méthode (main) est le point d'entrée d'un projet Java.
La classe contenant la méthode (main) est la classe principale d'un projet Java.
//===============================================
class GMain {
public static void main(String[] _args) {
GProcess lProcess = new GProcess();
lProcess.init();
lProcess.run(_args);
lProcess.getLogs().showLogsX();
lProcess.clean();
}
}
//===============================================Arguments en ligne de commande
La variable (_args) contient la liste des arguments passés en ligne de commande.
La propriété (length) permet récupérer le nombre d'arguments.
L'opérateur (_args[i]) permet de récupérer l'argument à la position (i).
//===============================================
public void run(String[] _args) {
String lModule = "";
if(_args.length > 0) lModule = _args[0];
if(lModule.equals("")) {
m_logs.addError("Le module est obligatoire.");
}
else if(lModule.equals("test")) {
runTest(_args);
}
else if(lModule.equals("server")) {
runServer(_args);
}
else {
m_logs.addError("Le module est inconnu.");
}
}
//===============================================Conditions
L'opérateur (if) permet de réaliser une condition (Si).
L'opérateur (lelse if) permet de réaliser une condition (Sinon Si).
L'opérateur (else) permet de réaliser une condition (Sinon).
//===============================================
public void run(String[] _args) {
String lModule = "";
if(_args.length > 0) lModule = _args[0];
if(lModule.equals("")) {
m_logs.addError("Le module est obligatoire.");
}
else if(lModule.equals("test")) {
runTest(_args);
}
else if(lModule.equals("server")) {
runServer(_args);
}
else {
m_logs.addError("Le module est inconnu.");
}
}
//===============================================Boucle For
L'opérateur (for) permet de réaliser une boucle (Pour Tout).
//===============================================
public void addLogs(GLog _obj) {
for(int i = 0; i < _obj.m_map.size(); i++) {
GLog lObj = _obj.m_map.get(i);
GLog lNew = new GLog();
lNew.setObj(lObj);
m_map.add(lNew);
}
}
//===============================================Boucle While
L'opérateur (while) permet de réaliser une boucle (Tant Que).
//===============================================
public void runServer() {
while(true) {
if(!m_continue) break;
GSocket lClient = new GSocket();
try {
lClient.m_socket = lServer.accept();
}
catch(Exception e) {
m_srvLogs.addError("La connexion au serveur a échoué.");
break;
}
GThread lThread = new GThread();
lThread.setObj(lClient);
lThread.start();
}
}
//===============================================Méthodes
Une méthode peut ne pas retourner un résultat.
//===============================================
public void addLogs(GLog _obj) {
for(int i = 0; i < _obj.m_map.size(); i++) {
GLog lObj = _obj.m_map.get(i);
GLog lNew = new GLog();
lNew.setObj(lObj);
m_map.add(lNew);
}
}
//===============================================Une méthode peut retourner un résultat.
//===============================================
public boolean hasErrors() {
for(int i = 0; i < m_map.size(); i++) {
GLog lObj = m_map.get(i);
if(lObj.m_type.equals("error")) return true;
}
return false;
}
//===============================================Surcharge de constructeurs
Java prend en charge la notion de surcharge de constructeurs.
//===============================================
public class GManager extends GObject {
//===============================================
protected String m_module = "";
protected String m_method = "";
//===============================================
public GManager() {
}
//===============================================
public GManager(String _module, String _method) {
m_module = _module;
m_method = _method;
}
//===============================================
}
//===============================================Ce qu'il faut savoir:
Les constructeurs doivent avoir des signatures différentes.
Surcharge de méthodes
Java prend en charge la notion de surcharge de méthodes.
//===============================================
public class GXml {
//===============================================
public Element addObj(String _name) {
Element lNode = new Element(_name);
m_node.addContent(lNode);
return lNode;
}
//===============================================
public Element addObj(String _name, String _value) {
Element lNode = new Element(_name);
lNode.setText(_value);
m_node.addContent(lNode);
return lNode;
}
//===============================================
}
//===============================================Ce qu'il faut savoir:
Les méthodes doivent avoir des signatures différentes.
Constantes
L'opérateur (final) permet de définir une constante en Java.
Déclaration de constantes.
//===============================================
public class GSocket extends GObject {
//===============================================
private static final int BUFFER_SIZE = 1024; // 1 ko
private static final int BUFFER_MAX = 1*1024*1024; // 1 Mo
//===============================================
}
//===============================================Ce qu'il faut savoir:
L'opérateur (static) permet de réserver un seul emplacement pour toutes les instances de classes.
Utilisation de constantes.
//===============================================
public class GSocket extends GObject {
//===============================================
public String readData() {
while(true) {
byte[] lBuffer = new byte[BUFFER_SIZE];
int lBytes = lStreamIn.read(lBuffer);
if(lBytes == -1) break;
lData += new String(lBuffer, 0, lBytes, StandardCharsets.UTF_8);
if(lStreamIn.available() <= 0) break;
if(lData.length() >= BUFFER_MAX) {
m_srvLogs.addError("La limite des données est atteinte.");
break;
}
}
}
//===============================================
}
//===============================================Listes
La classe (ArrayList) permet de créer une liste d'objets.
//===============================================
public class GLog {
//===============================================
private ArrayList<GLog> m_map = new ArrayList<GLog>();
//===============================================
}
//===============================================La méthode (size) permet récupérer le nombre d'éléments de la liste.
La méthode (get) permet récupérer un élément de la liste.
La méthode (add) permet d'ajouter un élément dans la liste.
//===============================================
public class GLog {
//===============================================
public void addLogs(GLog _obj) {
for(int i = 0; i < _obj.m_map.size(); i++) {
GLog lObj = _obj.m_map.get(i);
GLog lNew = new GLog();
lNew.setObj(lObj);
m_map.add(lNew);
}
}
//===============================================
}
//===============================================Multithreading
La classe (Thread) permet d'introduire le multithreading en Java.
La méthode (start) permet de démarrer le thread.
La méthode (run) sert de fonction de rappel.
Création du thread.
//===============================================
public class GThread extends Thread {
//===============================================
GObject m_obj = null;
//===============================================
public GThread() {
}
//===============================================
public void setObj(GObject _obj) {
m_obj = _obj;
}
//===============================================
public void run() {
m_obj.runThread();
}
//===============================================
}
//===============================================Démarrage du thread.
//===============================================
public void runServer() {
while(true) {
GThread lThread = new GThread();
lThread.setObj(lClient);
lThread.start();
}
}
//===============================================Fonction de rappel.
//===============================================
public void runThread() {
GSocket lClient = this;
String lData = lClient.readData();
GServer lServer = new GServer();
lServer.run(lData);
lServer.sendResponse(lClient);
lClient.closeSocket();
}
//===============================================Classe
L'opérateur (class) permet de créer une classe en Java.
//===============================================
public class GLog {
}
//===============================================Une classe peut contenir des attributs appelés des propriétés ou des variables membres.
//===============================================
public class GLog {
//===============================================
private String m_type = "";
private String m_side = "";
private String m_msg = "";
private ArrayList<GLog> m_map = new ArrayList<GLog>();
//===============================================
}
//===============================================Une classe peut contenir un constructeur.
//===============================================
public class GLog {
//===============================================
public GLog() {
}
//===============================================
}
//===============================================Une classe peut contenir des méthodes.
//===============================================
public class GLog {
//===============================================
public void addLogs(GLog _obj) {
for(int i = 0; i < _obj.m_map.size(); i++) {
GLog lObj = _obj.m_map.get(i);
GLog lNew = new GLog();
lNew.setObj(lObj);
m_map.add(lNew);
}
}
//===============================================
}
//===============================================Héritage de classe
L'opérateur (extends) permet d'introduire l'héritage de classe en Java.
Définition de la classe mère.
//===============================================
public class GObject {
//===============================================
public GObject() {
}
//===============================================
public String toBase64(String _data) {
return Base64.getEncoder().encodeToString(_data.getBytes());
}
//===============================================
public String fromBase64(String _data) {
return new String(Base64.getDecoder().decode(_data));
}
//===============================================
}
//===============================================Définition de la classe fille.
//===============================================
public class GCalculator extends GObject {
//===============================================
public GCalculator() {
}
//===============================================
public String serialize() {
lDom.addData(lCode, "expression", toBase64(m_expression));
}
//===============================================
public void deserialize(String _data) {
m_expression = fromBase64(lDom.getData(lCode, "expression"));
}
//===============================================
}
//===============================================Ce qu'il faut savoir:
La classe fille a directement accès aux méthodes de la classe mère (toBase64, fromBase64).
L'opérateur (super) permet à la classe fille d'accéder à une méthode de même nom de la classe mère.
//===============================================
public class GCalculator extends GManager {
//===============================================
public GCalculator() {
}
//===============================================
public void deserialize(String _data) {
super.deserialize(_data);
}
//===============================================
}
//===============================================Ce qu'il faut savoir:
La méthode (deserailize) est définie dans la classe mère (GManager) et redéfinie dans la classe fille (GCalculator) avec la même signature.
Polymorphisme de classe
Java prend en charge la notion de polymorphisme de classe.
Définition de la classe mère.
//===============================================
public class GObject {
//===============================================
public GObject() {
}
//===============================================
public void runThread() {}
//===============================================
}
//===============================================Définition de la classe fille.
//===============================================
public class GSocket extends GObject {
//===============================================
public GSocket() {
}
//===============================================
public void runThread() {
GSocket lClient = this;
String lData = lClient.readData();
GServer lServer = new GServer();
lServer.run(lData);
lServer.sendResponse(lClient);
lClient.closeSocket();
}
//===============================================
}
//===============================================Appel de la méthode polymorphique.
//===============================================
public class GThread extends Thread {
//===============================================
GObject m_obj = null;
//===============================================
public void run() {
m_obj.runThread();
}
//===============================================
}
//===============================================Ce qu'il faut savoir:
Toutes les méthodes en Java sont polymorphes.
Communication réseau
La classe (ServerSocket) permet de créer un point de connexion côté serveur.
Elle fournit la méthode (accept) qui permet d'attendre une connexion client.
Création du server.
//===============================================
public class GSocket extends GObject {
//===============================================
public void runServer() {
int lPort = 9040;
ServerSocket lServer = null;
try {
lServer = new ServerSocket(lPort);
System.out.print(String.format("Démarrage du serveur...\n"));
while(true) {
if(!m_continue) break;
GSocket lClient = new GSocket();
try {
lClient.m_socket = lServer.accept();
}
catch(Exception e) {
m_srvLogs.addError("La connexion au serveur a échoué.");
break;
}
GThread lThread = new GThread();
lThread.setObj(lClient);
lThread.start();
}
System.out.print(String.format("Arrêt du serveur...\n"));
lServer.close();
}
catch(Exception e) {
m_srvLogs.addError("Le démarrage du serveur a échoué.");
}
if(m_srvLogs.hasErrors()) {
m_logs.addLogs(m_srvLogs);
}
}
//===============================================
}
//===============================================La classe (Socket) permet de créer une connexion côté client.
Création du client.
//===============================================
public class GSocket extends GObject {
//===============================================
public String callServer(String _data) {
String lAddress = "127.0.0.1";
int lPort = 9040;
String lDataOut = "";
try {
InetAddress lInetAddress = InetAddress.getByName(lAddress);
m_socket = new Socket(lInetAddress, lPort);
sendData(_data);
lDataOut = readData();
closeSocket();
}
catch(Exception e) {
m_srvLogs.addError("La connexion au serveur a échoué.");
}
if(m_srvLogs.hasErrors()) {
m_logs.addError("La connexion au serveur a échoué.");
}
return lDataOut;
}
//===============================================
}
//===============================================La classe (DataOutputStream) offre la méthode (write) qui permet d'envoyer un message vers un point de connexion.
//===============================================
public class GSocket extends GObject {
//===============================================
public void sendData(String _data) {
try {
DataOutputStream lStreamOut = new DataOutputStream(m_socket.getOutputStream());
lStreamOut.write(_data.getBytes());
}
catch(Exception e) {
m_srvLogs.addError("L'envoi des données a échoué.");
}
}
//===============================================
}
//===============================================La classe (InputStream) offre la méthode (read) qui permet de recevoir un message à partir d'un point de connexion et la méthode (available) qui permet de déterminer le nombre de données disponible en lecture sur le réseau.
//===============================================
public class GSocket extends GObject {
//===============================================
public String readData() {
String lData = "";
try {
InputStream lStreamIn = m_socket.getInputStream();
while(true) {
byte[] lBuffer = new byte[BUFFER_SIZE];
int lBytes = lStreamIn.read(lBuffer);
if(lBytes == -1) break;
lData += new String(lBuffer, 0, lBytes, StandardCharsets.UTF_8);
if(lStreamIn.available() <= 0) break;
if(lData.length() >= BUFFER_MAX) {
m_srvLogs.addError("La limite des données est atteinte.");
break;
}
}
}
catch(Exception e) {
m_srvLogs.addError("La lecture des données a échoué.");
}
return lData;
}
//===============================================
}
//===============================================La classe (Socket) offre la méthode (close) qui permet de fermer le point de connexion.
//===============================================
public class GSocket extends GObject {
//===============================================
public void closeSocket() {
try {
m_socket.close();
}
catch(Exception e) {
m_srvLogs.addError("La fermeture du socket a échoué.");
}
}
//===============================================
}
//===============================================XML
La librairie JDOM2 permet de manipuler un document XML.
La classe (Document) permet de créer un document XML.
La classe (Element) permet de créer un noeud XML.
La classe (Document) offre la méthode (addContent) qui permet d'ajouter un noeud à un document XML.
Création d'un document XML.
//===============================================
public void createDoc() {
m_doc = new Document();
m_node = new Element("root");
m_doc.addContent(m_node);
}
//===============================================La classe (SAXBuilder) offre la méthode (build) qui permet de charger des données XML.
La classe (Document) offre la méthode (getRootElement) qui permet de récupérer le noeud racine d'un document XML.
Chargement de données XML.
//===============================================
public boolean loadXml(String _data) {
try {
SAXBuilder lSax = new SAXBuilder();
m_doc = lSax.build(new StringReader(_data));
m_node = m_doc.getRootElement();
}
catch (Exception e) {
m_logs.addError("La création du document a échoué.");
}
return !m_logs.hasErrors();
}
//===============================================La classe (SAXBuilder) offre la méthode (build) qui permet de charger un fichier XML.
La classe (Document) offre la méthode (getRootElement) qui permet de récupérer le noeud racine d'un document XML.
Chargement d'un fichier XML.
//===============================================
public boolean loadFile(String _filename) {
try {
SAXBuilder lSax = new SAXBuilder();
lSax.setProperty(XMLConstants.ACCESS_EXTERNAL_DTD, "");
lSax.setProperty(XMLConstants.ACCESS_EXTERNAL_SCHEMA, "");
m_doc = lSax.build(new File(_filename));
m_node = m_doc.getRootElement();
}
catch(Exception ex) {
m_logs.addError("Le chargement du fichier a échoué.");
}
return !m_logs.hasErrors();
}
//===============================================La classe (Element) offre la méthode (addContent) qui permet d'ajouter un nouveau noeud à un noeud existant.
Ajout d'un nouveau noeud.
//===============================================
public Element addObj(String _name) {
Element lNode = new Element(_name);
m_node.addContent(lNode);
return lNode;
}
//===============================================La classe (Element) offre la méthode (setText) qui permet d'ajouter un texte au contenu d'un noeud.
Ajout d'un nouveau noeud avec un texte.
//===============================================
public Element addValue(String _name, String _value) {
Element lNode = new Element(_name);
lNode.setText(_value);
m_node.addContent(lNode);
return m_node;
}
//===============================================La classe (XPathFactory) offre la méthode (compile) qui permet de compiler un chemin XPath.
La classe (XPathExpression) offre la méthode (evaluate) qui permet de récupérer la liste des noeuds correspondant à chemin XPath à partir du noeud racine.
Récupération du nombre de noeuds lié à une requête XPath.
//===============================================
public int countNode(String _path) {
if(m_doc == null) return 0;
XPathFactory lXPathF = XPathFactory.instance();
XPathExpression<Element> lXPathE = lXPathF.compile(_path, Filters.element());
List<Element> lNodes = lXPathE.evaluate(m_node);
return lNodes.size();
}
//===============================================Récupération du noeud lié à une requête XPath.
//===============================================
public Element getNode(String _path) {
if(m_doc == null) return null;
XPathFactory lXPathF = XPathFactory.instance();
XPathExpression<Element> lXPathE = lXPathF.compile(_path, Filters.element());
List<Element> lNodes = lXPathE.evaluate(m_node);
if(lNodes.size() == 0) return null;
return lNodes.get(0);
}
//===============================================La classe (Element) offre la méthode (detach) qui permet de détacher un noeud de son document actuel et de le charger dans un autre document XML.
Chargement de noeuds à partir de données XML.
//===============================================
public void loadNode(String _data) {
if(_data.equals("")) return;
GCode lDom = new GCode();
lDom.loadXml(_data);
m_node.addContent(lDom.m_node.detach());
}
//===============================================La classe (Element) offre la méthode (getText) qui permet de récupérer le contenu d'un noeud.
Récupération du contenu d'un noeud.
//===============================================
public String getValue() {
if(m_node == null) return "";
return m_node.getValue();
}
//===============================================La classe (XMLOutputter) offre la méthode (outputString) qui permet de convertir un document XML en chaine de caractères.
Conversion d'un document XML en chaine de caractères.
//===============================================
public String toString() {
if(m_doc == null) return "";
XMLOutputter lXmlOut = new XMLOutputter(Format.getPrettyFormat());
String lData = lXmlOut.outputString(m_doc);
return lData;
}
//===============================================La classe (XMLOutputter) offre la méthode (outputString) qui permet de convertir un noeud XML en chaine de caractères.
Conversion d'un noeud XML en chaine de caractères.
//===============================================
public String toNode() {
if(m_node == null) return "";
XMLOutputter lXmlOut = new XMLOutputter(Format.getPrettyFormat());
String lData = lXmlOut.outputString(m_node);
return lData;
}
//===============================================Expressions mathématiques
La bibliothèque mxParser permet de manipuler des expressions mathématiques.
La classe (Expression) permet de créer une expression mathématique.
Elle offre la méthode (calculate) qui permet d'évaluer une expression mathématique.
Evaluation d'une expression mathématique.
//===============================================
public class GCalculator extends GManager {
//===============================================
public void onRunCalculator(String _data) {
Expression lExpression = new Expression(m_expression);
Double lResult = lExpression.calculate();
}
//===============================================
}
//===============================================