Affichage des articles dont le libellé est éléments de cours. Afficher tous les articles
Affichage des articles dont le libellé est éléments de cours. Afficher tous les articles


Au niveau de la compilation et portabilité
 1. C++

  La compilation d'un programme écrit en langages C++ traduit le programme source en langage machine, c'est-à-dire, en instructions spécifiques au microprocesseur de l'ordinateur utilisé. Le résultat de la compilation est placé dans un fichier binaire (ou fichier exécutable) directement exécutable par le microprocesseur utilisé.
  Les fichiers binaires obtenus par la compilation des fichiers sources ne sont pas portables, ce qui signifie que ces fichiers ne peuvent être exécutés que sur le système (plate-forme et système d'exploitation) pour lequel ils ont été compilés.
  Pour utiliser le même programme sur une autre plate-forme, il faut le recompiler pour produire le langage machine spécifique à ce système. Le plus souvent, il faut modifier le code source avant de le compiler sur la nouvelle machine, compte tenu des différences que présentent les différents ordinateurs au niveau de leur micro-processeur.


2. Java


Si le langage Java est indépendant de toute plate forme (langage multi plate-forme), c'est parcequ'il repose sur une machine virtuelle Java ( JVM : Java Virtual Machine), il s'agit d'un programme appelé aussi interpréteur Java. Cette machine virtuelle prend les programmes Java compilés en bytecode et convertit les instructions du bytecode en instructions compréhensibles par un système d'exploitation.
Le même fichier compilé (ou bytecode) peut fonctionner sur n'importe quel système (plate-forme et système d'exploitation) possédant une machine virtuelle Java qui lui est compatible.
  • Les programmes Java ne peuvent fonctionner que sur un système sur lequel une machine virtuelle Java adéquate a été installée.
  • Les navigateurs Web permettent d'utiliser des applets possèdent aussi une machine virtuelle Java.
Le fait que Java repose sur l'interpréteur (machine virtuelle) a des incidences sur les performances des programmes Java. En effet, ces programmes s'exécutent plus lentement que les programmes écrits dans les langages compilés dépendants d'une plate-forme donnée telle le C++.

Comme déjà expliqué dans l'ancienne article Les Concepts de la Programmation Orientée Objet , l'encapsulation signifie que c'est pas possible d'agir sur les données directement, donc il faut passer par des méthodes d'objets.
Plusieurs niveaux de visibilité peuvent être définis en précédant d'un modificateur la déclaration d'un attribut, méthode ou constructeur.
Private, Public, Protected

Classe 
Public : La classe peut être utilisée par n'importe quelle classe
Private : Utilisable uniquement par les classes définies à l'intérieur d'une autre classe. Une classe privée n'est utilisable que par sa classe englobante
Attribut
Public: Attribut accessible partout où sa classe est accessible. N'est pas recommandé du point de vue encapsulation
Private: Attribut restreint à la classe où est faite la déclaration
Méthode
Public: Méthode accessible partout où sa classe est accessible
Private:  Méthode accessible à l'intérieur de la définition de la classe
Membres publics: Données ou méthodes accessible de l'extérieur de la classe.
Membres privés: Données ou méthodes non accessibles de l'extérieur de la classe.

Exemple d'Encapsulation
public class Voiture {
   //Déclaration d'attribut privée puissance
   private int puissance;
   ...
   //Déclaration d'une méthode public demarre()
   public void demarre(){
          ...
   }
    //Déclaration d'une méthode privée makeCombustion()
     private void makeCombustion(){
          ...
     } 
public class TestMaVoiture {
public static void main(String[] args){
//Déclaration puis création de maVoiture
Voiture maVoiture = new Voiture();

//Démarage de maVoiture
maVoiture.demarre();

maVoiture.makeCombustion(); //Erreur
}
}
Erreur: Parce que une méthode privée ne peut plus être invoquée en dehors du code de la classe où elle est définie.

L'encapsulation 
 En P.O.O pure, les données sont encapsulées, ce qui signifie qu'il n'est pas possible d'agir directement sur les données d'un objet, il faut obligatoirement passer par les méthodes de l'objet.

 L'encapsulation de données permet de les protéger, elle constitue un moyen sûr pour préserver l’intégrité des données. En effet, les contraintes d'intégrité (ou domaines de validité des données) sont programmées et contrôlés dans les méthodes et il obligatoire de passer par ces méthodes pour modifier les données.
 L'encapsulation permet la modularité et facilite la réutilisation de logiciel, en effet, les données et les méthodes sont regroupées dans une même classe. De ce fait, une classe est considérée comme un module indépendant qu'on peut réutiliser dans un nouveau programme. 
 Pour mieux comprendre ce concept, je vous invite à consulter mon future article sur L'encapsulation.

La composition 
 La composition signifie que les objets peuvent être inclus les uns dans les autres. Les objets sont organisés selon la relation composé de.
Exemple : 
  • Un point est un objet qui contient les coordonnées (x,y) d'un point dans un plan.
  • Un cercle est un objet qui contient le rayon du cercle et un point indiquant le centre du cercle.
On dit, qu'un objet cercle est composé d'un objet point et d'un rayon du type primitif réel qui n'est pas un objet.


 Le polymorphisme
 C'est la faculté d'une méthode à s'appliquer à des objets de types différents. Grâce au polymorphisme, il est possible de définir plusieurs méthodes différentes qui portent le même nom, la différences entre ces méthodes se fait par rapport au nombre et aux types des paramètres.

 Le polymorphisme permet l'écriture du code indépendamment des types spécifiques d'objets.

La généricité
 La généricité (ou types paramétrés) permet d'introduire des paramètres (ou variables) de types  dans la définition d'une méthode ou d'une classe.

 La généricité facilite la réutilisation de composants logiciels, elle permet aussi l'écriture du code indépendamment des types spécifiques d'objets.

L'héritage
 L'héritage est un mécanisme de transmission de fonctionnalités (propriétés et comportement) d'une classe vers une autre classe. Grâce à l'héritage, il devient donc possible de définir une nouvelle classe à partir d'une classe existante, à laquelle on ajoute de nouvelles fonctionnalités, c'est-à-dire, de nouvelles données (ou propriétés) et de nouvelles méthodes (ou comportements).

  La nouvelle classe hérite les fonctionnalités de l'ancienne classe tout en le spécialisant. Dans ce cas, la classe héritée constitue donc une généralisation alors que la classe qui dérive par héritage constitue une spécialisation.

 L'héritage organise les classes selon la relation est un. Il facilite la réutilisation et l'extensibilité de produits existants.
 Pour mieux comprendre ce concept, je vous invite à consulter mon future article sur L'héritage.
L'interface
 Une interface regroupe un ensemble de méthodes (ou comportement) dite abstraites, c'est à dire non implémentées. Lorsqu'une classe implémente une interface, cela indique que la classe se dote d'un comportement supplémentaire par rapport à son comportement et à celui dont elle hérite déjà de ses superclasses (classes dont elle dérive par héritage, c'est-à-dire, sa superclasses immédiat, la superclasse de la superclasse, ... , etc).

 Certains langages de P.O.O  (comme par exemple, le C++) permettent l'héritage multiple, c'est à dire, qu'une classe peut hériter les fonctionnalités de plusieurs superclasses. Dans ces langage, une classe peut donc posséder plusieurs superclasses.

 En java, l'héritage multiple n'est pas permis, en effet, pour les raisons de simplicité, Java, ne permet d'utiliser que l'héritage simple. Dans ce cas, une classe ne peut hériter les fonctionnalités que d'une seule superclasse.

 L'héritage simple peut être restrictif, surtout quand-on veut construire une classe qui doit hériter les fonctionnalités de plusieurs classes. Pour résoudre ce problème. Java propose d'utiliser des interfaces, en effet, grâce aux interfaces, une classe peut combiner les comportements issus de plusieurs interfaces.

Le package
 Un package permet de regrouper des classes et des interfaces. De la même manière que les classe qui permettent d'encapsuler les données, les packages peuvent être utilisés pour encapsuler des classes. Mais un package doit obligatoirement avoir au moins une classe public accessible depuis l'extérieur du package.

 Les packages servent donc à protéger les classes, les données et les méthodes. Ils constituent des modules indépendants qu'il est facile d'intégrer et de réutiliser dans un nouveau programme.



Avant le concept O.O (l'Orientée Objet), la programmation était structurée (ou classique) qui sépare les données et les traitements. Elle repose sur ce qu'on nomme l'équation de Wirth :
 Structures de données + Algorithmes = Programmes
Cette séparation :
  1. Rend les données vulnérable à des accès : elles ne sont pas protégées. Si les modifications erronées des données sont effectuées, l'intégrité de ces données peut être altérée.
  2. Rend difficile l'extensibilité et la réutilisation de logiciels ou produits existants.
Alors que la Programmation Orientée Objet (P.O.O) est fondé, sur le concept d'objet. Un objet est une association des données et des traitements appelés méthodes agissant sur ces données :
Données + méthode = objet (Les données et les méthodes sont regroupées au sein de l'objet).

Un objet constitue une instance (ou variable) d'une classe. Le mécanisme qui permet de créer des objets à partir des classes s'appelle l'instanciation. Ce mécanisme permet non seulement de créer l'objet mais aussi de l’initialiser (de lui donner une valeur).

Une classe constitue une description (ou un model) d'un ensemble d'objets ayant une même structure de donnée et disposant des mêmes méthodes.
Classe : Ensemble (ou type de données)
Objet : Élément de la classe (ou variable, ont dit aussi instance de la classe)
Les concepts principaux dans la P.O.O pure sont : l'encapsulation, la composition, le polymorphisme, la généricité et l'héritage. En plus de ces cinq concepts, le langage Java ajoute deux autres concepts : l'interface et le package, dont on va les détaillés dans l'article : "Les Concepts de la P.O.O".

Vous aimez cet article, s’abonner vous! Pour recevoir plus de tutoriels.

* Cette option vous permet d'être au courant des nouvelles articles, en remplissant votre adresse Email ci-dessus, ou vous pouvez vous abonnez sur le formulaire qui se trouve à gauche de la page d'accueil ;


En Java, il existe deux catégories de types de données : les types primitifs et les types références( en Java, les objets sont manipulés par références).

Les types primitifs

Il existe huit types primitifs prédéfinis en Java :
  • Six types numérique : quatre types d'entiers signés (byte, short, int et long) et deux types réels à virgule flottante (float et double);
  • Le type caractère char utilisé pour représenter des caractères Unicode;
  • Le type boolean : représente les valeurs booléennes false et true.
Ces types appelés types primitifs, car les variables de ces types ne sont pas stockées sous la forme des objets, ce qui permet une utilisation plus efficace. Ces types de données ont la même taille quelque soit la plate-forme et le système d'exploitation utilisé.
Il faut noter que le package java.lang inclut des classes correspondant à chacun de ces types primitifs. A la différence des types primitifs, ces classes permettent de définir des objets.
  1. Les types primitifs numériques
Le tableau suivant donne tous les types numériques de base qu'il est possible de former :


Les classes du package java.lang correspondant à ces types primitifs sont Byte , Short, Integer, Long, Float et Double. Il faut noter que les noms des classes commencent toujours par une lettre en majuscule, alors que les noms des types primitifs ne s'écrivent qu'en minuscule.
  • Pour définir une constante entière en hexadécimal, il faut la fair précéder par 0x ou 0X (exemple: 0xCAF9)
  • Une constante entière est par défaut de types int. pour définir une constante entière de types long, il faut la faire suivre par la lettre l ou L (exemple: 4000000000L)
  • Une constante décimale doit comporter un . (point) ou un e (ou E : exposant). Par défaut, cette constante est de type double. Pour définir une constante décimale de type float, il faut la faire suivre par la lettre f ou F (exemple: 3.402f).
       2. Le type primitif char

En Java , le type caractère char est implémenté sur 16 bits (2 octets) pour représente l'ensemble des caractères Unicode.
 L'unicode est un système qui comporte les caractères de toutes les langues écrites. Les caractères du code ASCII sont contenus dans l'Unicode. Pour plus d'informations sur le standard Unicode, visitez le site web Unicode à l'adresse : http://www.unicode.org.

Une constante de type char est :
  • Un caractère unique placé entre deux guillemets : 'A', '+', '3', ...etc.
  • Une suite de deux caractères, le premier est \ (anti-slash ou back-slash) pour désigner les caractères spéciaux (caractères de contrôle non imprimable) : '\b' (retour arrière : Backspace), '\n' (nouvelle ligne: Newline), '\t' (tabulation horizontale), ... etc.
  •  De la forme '\unnnn' : pour désigner un caractère Unicode. nnnn est le code du caractère formé de 4 chiffres hexadécimaux (en base 16). L'interface de ces valeurs va de '\u0000' à '\uFFFF' : '\u00ff' , '\u000b', ... etc.
  • La classe du package java.lang qui correspond à ce type primitif est Character.
  • Le type char est non signé et peut être converti explicitement par une opération de transtypage (cast) en type numérique (de byte à double).
      3. Le type primitif boolean

 Le type boolean sert à définir des variables qui peuvent contenir soit la valeur false, soit la valeur true. En Java , la conversion est interdite entre les booléens et les nombres, même par transtypage, la classe du package java.lang qui correspond à ce type primitif est Boolean.

Les Types références 

En Java, les objets utilisés dans un programme ne sont pas manipulés directement, en effet, on ne peut manipuler que des références (pointeurs implicites) à ces objets. C'est pourquoi, on parle de type référence. Les emplacements mémoires réservés à ces objets sont alloués dynamiquement à l'aide de l'opérateur new.

Il y a trois catégories de types références : les classes, les interfaces et les tableaux. Un objet est soit une instance de classe, soit un tableau (qui  est en fait une instance de la classe Array qui se trouve dans le package java.lang.reflect).

Les  interfaces ne peuvent pas être instanciées, ce qui signifie qu'il est possible d'avoir une réérebce de type interface mais pas d'objets de type interface.


Le langage Java fourni trois éléments spécifiques permettant la programmation par objet : les classes, les packages et les interfaces.
Dans cette article on va s'intéresse aux Classes.
Une classe représente un modèle de données qui sert à créer des objets.
En java, une classe se déclare à l'aide du mot clé class suivi du nom de classe, elle se compose de :
  1. Données : les attributs (ou champs) ; 
  2. Comportement : les méthodes qui agissent sur les données.
 Les attributs et les méthodes d'une classe sont appelés membres de la classe.

 La syntaxe générale d'une classe Java est la suivante : 

[modificateur] class NomDeClasse [extends NomDeSuperClasse] [implements interface1, interface2, ...]
{
//Définitions des attributs.
[modificateur] Type1 Attribut1 [=valeur1];
[modificateur] Type2 Attribut2 [=valeur2];

       ... //Autres attributs.

//Définitions des méthodes
[modificateur] TypeRetour1 NomMethode1(paramètres)  [throws exception1, exception2, ...]
{
     // Corps de la méthode.
}

[modificateur] TypeRetour2 NomMethode2(paramètres)  [throws exception1, exception2, ...]
{
     // Corps de la méthode.
}
    ... //Autres méthodes.
 

Modificateur (facultatif) : Les noms de classes, les attributs et les méthodes peuvent être précédés par des modificateurs. Les modificateurs utilisables dans les déclarations des classes, des attributs et des méthodes sont :
  1. Modificateurs de classe : pas de modificateur, public, abstract, final et static.
  2. Modificateurs d'accès aux attributs : pas de modificateurs, public, private, protected, final et static.
  3. Modificateurs d'accès aux méthodes : pas de modificateurs, public, private, protected, final, static, abstract et synchronized.
Les attributs et les méthodes peuvent être introduits dans un ordre quelconque, mais, il est préférable de placer les attributs avant les méthodes.
En java, les méthodes doivent être définis à l'intérieur de la classe :
  • Les méthodes d'instances, définies sans le modificateur static, ont accès à l'ensemble des membres ( attributs et méthodes), publics ou privés, de la même classe.
  • Les méthode de classe, définis à l'aide du modificateur static, ne peuvent accéder qu'à des membres static (attributs de classe et méthode de classe), publics ou privés, de la mêmes classe.
  • Les membres privés d'une classe sont inaccessibles de l’extérieur de la classe. Par contre, les membres publics de la classe sont accessibles de l’extérieur de la classe.
En Java, il est possible d'initialiser les attributs d'une classes au moment de leur déclaration.

L'opérateur new 
new est un opérateur unaire 'à un seul opérande), il permet de créer des objets (ou instances) d'une classe et de leur allouer de la mémoire.
La libération de la mémoire allouée, par l'opérateur new,  à des objets qui ne sont plus référencés est effectuée d'une manière automatique par garbage collector (ramasse miettes).

La syntaxe de cet opérateur est :
// Creation d'un objet de type NomDeClasse
new NomDeClasse(paramètres); 

/*Création  d'un objet tableau de n variables du type référence à des objets de la classe NomDeClasse. Les objets éléments du tableau ne seront pas créés, mais ces éléments seront tout simplement initialisés par null. */ 
new NomDeClasse[n]; 

/* Création d'un objet tableau de n éléments de type primitif TypePrimitif. Les éléments du tableau sont initialisés par 0 s'ils sont du type numérique, par \u0000 s'ils sont du type char ou par false s'ils sont du type boolean.*/
new TypePrimitif[n]; 
 Je vous invites à jeter l’œil sur la différence entre les types primitifs et les types de référence.

Après avoir réussi d'installer les outils nécessaires, vous pouvez maintenant programmer vos applications en Java, commençant par le fameux " Hello world ! ".

Alors lancez votre Eclipse IDE, sélectionnez le dossier qui va contenir vos projets, pour moi j'ai choisi le chemin C:\Users\OUIAME\Projet-Eclipse, comme il est indiqué dans la figure suivante.




Et voila maintenant nous somme dans notre fantastic Eclipse, une fenêtre s'affiche comme montre la figure suivante,


Nous avons plusieurs options à la main qu'on peut faire à partir de cette fenêtre dont on a pas besoin pour le moment, alors au revoir Welcome.

Avant de commencer à coder, il faut créer un projet qui va contenir des classes, interfaces... de votre application, ne laissez pas ça vous faire mal à l'aise, on va traiter tout ça étape par étape.
Il y a plusieurs façon de créer un nouveau projet :
  • Fichier -> Nouveau -> Projet
  • Utilisez le raccourcie clavier Alt+Shift+N
  • Dans la fenêtre de Explorateur Projet cliquez droit Nouveau -> Proje 

 Voila la fenêtre qui permet de créer un nouveau projet s'affiche,comme il est indiqué dans la figure suivante.

Choisissez Java Project puis cliquez sur suivant.



Remplissez le champ Nom de projet comme je l'ai fait par exemple " Hello World ", comme il est montré dans la figure ci dessus. Vous pouvez aussi voir où sera enregistré ce projet. Vous avez un environnement Java sur votre machine,mais dans le cas où vous en auriez plusieurs, vous pouvez aussi spécifier à Eclipse quel JRE utiliser pour ce projet. Maintenant cliquez su Terminer.

Ajoutez maintenant une nouvelle classe dans ce projet soit en cliquant sut le projet "clic droit" puis sur nouveau -> classe soit sur Fichier -> Nouveau -> Classe.Dans les deux cas vous devriez tomber une la fenêtre montrée dans la figure suivante :

Une classe est un ensemble de codes contenant plusieurs instructions que doit effectuer votre programme. N’hésitez pas à jeter l’œil sur les classes en Java.



Dans le premier encadré, nous pouvons voir où seront enregistrés nos fichiers Java. Dans le deuxième, nommez votre classe Java; moi, j'ai choisi Dwj. Dans le troisième, Eclipse vous demande si cette classe a quelque chose de particulier. Eh bien oui! Cochez Public static vois main(String[] args), puis cliquez sur Finish.
* Public static void main(String[] args) : Une classe java doit contenir une méthode appelée main : ce sera le point de démarrage de notre programme.
En général une méthode, en Java, est une suite d'instructions à exécuter.C'est un morceau de logique de notre programme. Une méthode contient:
  • un en-tête : celui-ci va être en quelque sorte la carte d'identité de la méthode;
  • un corps : le contenu de la méthode, délimité par des accolades;
  • une valeur de retour : le résultat que la méthode va retourner.
 Avant de commencer à coder, nous allons explorer l'espace de travail (Figure suivante). Dans l'encadré de gauche, vous trouverez le dossier de votre projet ainsi que son contenu. Ici, vous pourrez gérer votre projet comme bon vous semble (ajout, suppression...).
Dans l'encadré positionné au centre, je pense que vous avaez deviné : c'est ici que nous allons écrire nos code source.
Dans l'encadré du bas, c'est là que vous verrez apparaître le résultat de vos programmes ainsi que les erreurs éventuelles !
Et pour finir, c'est dans  l'encadré de droite, dès que nous aurons appris à coder nos propre fonctions et nos projets, que la liste des méthodes et des variables sera affichée.


Maintenant on va s’intéresse a l'encadré positionné au centre là où vous voyez la fameuse classe dont je vous parlais? Ici, elle s'appelle "Dwj1", comme vous voyez le nom de la classe doit commencer par une lettre majuscule, c'est pas obligé mais c mieux pour différencier les classes et les objets des ces classes.
Vous pouvez voir que le mot class est précédé du mot public, dont nous verrons la signification lorsque nous programmerons des objets.

Pour le moment, ce que vous devez retenir, c'est que votre classes es définie par un mot clé (class), qu'elle a un nom (ici, Dwj1) et que son contenu es délimité par des accolades ({}).

Nous écrivons nos codes sources entre la méthode main. La signature de cette méthode se présente toujours sous la forme suivante :
public  static  void  main(String[]  args)
{
         //Corps de la méthode.
}
  • public : signifie que la méthode main doit être accessible depuis les autres classes.
  • static : indique que main est une méthode de classe.
  • void : signifie que la méthode main ne retourne pas de valeur (il s'agit d'une procédure).
La méthode main admet un paramètre, qui est un tableau de chaîne de caractères. Ce paramètre est utilisé pour les arguments de la ligne de commande du programme.

Hello World ! 

Maintenant, essayons de taper le code suivant :
public  static  void  main(String[]  args)
{
         System.out.print("Hello World !");
}
System est une classe contenue dans le package java.lang, elle sert à accéder au comportement de niveau système de Java indépendamment de la plate-forme utilisé. La classe System contient trois objets variables de classe :
  1. err : représente le flux de sortie standard d'erreur, il correspond à l'écran;
  2. in : représente le flux d'entrée stantard. Par défaut, il correspond au clavier;
  3. out : représente le flux de sortie standard. Par défaut, il correspond à l'écran.
Alors une fois que vous avez saisi cette ligne de code dans votre méthode main, il vous faut lancer le programme. Vous devez cliquer sur la flèche blanche dans un rond vert (Figure suivante).


Si vous regarder dans votre console, dans la fenêtre du bas sous Eclipse, vous devriez voir la figure suivante



El voila le fameux Hello World !

A PROPOS

Débutants en Java ! Retrouvez ici la liste de tous les tutoriels, pour apprendre à programmer en Java étape par étape.

Contact us

Nom

E-mail *

Message *