Accueil > Ressources > Introduction au langage JAVA

Introduction au langage JAVA

lundi 25 janvier 2010, par LOISON

Dans cet article nous allons définir une classe,un attribut et une méthode pour le langage JAVA. Nous chercherons ensuite à savoir comment peut-on y accéder ?
Dans la suite de cet article nous verrons comment définir des tableaux associatifs et des expressions régulières en JAVA.

En programmation orientée objet une classe déclare des propriétés communes à un ensemble d’objets. La classe déclare des attributs représentant l’état des objets et des méthodes représentant leur comportement.

Pour commencer nous allons définir ce qu’est une classe en JAVA.

Une classe représente donc une catégorie d’objets. Il apparaît aussi comme un moule ou une usine à partir de laquelle il est possible de créer des objets. On parle alors d’un objet en tant qu’instance d’une classe (=création d’un objet ayant les propriétés de la classe).

Dans le langage JAVA notre code est inséré dans ce qu’on appelle des classes,pour n’importe quelle application il est nécessaire d’en utiliser au moins une.

Chaque classe est décomposé en un fichier texte qui suit les conventions de codage JAVA,c’est à dire que les noms de classes doivent correspondre aux noms de leurs fichiers .java. On écrit les classes en minuscules avec chaque première lettre des mots composant le nom de la classe en majuscules.Par exemple, la classe MaClasse sera enregistrée sous le nom MaClasse.java.

Une classe s’écrit comme ci-dessous :

public class MaClasse // on déclare la classe MaClasse avec le droit d'accès public.

                           

{

//code

}

Il est possible de faire appel à des constructeurs qui va créer un objet à partir d’une classe, cela necessite l’utilisation de l’opérateur new.
Le rôle du constructeur est de déclarer et de permettre d’initialiser les données de la classe, ainsi que de permettre différentes actions (définies par le concepteur de la classe) lors de l’instanciation.

Un constructeur se définit comme une méthode standard(que nous allons définir plus loin dans l’article) , mais ne renvoie aucune valeur.
Ainsi, le constructeur d’un objet porte le même nom que la classe et ne possède aucune valeur de retour.

Les propriétés d’un constructeur sont :

-qu’un constructeur porte le même nom que la classe dans laquelle il est défini.

-qu’un constructeur n’a pas de type de retour .

-qu’un constructeur peut avoir des arguments.

-que la définition d’un constructeur n’est pas obligatoire lorsqu’il n’est pas nécessaire.

Voyons sur un exemple comment se déclare un constructeur :

class Toto{  //on déclare la classe Toto

int age;       //on déclare la variable entière age

char sexe;   //on déclare la variable caractère sexe

float taille;   //on déclare la variable flottante taille (contient des valeurs

                   //décimales)

Toto(int age, char sexe, float taille){ //on déclare la méthode Toto qui va


                                                       //attribuer des valeurs aux variables

                                                      //précédemment déclarées

        this.age = age; //donne la valeur age à la variable age

        this.sexe = sexe;//donne la valeur sexe à la variable sexe

        this.taille = taille;//donne la valeur taille à la variable taille

 }

}

Nous allons maintenant définir ce qu’est un attribut en JAVA .

Un attribut permet de stocker des données à l’intérieur d’une classe. Un attribut se note comme ceci dans la classe (ou dans une méthode) :

[droits d’accès] [type de l’attribut] [nom de l’attribut] [éventuellement une définition ici]

Les droits d’accès à un attribut peuvent être de trois types :

-private : seules les méthodes de la classe dans laquelle est définit l’attribut peuvent y accéder et le modifier

-protected : seules les méthodes de la classe et des éventuelles classes héritées peuvent accéder à l’attribut et le modifier

-public : tout le monde peut accéder à l’attribut en question.

Les types correspondent aux types de données suivants :

- Les types primitifs

Type primitif | Signification | Place occupée en mémoire

byte | Entier très court allant de -128 à +127 | 1 octet

short | Entier court allant de -32768 à +32767 | 2 octets

int | Entier allant de -2 147 483 648 à +2 147 483 647 | 4 octets

long | Entier long allant de -263 à +263 -1 | 8 octets

float | Nombre réel allant de -1.4 * 10-45 à +3.4 * 103 | 4 octets

double | Nombre réel double précision allant de 4.9 * 10-324 à +1.7 * 10308 | 8 octets

char | Caractère unicode (65536 caractères possibles) | 2 octets

boolean | variable booléenne (valeurs : vrai ou faux) | 1 octet

- Les types objets

Il existe un type objet "transparent" : le type String (notez le S majuscule, c’est important). Ce type de données pourra contenir une chaîne de caractères. Comme il s’agit d’un type objet, le type String dispose de méthodes propres, comme par exemple la méthode equals() qui permet de savoir si une chaîne contient la valeur désirée.

Un type enveloppe est un type objet qui encapsule un type primitif. Grâce aux classes enveloppes (aussi appelées wrappers) nous pouvons manipuler les types primitifs à l’aide de méthodes inclues spécialement pour ces types enveloppes.

Voici la liste des types enveloppes intégrés en JAVA :

Type enveloppe | Type primitif associé

Byte | byte

Short | short

Integer | int

Long | long

Float | float

Double | double

Character | char

Boolean | boolean

Lors de la saisie du nom de attribut, il est conseillé de le composer de caractères alphanumériques. L’underscore est autorisé, mais il faut éviter de le placer en premier.

La définition d’un attribut indique que nous lui avons attribué une valeur,ceci est facultatif. Si nous n’attribuons pas de valeur à l’attribut, il y aura simplement une zone mémoire réservée, cette zone ne contiendra aucune valeur tant que nous n’aurons pas attribué de valeur à l’attribut.

Exemple :

public class Test// déclare la classe Test avec l'accès public pour les

{

   private float nombre;

   public double attribut_public;

   protected int nb;

   public Test()

   {

       nombre = 3.14f;
       nb = (int) 8.14;

   }

}

Et pour finir nous allons définir ce qu’est une méthode en JAVA.

Les méthodes (aussi appelées fonctions par abus de langage) vont nous permettre d’effectuer des traitements que nous effectuerons généralement au moins deux fois dans le code (sinon la création d’une méthode ne nous permettra juste que d’éclaircir un peu votre code avec en contrepartie une petite perte de performances).

Une méthode se délimite comme une classe, c’est à dire par deux accolades. Nous sommes cependant obligé d’y ajouter des parenthèses, même si elles ne contiennent rien. Ce qu’on peut placer à l’intérieur des parenthèses s’appellent les paramètres.

Il existe différents types de méthodes que l’on peut globalement classer en trois familles :

-Les accesseurs : ces méthodes vont permettre de modifier un attribut privé d’une classe par une autre classe (il s’agit d’une méthode publique accessible aux autres classes).

- Les modificateurs : ces méthodes ne retournent rien et modifient la valeur d’un attribut privé. Il s’agit de méthodes publiques.

-Le reste : toutes les fonctions qui ne rentrent pas dans ces deux catégories.

Les droits d’accès :

Comme pour les attributs, les méthodes disposent des mêmes droits d’accès qui limitent leur utilisation :

-public : la méthode est accessible de n’importe où.

- private : la méthode est accessible uniquement dans la classe où elle figure.

-protected : la méthode est accessible dans la classe où elle figure et dans les classes héritées.

Exemple d’une méthode MaMethode() qui ne renvoie rien (le mot clé void est facultatif), et qui ne prend pas de paramètre d’entrée :

public class Test
[
public Test()
[
MaMethode() ;
]

public void MaMethode()
[
System.out.println("Appel de la méthode") ;
]
]

Lorsque la méthode doit retourner un type de donnée, vous devez remplacer "void" par le type de donnée que vous souhaitez.

Lorsque la méthode doit retourner une donnée, on utilise le mot clé return. Attention, ce mot clé provoque l’arrêt de la fonction, c’est à dire que la donnée sera retournée et l’éventuel code se trouvant après le mot return ne sera pas exécuté. On peut donc utiliser le mot clé return pour interrompre une fonction comme ceci : return ; (ceci est valable si la fonction ne renvoie rien, sinon on doit retourner le type de données approprié, par exemple 0 pour un type de données int).

Exemple d’une méthode acceptant un paramètre et retournant un entier :

public class Test

{

   public Test()

   {

       MaMethode(50);

   }

   public int MaMethode(int variable)

   {

       System.out.println("Le nombre que vous avez passé en paramètre vaut : " + variable);

       return variable + 50; //variable vaut maintenant 100

   }

}

La surcharge de méthodes :

La surcharge survient lorsque l’on a deux méthodes du même nom mais qui ne prennent pas les mêmes paramètres. Voici un exemple de surcharge de méthode :

public class Test

{
   public Test()

   {

       MaMethode();

       MaMethode(50);

   }

   public void MaMethode(int variable)

   {

       System.out.println("Le nombre que vous avez passé en paramètre vaut : " + variable);

   }

   public void MaMethode()

   {

       System.out.println("Vous avez appelé la méthode sans paramètre ");

   }

}

Méthodes statiques :

Une méthode statique est une méthode qui peut être appelée même sans avoir instancié la classe. Une méthode statique ne peut accéder qu’à des attributs et méthodes statiques.

Exemple d’application avec une méthode statique :

public class Test

{
   public int test;

   public static String chaine = "bonjour";
   
   public Test()

   {

       MaMethodeStatique();

   }
   
   public static void MaMethodeStatique()

   {  

       int nombre = 10;
       
       System.out.println("Appel de la méthode statique : " + nombre + chaine);  

   }

}

On peut sans avoir instancié la classe accéder à la méthode statique en tapant ceci : Test.MaMethodeStatique() ; n’importe où dans le code.

Pour définir les arguments en JAVA nous allons travailler sur un exemple avec la fonction main.

La fonction main est définit comme ci-dessous :

public static void main(String[] args)

Les arguments de main sont des chaînes de caractères, rangées dans le tableau args. Il s’agit des différents mots passés en arguments de la commande java NomClass. L’élément args[0] correspond au premier argument, et non au nom de la classe. Pour convertir les arguments de main de type String en l’un des types primitifs, par exemple int, on utilise la fonction

int Integer.parseInt(String str)

ou, de manière équivalente Boolean.parseBoolean, Byte.parseByte, Short.parseByte, Long.parseLong, Float.parseFloat, Double.parseDouble.

Par exemple, si l’on veut exécuter un programme avec comme paramètres une chaînes de caractères, un nombre entier puis à nouveau une chaîne de caractères, nous aurons la fonction main suivante :

public static void main(String[] args)
   {
       String pays = args[0];
       int cp = Integer.parseInt(args[1]);
       String ville = args[2];
             ⋮
   }

TABLEAUX ASSOCIATIFS :

En informatique, un tableau associatif (aussi appelé dictionnaire ou table d’association) est un type de données associant à un ensemble de clefs un ensemble correspondant de valeurs. Ces ensembles sont finis.

Chaque clef est associée à une valeur : un tableau associatif correspond à une fonction d’injection en mathématiques(Une application f : X -> Y est dite injective ou est une injection si pour tout y dans l’ensemble d’arrivée Y, il existe au plus un élément x dans l’ensemble de définition X tel que f(x) = y. On dit encore dans ce cas que tout élément y de Y admet au plus un antécédent x (par f)

De manière équivalente, f est dite injective si pour tous x et x’ dans X, f(x) = f(x’) implique x = x’..).

Du point de vue du programmeur, le tableau associatif peut être vu comme une généralisation du tableau : alors que le tableau traditionnel associe des entiers consécutifs à des valeurs d’un certain type, le tableau associatif associe des valeurs d’un type arbitraire à des valeurs d’un autre type.

Les opérations usuellement fournies par un tableau associatif sont :

-ajout : association d’une nouvelle valeur à une nouvelle clef ;

- modification : association d’une nouvelle valeur à une ancienne clef ;

- suppression : suppression d’une clef ;

- recherche : détermination de la valeur associée à une clef, si elle existe.

Les tableaux associatifs diffèrent des tableaux normaux de taille fixe en ce qu’ils n’ont aucune limite prédéfinie en matière de nombre d’éléments.

Les éléments peuvent être indexés par un tuple(un couple de valeurs x et y s’écrit (x, y ).
Si x est de type T et y de type U, alors (x, y ) a le type ”tuple” (T, U).
Plus généralement, si xi : Ti, alors le tuple (x1, ..., xn ) a le type
(T1, ..., Tn ).
Les tuples et les listes fusionnent, l’un comme l’autre, les données mais il y a
deux différences importantes.
• Les éléments d’un tuple peuvent être de types différents, alors que les
éléments d’une liste sont tous du même type.
• Le nombre d’éléments d’un tuple est fixé par son type, alors que la
longueur d’une liste ne l’est pas.)

Les tableaux associatifs sont utiles dans les situations dans lesquelles vous devez utiliser une table de hachage ou une autre structure de données de dictionnaire simple dans un programme en langage C, C++ ou Java. Les tableaux associatifs nous permettent de créer un historique dynamique des événements et de l’état capturé dans notre programme .

Pour définir un tableau associatif, on écrit une expression d’affectation comme ci-dessous :

name [ key ] = expression ;

name correspond à un identificateur valide et key à une liste séparée par des virgules d’une ou plusieurs expressions.

Par exemple, l’instruction suivante définit un tableau associatif a avec la signature de clé [ int, string ] et enregistre la valeur entière 456 à l’emplacement nommé par le tuple [ 123, "hello" ] :

a[123, "hello"] = 456 ;

Le type de chaque objet contenu dans le tableau est également fixe pour tous les éléments d’un tableau donné. Comme a a été affecté en premier à l’aide du nombre entier 456, chaque valeur ultérieure enregistrée dans le tableau aura également comme type int. Par contre nous ne pouvons pas imbriquer un tableau associatif dans un autre sous forme de clé ou de valeur.

Voici un exemple de tableau associatif utilisant une matrice creuse :

float[][][] Matrice = {1.1,2.5,3.9}{5.1,2.6,8.1}{9.6,4.1,6.5};

EXPRESSIONS REGULIERES :

Les expressions régulières ou rationnelles sont des expressions construites à partir de constantes et d’opérateurs.

Trois classes interviennent dans les utilisations d’expressions régulières en Java :

-Pattern : permet d’obtenir une version compilée d’une expression régulière.

- Matcher : permet d’analyser une chaîne en entrée à partir d’un Pattern.

-PatternSyntaxException : exception levée lorsque la syntaxe d’une expression régulière n’est pas correcte.

Les caractères utilisés dans une expression rationnelles sont les caractères unicode java, plus les caractères spéciaux suivants :

Caractère :Sémantique.

\\ :Le caractère anti-slash
\0n :Le caractère de code octal n avec (0≤n≤7)

\0nn :Le caractère de code octal nn avec (0≤n≤)

\0mnn :Le caractère de code octal mnn avec (0≤m≤3 et 0≤n≤7)

\0hh :Le caractère de code 0xhh

\0hhhh :Le caractère de code 0xhhhh

\t :Le caractère de tabulation ’\u0009’

\n :Le caractère de nouvelle ligne ’\u000A’

\r :Le caractère de retour en début de ligne ’\u000D’

\a :Le caractère sonnette ’\u0007’

\e :Le caractère d’échappement ’\u001B’

\cx : Le caractère de contrôle correspondant à x

Les méta-caractères sont des caractères qui sont interprétés par l’analyseur. Pour qu’un méta-caractère ne soit par interprété par l’analyseur, il faut le faire précéder du caractère ’\’. Les caractères ’-’ et ’]’ ont un statut spécial : dans un intervalle ce sont des méta-caractères, et en dehors d’un intervalle ils se comportent comme des caractères normaux.

-[a\]b]*c est équivalent à (a|]|b)*c

-[a\-b]*c est équivalent à (a|-|b)*c

Caractère :Sémantique.
. :Remplace n’importe quel caractère, sauf la fin de ligne.

 ? :Opérateur portant sur l’expression précédente : 0 ou une fois l’expression précédente.

* :Opérateur de Kleene : 0, 1 ou plusieurs fois l’expression précédente.

+ :1 ou plusieurs fois l’expression précédente.

[] :Intervalle de caractères.

:Quantificateur.

\ :Le caractère qui suit n’est plus considéré comme un méta-caractère.

^ :Négation ou début de ligne.

$ :Fin de ligne.

| :Opérateur ou.

Une classe de caractères est un ensemble de caractères : certaines classes sont prédéfinies dans l’API Java, d’autre peuvent être définies par le programmeur.

Classe :Sémantique.

\d :Un chiffre : équivalent à [0-9]

\D :un caractère qui n’est pas un chiffre : équivalent à [^0-9]

\s :Un caractère blanc : espace, tabulation, retour à la ligne ... équivalent à [ \t\n\r\f\x0B]

\S :Un caractère non blanc : [^\s]

\w :Un caractère de mot : [a-zA-Z_0-9]

\W :Un caractère qui n’est pas un caractère de mot : [^\w]

Une classe de caractères peut être définie par le programmeur en écrivant entre [ ] la liste des caractères de la classe, et en utilisant les opérateurs d’union (non marqué), d’intersection (&&) et de négation (^) :

[abc] ou [a-z] :La classe des trois caractères a, b et c, ou la classe de tous les caractères de a à z.

[^abc] :La classe de tous les caractères sauf a, b et c.

[a-zA-Z]ou[a-z[A-Z]] :L’union des classes [a-z] et [A-Z].

[123abc&&[a-z]] :L’intersection de la classe [123abc] et de la classe [a-z]

Les classes de caractères POSIX sont :

Classe :Sémantique.

\pLower:Une lettre minuscule : [a-z]

\pUpper:Une lettre majuscule :[A-Z]

\pASCII:tout caractère ASCII :[\x00-\x7F]

\pAlpha:Une lettre minuscule ou majuscule :[\pLower\pUpper]

\pDigit:Un chiffre : [0-9]

\pAlnum:Une lettre ou un chiffre :[\pAlpha\pDigit]

\pPunct:Ponctuation : un parmi !"#$%&’()*+,-./ : ;<=> ?@[\]^_`| 

\pGraph:Un caractère visible : [\pAlnum\pPunct]

\pPrint:Un caractère imprimable [\pGraph\x20]

\pBlank:Espace ou tabulation : [ \t]

\pCntrl:Caractère de contrôle : [\x00-\x1F\x7F]

\pXDigit:Un chiffre hexadécimal [0-9a-fA-F]

\pSpace:Un espace : [ \t\n\x0B\f\r]

Les classes de caractères Java sont :

Classe :Sémantique.

\pjavaLowerCase:Equivalent to java.lang.Character.isLowerCase()

\pjavaUpperCase:Equivalent to java.lang.Character.isUpperCase()

\pjavaWhitespace:Equivalent to java.lang.Character.isWhitespace()

\pjavaMirrored:Equivalent to java.lang.Character.isMirrored()

Les classes de caractères Unicode sont :

Classe :Sémantique.

\pInGreek:Un caractère grec.

\pLu:Une lettre majuscule.

\pSc:Un symbole monétaire.

\PInGreek:Tout ce qui n’est pas un caractère grec.

Les quantificateurs sont

- + : une ou plusieurs occurrences.

- * : zéro, une ou plusieurs occurrences.

- ? : zéro ou une occurrence.

- n : exactement n occurrences.

- n, : au moins n occurrences.

- n,m : de n à m (inclus) occurrences.

Les quantificateurs précédents sont qualifiés de 3 façons différentes :

-avides : le matcheur lit toute la chaîne avant d’essayer la première concordance. Si l’appariement échoue, le matcheur recule d’un caractère, puis recommence ... et ainsi de suite. La recherche du motif .
*abc dans la chaîne abcxxxxxxabcxxxxabc trouve une occurrence de 0 à 19.

- réticent noté par ? : la premère réussite est la bonne ! La recherche du motif .* ?abc dans la chaîne abcxxxxxxabcxxxxabc trouve trois occurrences, une de 0 à 3, une de 3 à 12 et une 12 de à 19.

-possessif noté par + : pareil que avide, mais si ça échoue, on ne recommence pas ! La recherche du motif .*+abc dans la chaîne abcxxxxxxabcxxxxabc ne trouve pas de concordance : en effet, .*+ mange tout jusqu’à la fin de la chaîne, et donc ce n’est pas suivi de abc

Les spécificateurs de frontière sont des indicateurs permettant de dire où commence ou où finit le motif.

^ :Début de ligne. (en mode multiligne )

$ :Fin de ligne. (en mode multiligne )

\b :Extrémité de mot.

\B :Extrémité de non mot.

\A :Le début de la séquence à analyser.

\G :L’analyse du motif qui suit \G suit exactement l’analyse précédente du motif.

\Z :La fin de la séquence à analyser, moins le caractère final.

\z :La fin de la séquence à analyser.

sources : http://www.vulgarisation-informatique.com/

http://docs.sun.com/app/docs/doc/819-6958/6n8ugrktp?l=fr&a=view

http://fr.wikipedia.org/wiki/Tableau_associatif

http://prevert.upmf-grenoble.fr/Prog/Java/CoursJava/expressionsRegulieres.html