Java

    Le langage Java a été inventé par Sun Microsystem. Son objectif était la création 
    d'application pour la domotique.
    Avec l'essor d'internet, et la portabilité de Java, le langage est devenu un standard.

• Caractéristiques principales du langage

• Simple 
          Syntaxe proche du C++ sans la gestion de la mémoire et des pointeurs

• Orienté Objet 
          Puissance de l'objet simplifié par l'absence d'héritage multiple. Un 
          grand nombre d'API permettent l'accès et la gestion de tous ces objets.

• Portable
          Java est un langage interprété (80% de code compilé, 20% de code interprété). 
          Les 20% correspondent aux appels systèmes ce qui rend ce code portable. 
          De plus les types de données sont normalisés, donc identiques sur tous les 
          systèmes d'exploitation.

• Multitâche
          Java permet de développer des applications mettant en oeuvre l'exécution 
          simultanée de plusieurs processus, ce qui permet de diminuer 
          les temps de réponse.
          

Eléments nécessaire à JAVA :     

	L'environnement minimal pour concevoir des programmes java est gratuit et 
    disponible en ligne.
    Il s'agit du SDK (Software Development Kit). la version actuelle est 1.4.
    Ce SDK contient
    	- Un compilateur
    	- Un interpréteur
    	- Une bibliothèque d'API évitant de refaire les couches de bas niveau.

	Url indispensable : http://java.sun.com
    	Url de téléchargement du SDK : http://java.sun.com/j2se/1.4/download.html

	le second élément indispensable est un éditeur de texte comme le notepad. 
    Cependant pour gagner du temps lors du développement d'application, il est fortement 
    conseillé d'utiliser un IDE qui fournira un environnement de test, un debogueur, 
    une visualisation des classes et de leurs arborescences...

Etape 1 
    : Création d'un fichier dans le notepad s'appelant BonjourLeMonde.java 
    (Faire attention de bien respecter les majuscules/minuscule).

/**
 * La classe BonjourLeMonde est une application qui
 * affiche "Bonjour le monde!" sur la sortie standard.
 */
public class BonjourLeMonde {
    public static void main(String[] args) {
        // Affichage du message
        System.out.println("Bonjour le monde!");
    }
}

Etape 2 : Compilation du source 

	- Au travers d'une session DOS, positionnez vous dans le répertoire contenant 
    le fichier BonjourLeMonde.java
    	- Taper la commande "<chemin du SDK>\javac BonjourLeMonde.java"
    		Le chemin du SDK est le répertoire d'installation du SDK. 
    		Les utilitaires sont situés dans le répertoire bin
    		Pour éviter ces problèmes de chemin d'accès, il suffit de mettre à 
    		jour la variable d'environement PATH avec : 
    			"<Chemin du SDK>\bin" 
    	- En résultat, dans le répertoire contenant le fichier BonjouLeMonde.java, 
    	il y a un nouveau fichier s'appelant BonjourLeMonde.class. 
    	Ce fichier est la vue compilée du programme.

Etape 3 : Exécution du programme

	- Au travers d'une session DOS, taper la commande 
    "<chemin du SDK>\java BonjourLeMonde"
    	Erreur possible : 
    	Exception in thread "main" java.lang.NoClassDefFoundError: BonjourLeMonde
    	Le fichier BonjourLeMonde.class est inexistant dans le répertoire courant. 
    	L'interpréteur n'a pas pu trouver la classe
    	
    	Pour éviter ce genre de problème, il est possible de créer une variable 
    	d'environnement s'appelant CLASSPATH, et d'y mettre la liste des 
    	répertoires contenant vos applications.

JAVA sur AS/400

1. depuis la ligne de commande tapez EDTF /monrépertoire/MaClasse.java
   
   
2. passez tout de suite en page de code ASCII par F13 (nous sommes en EBCDIC / 297)
   
   
3. Saisissez votre code
   
   
4. lancez le SHELL par QSH (vous devez avoir l'option 30 du système d'exploitation)
   
   
5. pour créér la classe, utilisez JAVAC MaClasse.java
   
6. Pour lancez JAVA MaClasse
   
   
   Vous pouvez aussi utiliser la commande système RUNJVA

Commentaire : Il y a trois type de commentaires
    	- /* texte */   Ce code est ignoré par le compilateur.
    	- // texte      Ce code est ignoré du compilateur
    	- /** texte */  Ce code est ignoré du compilateur, mais il est pris en 
    	compte lors de la génération de la documentation. Java dispose d'un utilitaire 
    	permettant de générer automatiquement de la documentation.
    	Cet utilitaire s'appelle JavaDoc.

Définition d'une classe : En java, il n'existe pas de fonctions ou variables globales. 
    Toutes les méthodes et variables doivent être définies à l'intérieur d'une classe.

Méthode main : Le point d'entrée d'une application java est 
    la méthode main. Quand vous lancez l'interpréteur avec le nom de la classe, 
    il appelle automatiquement la méthode main. Le fonctionnemenr est similaire au C et C++.
    Détail de la signature de la méthode : 
    	- public : La méthode main peut-être appelée par n'importe quel objet.
    	- static : La méthode main ne peut pas être modifiée par une sous-classe
    	- void   : La méthode main ne retourne aucune valeur.

Corps du programme : L'on y trouve les instructions à exécuter, les méthodes, 
    les commentaires ...

    Le nom des classes, des méthodes et des variables est normalisé de façon non bloquante. 
    Cependant, tous les développeurs Java respectent des ces normes : 
    	- Classe : Majuscule pour chaque début de mot
    		Exemple : BonjourLeMonde 
    	- Méthode : Minuscule pour le premier mot, et majuscule pour chaque début de mot
    		Exemple : maPremiereMethode
    	- Variable : Minuscule pour le premier mot, et majuscule pour chaque début de mot 
    		Exemple : variableDeStockage
    	- Constante : Entierement en majuscule
    		Exemple : MACONSTANTE

    Le nom des classes, des méthodes et des variables est normalisé de façon non bloquante.
     Cependant, tous les développeurs et les outils de développements utilise ces normes 
     de façon à améliorer la maintenance.

Instructions, expressions et blocs

     - Toutes les instructions sont terminées par le caractère point virgule ";".
    	System.out.println("Volubis");
     - Les expressions ont pour but de produire des valeurs
     	int x = 10;
     	int x = (a + b) * 100;
     - Les blocs permettent de regrouper un ensemble d'instruction. le bloc doit 
     être déclaré entre accolades "{}"
     	try{
     		int x = 10;
     		System.out.println("" + x);
     	}catch(Exception e){
     		e.printStakTrace();
     	}
     	

Il existe trois types des variables : 
    	- Variable de classe : Variable contenant une valeur identique à toutes 
    		les instances de la classe
    	- Variable d'instance : Variable contenant une valeur propre à 
    		l'instance d'une classe
    	- Variable locale : Variable contenant une valeur propre à un bloc d'instructions ({})
    	
Déclaration d'une variable:
	<type de données> <nom de la variable> [= valeur par défaut];
	String maVariable;
	int x = 10;
	String maVariable = "Cours Java";
	
	Le compilateur java n'autorise pas la déclaration d'une variable qui n'aurait 
	pas de valeur.
		{
			int x;
			System.out.println(x=x+1);
		}

Déclaration d'une constante:
	Pour créer une constante il suffit de déclarer une variable précédée du mot clé final
		final String MACONSTANTE = "Cours Java";
		final int MONENTIER = 10;

Portée d'une variable :
	Une variable est visible seulement à l'intérieur du bloc ({}) ou elle est définie
    

public class Volubis {
        //Déclaration d'une variable globale static
        //Une variable static va avoir la même valeur 
        //pour toutes les instances de la classe.
        static int val = 1;     
    	//Déclaration d'une constante
	final static int val2 = 2;
    	//Déclaration d'une variable globale
	int val3 = 3;
	
	public Volubis() {
	  super();
	}
        //Affichage de la variable 'val' du bloc supérieur
        public int fonction(int v){
        	System.out.println("val dans le bloc fonction : " + val);
        	System.out.println("val2 dans le bloc fonction : " + val2);
        	System.out.println("val3 dans le bloc fonction : " + val3);
        	return v;
        }
        //Redefinition de la variable 'val'
        public void procedure(){
        	char val = 'A';
        	System.out.println("val dans le bloc procedure : " + val);
        	System.out.println("val this dans le bloc procedure : " + this.val);
        	System.out.println("val2 dans le bloc procedure : " + val2);
        	System.out.println("val3 dans le bloc procedure : " + val3);
        }
}

public class VolubisDemo {
//Méthode principale
	public static void main(String args[]){
		Volubis vol = new Volubis();
		System.out.println("val dans le bloc main : "  + vol.val);
		//Nouvelle affectation
		vol.val = 2;
		//appel procédure
		vol.procedure();
		//appel fonction
		vol.fonction(vol.val);
	}
}

 Ce programme affiche les résultats suivants : 
val dans le bloc main : 1
val dans le bloc procedure : A
val this dans le bloc procedure : 2
val2 dans le bloc procedure : 2
val3 dans le bloc procedure : 3
val dans le bloc fonction : 2
val2 dans le bloc fonction : 2
val3 dans le bloc fonction : 3      

Les types de données composés : 
    Toutes les classes qui existent peuvent devenir un type de données composés.
    Exemple : Une classe Point
    	 Point p;
    	 Point p = new Point();

Les chaînes de caractères : 

    Les chaînes de caractères sont manipulées par la classe String. Cette classe est 
    la seule classe qui ne nécessite pas d'être instanciée par le mot clé new.
    Exemple de déclaration d'une chaîne de caractère : 
    	- String maChaine = "Volubis"
    	- String maChaine = new String("Volubis");
    
    Pourquoi une classe ?
    	L'objet String contient un grand nombre de méthodes qui permettent la quasi-totalité 
    	des manipulations possibles.

Les tableaux : 

    Un tableau est une variable qui contient une liste d'éléments du même type de donnée simple 
    ou de la même classe.
    	Déclaration : 
    		- <type>[] <nom> ;
    		- <type> <nom>[] ;
    	Exemple : 
    		//tableau entier
    		int[] notes;
    		//tableau de chaîne
    		String nom[];
    		//Tableau multidimensionnel
    		String coordonnées[][] ;
    	Utilisation : 
    		String famille[] = {"Dupond", "Martin", "Durand"};
    	Accès à une valeur : 
    		String familleCourante = famille[indice];
    		//taille d'un tableau
    		famille.length;
    

Structure de contrôle: 
    Les boucles : 
    	while(expression booléenne){//Boucler tant que l'expression est vérifiée
    		instruction;
    	}
    	do{//boucler au moins une fois jusqu'a ce que l'instruction ne soit plus vérifiée
    		instruction;
    	}while(expression booléenne);
    	for(int i=0; i<variable; i++){//Boucler sur un ensemble fini d'occurrences. 
    	  instruction; 
    	 } 
    Les tests : Il existe deux structures de test : if-else et switch. 
    	Syntaxe de la structure de test if-else 
    	if(condition){ 
    	  instruction; 
    	} 
    	//syntaxe de la clause else 
    	if(condition){ 
    	  instruction1; 
    	}else{ 
    	  instruction2; 
    	} 
    	//imbriquer les test 
    	if(expression){ 
    	  instruction1; 
    	}else if(expression2){ 
    	  instruction2; 
    	}else if(expression3){ 
    	  instruction3; 
    	}else{ 
    	  instruction4; 
    	} 
    	Syntaxe de la structure switch 
    	switch(int expression){ 
    		case int expression1 : 
    		  instruction1; 
    		  break; 
    		case int expression2 : 
    		  instruction 2;
    		  break; 
    		... 
    		default : 
    		  instruction defaut; 
    		  break; 
    	} 

    Syntaxe permettant l'incrément : 
    i++; //Ajoute 1 à la variable
    ++i; //Ajoute 1 à la variable
    La différence entre ces deux instructions est que dans le premier cas l'instruction 
    est évaluée avant l'incrément et dans le second après l'incrément
    Exemple avec deux boucles : 
    int i = 0;
    do{
      instructions;
    while(i++<5)
    int i = 0;
    
    do{
      instructions;
    while(++i<5)
    
    La première boucle est exécutée 6 fois, et la seconde 5 fois.
    
Les opérateurs binaires : 
    

Les opérateurs d'affectation:

Les opérateurs logiques : 

Exmple : 
    	if(test1&&test2){
    	  instruction;
    	}

Gestion des erreurs :

    Java fournit un mécanisme de gestion des erreurs appelées Exception. Dès qu'une 
    erreur survient, le programme lance une exception.
    Trois instructions permettent de gérer ces erreurs : 
    	- try : Identifie le début du bloc à l'intérieur duquel une exception peut être lancée
    	- catch : Identifie le type d'exception gérable dans le bloc
    	- finaly : Permet de définir un bloc d'instruction qui sera toujours exécuté 
    	même si une erreur survient.
    	
    Exemple : 
    	try{
    	  instruction(s);
    	}catch(Exception e){
    		System.out.println(e.getMessage());
    	}finaly{
    	  instruction(s)
    	}

Ces mots sont réservés aux compilateurs java
    - abstract : déclaration d'une classe abstraite
    - break : Instruction qui permet de sortir d'une boucle 
    - class : Déclaration d'une classe
    - extends : Utilisé lors de la déclaration d'une classe pour indiquer le nom de 
    la super-classe
    - final : Utilisé dans la déclaration d'une classe pour indiquer qu'elle ne peut 
    pas êre super-classe
    	Utilisé dans la déclaration d'une méthode ou d'une variable pour interdire 
    	leur redéfinition
    - implements : Utilisé lors de la déclaration d'une classe pour indiquer le nom de 
    l'interface à utiliser
    - import : Utilisé au début d'un fichier java pour indiquer le nom des classes que 
    l'on va utilisé
    - new : Utilisé pour instancier une classe
    - package : Utilisé au début du fichier java pour le rattacher à un groupe de classe java
    - private : Utilisé pour déclarer une classe, une méthode ou une variable non visible
    - protected : Utilisé pour déclarer une classe, une méthode ou une variable visible 
    mais non modifiable
    - public : Utilisé pour déclarer une classe, une méthode ou une variable visible
    - return : Utilisé pour dans une méthode pour retourné une valeur
    - static : Utilisé pour déclarer une classe, une méthode ou une variable comme des 
    constantes
    - super : utilisé pour faire référence à la super-classe
    - synchronized : Utilisé dans un bloc pour indiquer q'un ensemble d'instruction 
    n'est exécutable
	que par un programme simultanément.
    - this : utilisé pour faire référence à l'objet courant  
    - void : Utilisé pour déclarer une méthode comme étant une procédure