La différence entre Java et C++

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++.

Continuer la lecture

L'héritage en Java

L'héritage permet à une classe d'hériter les attributs et les méthodes d'une autre classe. La classe héritée est appelée superclasse (ou classe parent) et la classe qui dérive par héritage d'une superclasse est appelée sous-classe ou classe dérivée (ou encore classe enfant).

Grâce à l'héritage, une classe peut disposer de toutes les fonctionnalités (attributs et méthodes) d'une classe existante, à laquelle on ajoute une nouvelle fonctionnalité, c'est-à-dire, de nouveaux attributs et de nouvelles méthodes permettant de spécialiser la sous-classe.

Une superclasse constitue un rassemblement (ou une factorisation) des fonctionnalités communes à plusieurs classes, ce qui permettra de les réutiliser, dans ces classes, en utilisant le principe d'héritage.

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

[modificateur] class NomDeSousClasse [extends NomDeSuperClasse] [implements interface1, inetrface2, ...]

{

// Attributs et méthodes de la classe.
...

}

Le mot clé extends (facultatif) signifie que l'on crée une nouvelle classe qui dérive par héritage d'une classe existante.
En Java, lorsqu'une déclaration d'une classe n'indique pas explicitement une superclasse à l'aide du mot clé extends, cette classe sera considérée comme une sous-classe de la classe Object.

 L'écriture: public class NomDeClasse

est équivalet à :

public classe NomDeclasse extends Object.

En Java, chaque classe ne peut posséder qu'une seule superclasse: héritage simple, mais une superclasse peut posséder plusieurs sous-classes.

Les classes Java sont organisées en une hiérarchie arborescente dont le sommet est la classe Object. Toute classe sauf Object possède une et une seule superclasse dont elle hérite.La classe Object est la superclasse de toutes les classes Java: Toutes les classes héritent de la classe Object.

A partir d'une sous-classe, il est possible d'accéder et d'utiliser tous les membres (attributs et méthodes) non privées de sa superclasse. Toutefois, les membres définis sans modificateur ne sont accessibles que par les classes et les sous-classes définies dans le package de la superclasse.

Par contre, la sous-classe n'a pas accès :

• Aux membres de la superclasse définis sans modificateur si le package de la sous-classe est différent de celui de la superclasse. Ces membres ne sont pas hérités par les sous-classes définies dans des packages différents de celui de la superclasse.
• Aux membres privés de sa superclasse, ces membres ne sont pas hérités par les sous-classes.

Cependant, si la superclasse possède des méthodes public ou protected qui accident à ces membres non hérités, ces méthodes peuvent être utilisées par une sous-classe pour accéder indirectement à ces membres non hérités qui sont en fait contenus dans les objets de cette sous-classe.

Si une superclasse est modifiée, cette modification se répercutera sur toutes ses sous-classes et sur toutes les sous-classes de ces sous-classes.

Si une classe est déclarée finale, elle ne peut pas être héritée(ou sous-classée) par une autre classe.

 

Continuer la lecture

L'encapsulation

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.

Continuer la lecture

Les concepts de la Programmation Orientée Objet

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.

Continuer la lecture

La Programmation Orientée Objet (P.O.O)

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 ;

Continuer la lecture

Les différents types de données en Java

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.

Continuer la lecture

Les classes en Java

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.

Continuer la lecture