Différences entre versions de « Java »

De Didaquest
Aller à la navigationAller à la recherche
 
(93 versions intermédiaires par le même utilisateur non affichées)
Ligne 6 : Ligne 6 :
 
==Java et la programmation orientée objet==
 
==Java et la programmation orientée objet==
 
La programmation orientée-objet (introduite par le langage '''SmallTalk''') propose une méthodologie centrée sur les données. Le programmeur Java va d’abord identifier un ensemble d’objets, tel que chaque objet représente un élément qui doit être utilisé ou manipulé par le programme, sous la forme d’ensembles de données. Ce n’est que dans un deuxième temps, que le programmeur va écrire les traitements, en associant chaque traitement à un objet donné. Un objet peut être vu comme une entité regroupant un ensemble de données et de méthodes de traitement.
 
La programmation orientée-objet (introduite par le langage '''SmallTalk''') propose une méthodologie centrée sur les données. Le programmeur Java va d’abord identifier un ensemble d’objets, tel que chaque objet représente un élément qui doit être utilisé ou manipulé par le programme, sous la forme d’ensembles de données. Ce n’est que dans un deuxième temps, que le programmeur va écrire les traitements, en associant chaque traitement à un objet donné. Un objet peut être vu comme une entité regroupant un ensemble de données et de méthodes de traitement.
 +
 +
===Classe===
 +
C’est une description d’un ensemble d’objets ayant '''les mêmes ATTRIBUTS et les mêmes METHODES'''.
 +
''Exemples: la classe ARTICLE, la classe POINT''
 +
====Encapsulation====
 +
Lors de la conception d’un programme orienté objet, le programmeur doit identifier les objets et les données appartenant à chaque objet mais aussi des droits d’accès qu’ont les autres objets sur ces données. L’encapsulation de données dans un objet permet de cacher ou non leur existence aux autres objets du programme. Une donnée peut être déclarée en accès :<br/>
 +
✓ public: propriétés visibles et accessibles à l’extérieur de la classe.<br/>
 +
✓ private: propriétés visibles et accessibles uniquement à l’intérieur de la classe.<br/>
 +
✓ protected: propriétés visibles et accessibles à l’intérieur de la classe, dans les sous-classes et dans les classes du même package.<br/>
 +
✓ Par défaut: propriétés visibles et accessibles à l’intérieur de la classe et dans les classes du même package.<br/>
 +
 +
====Constructeur====
 +
Chaque classe doit définir une ou plusieurs méthodes particulières appelées des constructeurs. Un constructeur est une méthode invoquée lors de la création d’un objet. Cette méthode, qui peut être vide, effectué les opérations nécessaires à l’initialisation d’un objet. Chaque constructeur doit avoir le même nom que la classe où il est défini et n’a aucune valeur de retour (c’est l’objet créé qui est renvoyé).
 
===Objet===
 
===Objet===
 
Dans un modèle orienté objet, toute entité du monde réel est un '''objet'''.  
 
Dans un modèle orienté objet, toute entité du monde réel est un '''objet'''.  
Ligne 12 : Ligne 25 :
 
'''Un Comportement''' : Opérations implémentées à l’aide de fonctions ou procédures appelées METHODES.  
 
'''Un Comportement''' : Opérations implémentées à l’aide de fonctions ou procédures appelées METHODES.  
 
''Exemples:  ARTICLE (Article en stock), POINT (point dans un plan)''
 
''Exemples:  ARTICLE (Article en stock), POINT (point dans un plan)''
−
===Classe===
+
 
−
C’est une description d’un ensemble d’objets ayant '''les mêmes ATTRIBUTS et les mêmes METHODES'''.
 
−
''Exemples: la classe ARTICLE, la classe POINT''
 
 
= Syntaxe du langage=
 
= Syntaxe du langage=
 
==Types de données==
 
==Types de données==
 
===Types simples===
 
===Types simples===
−
[[S12 Typedonnee.png|center|200:300]]
+
Les types de donnée de base en Java sont :<br/><br/>
 +
'''boolean''' : un booléen (d'ordre 2 en réalité) qui ne pourra prendre que les valeurs true ou false.<br/>
 +
✓ '''byte''' : un entier relatif très court (entre -128 et 127).<br/>
 +
✓ '''short''' : un entier relatif court (entre -32 768 et 32 767).<br/>
 +
✓ '''int''' : un entier relatif (entre -2 147 483 648 et 2 147 483 647).<br/>
 +
✓ '''long''' : un entier relatif long (entre -9 223 372 036 854 775 808 et 9 223 372 036 854 775 807).<br/>
 +
✓ '''float''' : un nombre décimal.<br/>
 +
✓ '''double''' : un nombre décimal à double précision.<br/>
 +
✓ '''char''' : un caractère.<br/>
 +
✓ '''String''' : une chaine de caractère.<br/>
 +
''Exemple :''<br/>
 +
int a=4;
 +
float b=5.2;
 +
String ch='Bonjour';
 +
 
 +
=== Tableaux et matrices===
 +
Un tableau a toujours une taille fixe qui doit être précisée avant l’affectation de valeurs à ses indices, de la manière suivante :<br/>
 +
''Exemple :  '' pour déclarer un tableau de 20 entiers<br/>
 +
int[] mon_tableau = new int[20];
 +
==Les opérateurs==
 +
[[Fichier:S12_operateurs.jpg|center]]
 +
==Structures de contrôle==
 +
===Structures conditionnelles===
 +
'''Syntaxe :'''<br/>
 +
if (<condition>) <bloc1> [else <bloc2>] <br/>
 +
ou <br/>
 +
<condition>?<instruction1>:<instruction2><br/>
 +
<condition> doit renvoyer une valeur booléenne. Si celle-ci est vraie c’est <bloc1> (resp. <instruction1>) qui est exécuté sinon <bloc2> (resp. <instruction2>) est exécuté. La partie else <bloc2>est facultative.<br/>
 +
''Exemple :''<br/>
 +
if (a == b) <br/>
 +
{ a = 50; b = 0;}<br/>
 +
else{a = a - 1;}
 +
 
 +
===Structures itératives===
 +
====Structure itérative complète====
 +
'''Syntaxe :''' <br/>
 +
for (<init>;<condition>;<instr_post_itération>) <bloc><br/>
 +
''Exemple:''<br/>
 +
int s=0;<br/>
 +
for (int i = 0, i<20;i++)<br/>
 +
{ s=s+i;}
 +
 
 +
====Structure itérative à condition d'arrêt====
 +
=====TantQue...Faire... =====
 +
'''Syntaxe :''' <br/>
 +
while (<condition>) <bloc><br/>
 +
''Exemple:''<br/>
 +
while (a != b) a++;
  
−
= {{Widget:Definition-Fiche}} =
+
=====Faire...TantQue...=====
 +
'''Syntaxe :'''
 +
do <bloc> while (<condition>);<br/>
 +
''Exemple:''<br/>
 +
do a++ while (a != b);
  
−
== {{Widget:Disciplines-Fiche}} ==
+
=Héritage=
−
<!--************************* Début Fiche-Disciplines-Thématiques *************************************-->
+
L’idée principale de l’héritage est d’organiser les classes de manière hiérarchique. La relation d’héritage est unidirectionnelle et, si une classe B hérite d’une classe A, on dira que B est une sous classe de A. Cette notion de sous-classe signifie que la classe B est un cas particulier de la classe A et donc que les objets instanciant la classe B instancient également la classe A.<br/>
−
{{Fiche-Disciplines-Thématiques <!----------------------------------------------------------------------->
+
Prenons comme exemple des classes Carre, Rectangle et Cercle. La figure ci-dessous propose une organisation hiérarchique de ces classes telle que Carre hérite de Rectangle qui hérite, ainsi que Cercle, d’une classe Forme.<br/>
−
<!--Indiquez le(s) Domaine(s) ou Discipline(s) ou Thématique(s) en relation avec le concept principale -->
+
[[Fichier:S12 heritage.jpg|center]]
−
<!--Complétez, Supprimez ou Ajoutez des lignes (jusqu'à 50), Exemples: Mathématique, Economie, Biologie-->
+
'''Syntaxe:''' <br/>
−
<!--****************** Commercez les modifications: Fiche-Disciplines-Thématiques *********************-->
+
L’héritage est mis en œuvre à l’aide du mot clé '''extends:'''<br/>
 +
class NomSousClasse extends NomSuperClasse
 +
==Redéfinition==
 +
L’héritage intégral des attributs de la classe Rectangle pose deux problèmes : Il faut que chaque carré ait une longueur et une largeur égales ; . La méthode affiche écrit le mot “rectangle” en début de chaîne. Il serait souhaitable que ce soit “carré” qui s’affiche. De plus, les constructeurs ne sont pas hérités par une sous classe. Il faut donc écrire un constructeur spécifique pour Carre. Ceci nous permettra de résoudre le premier problème en écrivant un constructeur qui ne prend qu’un paramètre qui sera affecté à la longueur et à la largeur. Pour attribuer une valeur à ces variables (qui sont privées), le constructeur de Carre doit faire appel au constructeur de Rectangle en utilisant le mot-clé super qui fait appel au constructeur de la classe supérieure comme suit :<br/>
 +
public Carre(int cote) { super(cote,cote); }
  
−
|Domaine-Discipline-Thématique-1= .......                         
+
==Polymorphisme==
−
|Domaine-Discipline-Thématique-2= .......
+
Le polymorphisme est la capacité d’une même opération à pouvoir s’appliquer sur des objets différents d’une même hiérarchie de classes et à pouvoir déclencher des traitements différents, selon la nature de l’objet en question.<br/>
−
|Domaine-Discipline-Thématique-3= .......
+
❖On dit alors que cette opération est polymorphe.<br/>
−
|Domaine-Discipline-Thématique-4=
+
❖La gestion du polymorphisme est assurée par la machine virtuelle de façon dynamique lors de l’exécution du programme;<br/>
−
|Domaine-Discipline-Thématique-5=
+
==Classe abstraite==
−
|Domaine-Discipline-Thématique-6=
+
Soit la classe Forme représentant les formes géométriques. Chaque catégorie de forme géométrique (Carré, Cercle, Rectangle, Triangle, …) peut être représentée par une sous classe de cette classe mère. Toutes ces formes possèdent une surface calculable, donc une méthode Surface () est commune à toutes les sous-classes, sauf que chacune de ces formes possède une manière spécifique pour calculer sa surface. D’où, l’action Surface () n’a pas vraiment de sens au niveau de la classe mère : c’est une notion abstraite qui sera précisée concrètement au niveau de chaque sous-classe.<br/>
−
|Domaine-Discipline-Thématique-7=
+
❖Méthode Abstraite: une méthode déclarée à l’aide du mot clé abstract à l’intérieur d’une super-classe:<br/>
−
|Domaine-Discipline-Thématique-8=
+
      ➢ n’a pas d’implémentation (juste une entête de méthode)<br/>
−
|Domaine-Discipline-Thématique-9=
+
      ➢ n’est pas exécutable<br/>
−
|Domaine-Discipline-Thématique-10=
+
      ➢ Doit être redéfinie dans les classes filles.<br/>
 +
❖Classe Abstraite: une classe  contenant au moins une méthode abstraite.<br/>
 +
      ➢ Ne peut pas être instanciée.<br/>
 +
      ➢ seules les sous-classes qui redéfinissent toutes les méthodes abstraites de leur classe mère sont instanciables. <br/>
 +
Une classe abstraite ne peut pas être instanciée directement : seule une sous-classe qui redéfinit obligatoirement toutes les méthodes abstraites de la classe mère peut être instanciée.<br/>
 +
Une sous-classe qui redéfinit toutes les méthodes abstraites de la super-classe, sauf une (ou quelques unes), ne pourra pas non plus être instanciée et subit la même règle que sa super-classe : elle contient au moins une méthode abstraite → elle-même sera une classe abstraite à déclarer avec le mot clé abstract.<br/>
 +
=Gestion des entrées/sorties simples=
 +
==Flux d’entrée==
 +
Un flux d’entrée est une instance d’une sous-classe de '''InputStream'''. Chaque classe de flux d’entrée a son propre mode d’échange de données qui spécifie un format particulier de données ou un accès particulier. Les classes les plus couramment utilisées sont :<br/>
 +
●'''ByteArrayInputStream''' : permet de lire le flux d’entrée sous la forme d’octets(byte).<br/>
 +
●'''DataInputStream''' : permet de lire le flux d’entrée sous la forme de types de données primitifs de Java. Il existe des méthodes pour récupérer un entier, un réel, un caractère,…<br/>
 +
● '''FileInputStream''' : est utilisé pour lire le contenu d’un fichier. Les objets de cette classe sont souvent encapsulés dans un autre objet de classe '''InputStream''' qui définit le format des données à lire.<br/>
 +
● '''ObjectInputStream''' : permet de lire des objets (c-à-d des instances de classes Java)à partir du flux d’entrée, si ces objets implémentent les interfaces '''java.io.Serializable''' ou '''java.io.Externalizable'''.<br/>
 +
● '''Reader''' :  n’est pas une sous-classe de '''InputStream''' mais représente un flux d’entrée pour chaînes de caractères. Plusieurs sous-classes de '''Reader''' permettent la création de flux pour chaînes de caractères.<br/>
 +
● '''Scanner''' : n’est pas une sous-classe de '''InputStream''', mais un '''Iterator''' qui permet de lire un flux (fichier ou chaîne de caractères par exemple) “mot” par “mot” en définissant le délimiteur entre les mots.<br/>
  
−
}}<!--****************** Fin modifications: Fiche-Disciplines-Thématiques *****************************-->
+
=== Lecture des entrées clavier===
 +
Les données provenant de l’utilisation du clavier sont transmises dans un flux d’entrée créé automatiquement pour toute application Java. On accède à ce flux par la variable statique de la '''classejava.lang.System''' qui s’appelle in. Ce flux est alors utilisé comme paramètre d’entrée du constructeur d’un autre flux d’entrée. Pour cet autre flux, on utilise généralement une sous-classe de '''Reader''' pour récupérer les entrées de l’utilisateur sous la forme d’une chaîne de caractères.
  
−
== {{Widget:Definition-ecrite-Fiche}} ==
+
===Lecture à partir d’un fichier===
 +
Un fichier est représenté par un objet de la classe '''java.io.File'''. Le constructeur de cette classe prend en paramètre d’entrée le chemin d’accès du fichier. Le flux d’entrée est alors créé à l’aide de la classe '''FileInputStream''' sur lequel on peut lire caractère par caractère grâce à la méthode '''read()'''.
  
 +
===Lecture d’objets enregistrés===
 +
Il est parfois utile d’enregistrer l’état d’objet (de n’importe quelle classe implémentant les interfaces '''java.io.Serializableoujava.io.Externalizable''') pour des exécutions futures. Le flux d’entrée est encore créé à l’aide de la classe '''FileInputStream''' et est ensuite encapsulé dans un autre flux spécifiant le format des données à lire.
  
−
<!-- ******** Début Fiche Didactique Definition ********************-->
+
== Flux de sortie==
−
{{Fiche Didactique Definition <!-------------------------------------->
+
===Écriture sur la sortie standard “écran”===
−
<!-- Définition : Donner une ou plusieurs définition (s)            -->
+
Comme pour les entrées du clavier, l’écriture vers l’écran fait appel à la variable '''statiqueo'''ut de la classe '''System'''. On appelle généralement la méthode '''System.out.print''' ou '''System.out.println'''.
−
<!-- Compléter les pointillés et Supprimer les lignes non utilisées -->
 
−
|Définition= <!-- Ne pas Modifier  -->
 
−
<!-- *************** Commercez les modifications *******************-->
 
  
−
*cc......................................................................
+
===Écriture dans un fichier===
−
.......................................................................
+
L’écriture dans un fichier se fait par un flux de la classe '''FileOutputStream''' qui prend en entrée un fichier (instance de la classe '''File'''). Ce flux de sortie permet d’écrire des caractères dans le fichier grâce à la méthode '''write()'''.
−
.......................................................................
 
−
.......................................................................
 
−
*......................................................................
 
−
.......................................................................
 
−
.......................................................................
 
  
−
<!-- ******** Fin Définition Générale ***************************** -->
+
===Écriture d’objets===
−
<!-- ************* Début Définition Approfondissement ************* -->
+
Le flux de sortie peut également être encapsulé dans un flux de type '''ObjectOutputStream'''.
−
<!-- Approfondissement des définitions à travers des classifications, des catégorisations, des typologies, ou autre.... -->
 
−
|Typologie= <!------------------------------------ Ne pas Modifier  -->
 
−
<!-- ****************** Commercez les modifications ****************-->
 
−
*......................................................................
 
−
.......................................................................
 
−
.......................................................................
 
−
.......................................................................
 
−
*......................................................................
 
−
.......................................................................
 
−
.......................................................................
 
−
}}<!-- ******** Fin Fiche Didactique Définition ******************* -->
 
  
−
== {{Widget:Definition-graphique-Fiche}} ==
+
= {{Widget:Definition-graphique-Fiche}} =
  
 
<!-- ************************* Début ****************************** -->
 
<!-- ************************* Début ****************************** -->
Ligne 86 : Ligne 151 :
  
 
<!-- Remplacez, Adaptez, Ajoutez ou Supprimez les images et lignes non utilisées-->
 
<!-- Remplacez, Adaptez, Ajoutez ou Supprimez les images et lignes non utilisées-->
−
S12_GI_img1.jpeg|JAVA
+
Image:S12_GI_img1.jpeg|Langage JAVA
−
S12_netbean-windows.jpg|Netbeans
+
Image:S12 netbean-windows.jpg|Netbeans
−
S12_jdk.png|JDK
+
Image:S12 jdk.png|JDK
  
  
Ligne 99 : Ligne 164 :
 
<!--Ajoutez ou supprimez les lignes non utilisées --------------------------------------------------------------------------->
 
<!--Ajoutez ou supprimez les lignes non utilisées --------------------------------------------------------------------------->
 
<!-- ****************** Commercez les modifications pour les Vidéos *******************************************************-->
 
<!-- ****************** Commercez les modifications pour les Vidéos *******************************************************-->
−
<youtube width="220" height="220">XgVADKKb4jI</youtube>
+
<youtube width="250" height="250">XgVADKKb4jI</youtube>
−
<youtube width="220" height="220">SvPGiy5UXRI</youtube>
+
<youtube width="250" height="250">SvPGiy5UXRI</youtube>
−
<youtube width="220" height="220">BMpLLJtt2ys</youtube>
+
<youtube width="250" height="250">BMpLLJtt2ys</youtube>
−
<youtube width="220" height="220">rvjAPI89QnE</youtube>
+
<youtube width="250" height="250">rvjAPI89QnE</youtube>
 +
<youtube width="250" height="250">oHOXE9h3t_A</youtube>
 +
<youtube width="250" height="250">rJx9Q-aYuAA</youtube>
 +
 
 +
 
 +
 
  
  
Ligne 139 : Ligne 209 :
 
<!-- Compléter les pointillés et Supprimer les lignes non utilisées          -->
 
<!-- Compléter les pointillés et Supprimer les lignes non utilisées          -->
 
<!-- ****************** Commercez les modifications ***********************  -->
 
<!-- ****************** Commercez les modifications ***********************  -->
 +
{{@}} '''Domaine d'applications:'''<br/>
 +
Sun fournit un grand nombre de frameworks et d’API afin de permettre l’utilisation de Java pour des usages très diversifiés.
 +
On distingue essentiellement quatre grands frameworks :
 +
 +
    * Java SE (anciennement J2SE) : Ce framework est destiné aux applications pour poste de travail ;
 +
    * Java EE (anciennement J2EE) : Ce framework est spécialisé dans les applications serveurs. Il contient pour ce faire un grand nombre d’API et d’extensions ;
 +
    * Java ME (anciennement J2ME) : Ce framework est spécialisé dans les applications mobiles ;
 +
    * JavaFX (à ne pas confondre avec JavaFX) : Ce framework est spécialisé dans les applications liées aux cartes à puces et autres SmartCards.
 +
{{@}}'''Outils de développement'''<br/>
 +
La programmation peut se faire depuis une invite de commande en lançant un compilateur Java (souvent nommé javac), mais pour avoir plus de confort, il est préférable d’utiliser un environnement de développement intégré ou IDE (qui permet de compiler automatiquement), certains sont gratuits. Par exemple :
 +
    * NetBeans
 +
    * BlueJ
 +
    * CodeWarrior
 +
    * Eclipse
 +
    * JBuilder
 +
    * JCreator
 +
    * jDeveloper
 +
   
 +
  
−
*...............................................................................
 
−
................................................................................
 
−
................................................................................
 
−
................................................................................
 
−
*...............................................................................
 
−
................................................................................
 
−
................................................................................
 
−
................................................................................
 
 
}}<!--************** Fin Fiche Didactique Explicitations ******************* -->
 
}}<!--************** Fin Fiche Didactique Explicitations ******************* -->
−
 
  
 
= {{Widget:Erreurs-confusions-Fiche}} =
 
= {{Widget:Erreurs-confusions-Fiche}} =
Ligne 162 : Ligne 242 :
  
 
* Confusion entre [[Objet et Classe]]
 
* Confusion entre [[Objet et Classe]]
−
* Confusion entre [[Java et Javascript]]
+
* Confusion entre [[JavaScript et Java]]
−
* Erreur fréquente: ....................
+
* Confusion entre polymorphisme et héritage  [[Polymorphisme et Héritage]]
 +
 
  
 
}}<!-- ************** Fin Fiche Didactique Conceptions ********************* -->
 
}}<!-- ************** Fin Fiche Didactique Conceptions ********************* -->
Ligne 176 : Ligne 257 :
 
<!-- ************ Commercez les modifications *********************-->
 
<!-- ************ Commercez les modifications *********************-->
  
−
* [[.................. ?]]
+
* [[Quels sont les IDE les plus utilisés pour JAVA ?]]
−
* [[.................. ?]]
+
* [[Quelle est la particularité de Java 8?]]
−
* [[.................. ?]]
+
* [[C'est quoi la redéfintion de Méthodes ?]]
 +
* [[C'est quoi la surcharge des méthodes ?]]
  
 
}}<!-- ******** Fin Fiche Didactique Questions ******************* -->
 
}}<!-- ******** Fin Fiche Didactique Questions ******************* -->
−
 
  
 
= {{Widget:Liens-enseignement-Fiche}} =
 
= {{Widget:Liens-enseignement-Fiche}} =
Ligne 195 : Ligne 276 :
 
<!-- ****************** Commercez les modifications **************************  -->
 
<!-- ****************** Commercez les modifications **************************  -->
  
−
* ..................                                               
+
* Utiliser le même exemple durant tous le cours:                                           
−
:* .................
+
:* Il est préférable d'utiliser un exemple simple pour expliquer les différents parties du cours( ''l'exemple du '''point''' est le plus simple'') 
−
* ..................                                               
+
                                         
−
:* .................                                               
 
  
 
}}<!-- ************************* Fin Idées-Enseignement ********************** -->
 
}}<!-- ************************* Fin Idées-Enseignement ********************** -->
−
 
  
 
== {{Widget:Aides et astuces-Fiche}} ==
 
== {{Widget:Aides et astuces-Fiche}} ==
Ligne 211 : Ligne 290 :
 
<!-- Complétez les pointillés et Supprimez les lignes non utilisées          ----->
 
<!-- Complétez les pointillés et Supprimez les lignes non utilisées          ----->
 
<!-- ****************** Commercez les modifications **************************  -->
 
<!-- ****************** Commercez les modifications **************************  -->
−
 
+
* '''Pour introduire la notion du boucle :'''                                               
−
* ..................                                                  
+
:* on peut demander au élèves qui ont un niveau cognitif faible d'utiliser Scratch
−
:* .................
+
* '''Utilisation de Netbeans :'''                                                  
−
* ..................                                                  
+
:* http://cours.thirion.free.fr/Cours/Java-Premieres-Notions/Pdf/Notice-NetBeans.pdf
−
:* .................                                               
+
* '''Installation du JDK.'''                                                  
 +
:* http://monalisa.cern.ch/MONALISA/download/java/                                               
  
 
}}<!-- ************************* Fin Astuces-Enseignement ********************** -->
 
}}<!-- ************************* Fin Astuces-Enseignement ********************** -->
Ligne 227 : Ligne 307 :
 
<!-- ****************** Commercez les modifications ************-->
 
<!-- ****************** Commercez les modifications ************-->
  
−
:* ..................
+
:* https://fr.coursera.org/learn/initiation-programmation-java
−
:* ..................
+
:* https://www.udemy.com/course/cours-complet-de-programmation-java-pour-debutants/
−
:* ..................
+
:* https://www.fun-mooc.fr/cours/#filter/subject/programmation?page=1&rpp=50
  
 
}}<!-- ************ Fin Liens Education ********************** -->
 
}}<!-- ************ Fin Liens Education ********************** -->
Ligne 243 : Ligne 323 :
 
<!-- ****************** Commercez les modifications *********************-->
 
<!-- ****************** Commercez les modifications *********************-->
  
−
* ..................                                               
+
* https://www.java.com/fr/                                             
−
* ..................
+
* https://www.ukonline.be/
−
* ..................                                                  
+
* https://fr.wikiversity.org                                                  
−
* ..................                                                  
+
* https://www.editions-eni.fr                                                  
  
 
}}<!-- ************* Fin Fiche Didactique Bibliographie *************** -->
 
}}<!-- ************* Fin Fiche Didactique Bibliographie *************** -->
  
 
{{Widget:Fiche-Conceptuelle-Bas}}
 
{{Widget:Fiche-Conceptuelle-Bas}}

Version actuelle datée du 1 juin 2020 à 01:03


Autres Fiches Conceptuelles
Posez une Question


(+)

Target Icon.pngVotre Publicité sur le Réseau Target Icon.png

Introduction: Le langage JAVA

Présentation

Java est une technologie composée d’un langage de programmation orient objet et d’un environnement d’exécution. Préalablement nomme Oak, il a été créé par James Gosling et Patrick Naughton chez Sun Microsystems avec le soutien de Bill Joy. Le langage Java fut officiellement présent le 23 mai 1995 au SunWorld. Java est à la fois un langage de programmation et une plateforme d’exécution. Le langage Java a la particularité principale d’être portable sur plusieurs systèmes d’exploitation tels que Windows, MacOS ou Linux. C’est la plateforme qui garantit la portabilité des applications développées en Java.

Java et la programmation orientée objet

La programmation orientée-objet (introduite par le langage SmallTalk) propose une méthodologie centrée sur les données. Le programmeur Java va d’abord identifier un ensemble d’objets, tel que chaque objet représente un élément qui doit être utilisé ou manipulé par le programme, sous la forme d’ensembles de données. Ce n’est que dans un deuxième temps, que le programmeur va écrire les traitements, en associant chaque traitement à un objet donné. Un objet peut être vu comme une entité regroupant un ensemble de données et de méthodes de traitement.

Classe

C’est une description d’un ensemble d’objets ayant les mêmes ATTRIBUTS et les mêmes METHODES. Exemples: la classe ARTICLE, la classe POINT

Encapsulation

Lors de la conception d’un programme orienté objet, le programmeur doit identifier les objets et les données appartenant à chaque objet mais aussi des droits d’accès qu’ont les autres objets sur ces données. L’encapsulation de données dans un objet permet de cacher ou non leur existence aux autres objets du programme. Une donnée peut être déclarée en accès :
✓ public: propriétés visibles et accessibles à l’extérieur de la classe.
✓ private: propriétés visibles et accessibles uniquement à l’intérieur de la classe.
✓ protected: propriétés visibles et accessibles à l’intérieur de la classe, dans les sous-classes et dans les classes du même package.
✓ Par défaut: propriétés visibles et accessibles à l’intérieur de la classe et dans les classes du même package.

Constructeur

Chaque classe doit définir une ou plusieurs méthodes particulières appelées des constructeurs. Un constructeur est une méthode invoquée lors de la création d’un objet. Cette méthode, qui peut être vide, effectué les opérations nécessaires à l’initialisation d’un objet. Chaque constructeur doit avoir le même nom que la classe où il est défini et n’a aucune valeur de retour (c’est l’objet créé qui est renvoyé).

Objet

Dans un modèle orienté objet, toute entité du monde réel est un objet. Un objet est caractérisé par : Un état : Données stockées dans des champs appelés ATTRIBUTS. Un Comportement : Opérations implémentées à l’aide de fonctions ou procédures appelées METHODES. Exemples: ARTICLE (Article en stock), POINT (point dans un plan)

Syntaxe du langage

Types de données

Types simples

Les types de donnée de base en Java sont :

boolean : un booléen (d'ordre 2 en réalité) qui ne pourra prendre que les valeurs true ou false.
✓ byte : un entier relatif très court (entre -128 et 127).
✓ short : un entier relatif court (entre -32 768 et 32 767).
✓ int : un entier relatif (entre -2 147 483 648 et 2 147 483 647).
✓ long : un entier relatif long (entre -9 223 372 036 854 775 808 et 9 223 372 036 854 775 807).
✓ float : un nombre décimal.
✓ double : un nombre décimal à double précision.
✓ char : un caractère.
✓ String : une chaine de caractère.
Exemple :
int a=4; float b=5.2; String ch='Bonjour';

Tableaux et matrices

Un tableau a toujours une taille fixe qui doit être précisée avant l’affectation de valeurs à ses indices, de la manière suivante :
Exemple : pour déclarer un tableau de 20 entiers
int[] mon_tableau = new int[20];

Les opérateurs

S12 operateurs.jpg

Structures de contrôle

Structures conditionnelles

Syntaxe :
if (<condition>) <bloc1> [else <bloc2>]
ou
<condition>?<instruction1>:<instruction2>
<condition> doit renvoyer une valeur booléenne. Si celle-ci est vraie c’est <bloc1> (resp. <instruction1>) qui est exécuté sinon <bloc2> (resp. <instruction2>) est exécuté. La partie else <bloc2>est facultative.
Exemple :
if (a == b)
{ a = 50; b = 0;}
else{a = a - 1;}

Structures itératives

Structure itérative complète

Syntaxe :
for (<init>;<condition>;<instr_post_itération>) <bloc>
Exemple:
int s=0;
for (int i = 0, i<20;i++)
{ s=s+i;}

Structure itérative à condition d'arrêt

TantQue...Faire...

Syntaxe :
while (<condition>) <bloc>
Exemple:
while (a != b) a++;

Faire...TantQue...

Syntaxe : do <bloc> while (<condition>);
Exemple:
do a++ while (a != b);

Héritage

L’idée principale de l’héritage est d’organiser les classes de manière hiérarchique. La relation d’héritage est unidirectionnelle et, si une classe B hérite d’une classe A, on dira que B est une sous classe de A. Cette notion de sous-classe signifie que la classe B est un cas particulier de la classe A et donc que les objets instanciant la classe B instancient également la classe A.
Prenons comme exemple des classes Carre, Rectangle et Cercle. La figure ci-dessous propose une organisation hiérarchique de ces classes telle que Carre hérite de Rectangle qui hérite, ainsi que Cercle, d’une classe Forme.

S12 heritage.jpg

Syntaxe:
L’héritage est mis en œuvre à l’aide du mot clé extends:
class NomSousClasse extends NomSuperClasse

Redéfinition

L’héritage intégral des attributs de la classe Rectangle pose deux problèmes : Il faut que chaque carré ait une longueur et une largeur égales ; . La méthode affiche écrit le mot “rectangle” en début de chaîne. Il serait souhaitable que ce soit “carré” qui s’affiche. De plus, les constructeurs ne sont pas hérités par une sous classe. Il faut donc écrire un constructeur spécifique pour Carre. Ceci nous permettra de résoudre le premier problème en écrivant un constructeur qui ne prend qu’un paramètre qui sera affecté à la longueur et à la largeur. Pour attribuer une valeur à ces variables (qui sont privées), le constructeur de Carre doit faire appel au constructeur de Rectangle en utilisant le mot-clé super qui fait appel au constructeur de la classe supérieure comme suit :
public Carre(int cote) { super(cote,cote); }

Polymorphisme

Le polymorphisme est la capacité d’une même opération à pouvoir s’appliquer sur des objets différents d’une même hiérarchie de classes et à pouvoir déclencher des traitements différents, selon la nature de l’objet en question.
❖On dit alors que cette opération est polymorphe.
❖La gestion du polymorphisme est assurée par la machine virtuelle de façon dynamique lors de l’exécution du programme;

Classe abstraite

Soit la classe Forme représentant les formes géométriques. Chaque catégorie de forme géométrique (Carré, Cercle, Rectangle, Triangle, …) peut être représentée par une sous classe de cette classe mère. Toutes ces formes possèdent une surface calculable, donc une méthode Surface () est commune à toutes les sous-classes, sauf que chacune de ces formes possède une manière spécifique pour calculer sa surface. D’où, l’action Surface () n’a pas vraiment de sens au niveau de la classe mère : c’est une notion abstraite qui sera précisée concrètement au niveau de chaque sous-classe.
❖Méthode Abstraite: une méthode déclarée à l’aide du mot clé abstract à l’intérieur d’une super-classe:

      ➢ n’a pas d’implémentation (juste une entête de méthode)

      ➢ n’est pas exécutable
 
      ➢ Doit être redéfinie dans les classes filles.

❖Classe Abstraite: une classe contenant au moins une méthode abstraite.

      ➢ Ne peut pas être instanciée.

      ➢ seules les sous-classes qui redéfinissent toutes les méthodes abstraites de leur classe mère sont instanciables.

Une classe abstraite ne peut pas être instanciée directement : seule une sous-classe qui redéfinit obligatoirement toutes les méthodes abstraites de la classe mère peut être instanciée.
Une sous-classe qui redéfinit toutes les méthodes abstraites de la super-classe, sauf une (ou quelques unes), ne pourra pas non plus être instanciée et subit la même règle que sa super-classe : elle contient au moins une méthode abstraite → elle-même sera une classe abstraite à déclarer avec le mot clé abstract.

Gestion des entrées/sorties simples

Flux d’entrée

Un flux d’entrée est une instance d’une sous-classe de InputStream. Chaque classe de flux d’entrée a son propre mode d’échange de données qui spécifie un format particulier de données ou un accès particulier. Les classes les plus couramment utilisées sont :
●ByteArrayInputStream : permet de lire le flux d’entrée sous la forme d’octets(byte).
●DataInputStream : permet de lire le flux d’entrée sous la forme de types de données primitifs de Java. Il existe des méthodes pour récupérer un entier, un réel, un caractère,…
● FileInputStream : est utilisé pour lire le contenu d’un fichier. Les objets de cette classe sont souvent encapsulés dans un autre objet de classe InputStream qui définit le format des données à lire.
● ObjectInputStream : permet de lire des objets (c-à-d des instances de classes Java)à partir du flux d’entrée, si ces objets implémentent les interfaces java.io.Serializable ou java.io.Externalizable.
● Reader : n’est pas une sous-classe de InputStream mais représente un flux d’entrée pour chaînes de caractères. Plusieurs sous-classes de Reader permettent la création de flux pour chaînes de caractères.
● Scanner : n’est pas une sous-classe de InputStream, mais un Iterator qui permet de lire un flux (fichier ou chaîne de caractères par exemple) “mot” par “mot” en définissant le délimiteur entre les mots.

Lecture des entrées clavier

Les données provenant de l’utilisation du clavier sont transmises dans un flux d’entrée créé automatiquement pour toute application Java. On accède à ce flux par la variable statique de la classejava.lang.System qui s’appelle in. Ce flux est alors utilisé comme paramètre d’entrée du constructeur d’un autre flux d’entrée. Pour cet autre flux, on utilise généralement une sous-classe de Reader pour récupérer les entrées de l’utilisateur sous la forme d’une chaîne de caractères.

Lecture à partir d’un fichier

Un fichier est représenté par un objet de la classe java.io.File. Le constructeur de cette classe prend en paramètre d’entrée le chemin d’accès du fichier. Le flux d’entrée est alors créé à l’aide de la classe FileInputStream sur lequel on peut lire caractère par caractère grâce à la méthode read().

Lecture d’objets enregistrés

Il est parfois utile d’enregistrer l’état d’objet (de n’importe quelle classe implémentant les interfaces java.io.Serializableoujava.io.Externalizable) pour des exécutions futures. Le flux d’entrée est encore créé à l’aide de la classe FileInputStream et est ensuite encapsulé dans un autre flux spécifiant le format des données à lire.

Flux de sortie

Écriture sur la sortie standard “écran”

Comme pour les entrées du clavier, l’écriture vers l’écran fait appel à la variable statiqueout de la classe System. On appelle généralement la méthode System.out.print ou System.out.println.

Écriture dans un fichier

L’écriture dans un fichier se fait par un flux de la classe FileOutputStream qui prend en entrée un fichier (instance de la classe File). Ce flux de sortie permet d’écrire des caractères dans le fichier grâce à la méthode write().

Écriture d’objets

Le flux de sortie peut également être encapsulé dans un flux de type ObjectOutputStream.

Définition graphique

Emblem-important-blue.svg

  • Langage JAVA

  • Netbeans

  • JDK


Emblem-important-blue.svg


Emblem-important-blue.svg

{{{AutresMedias}}}


Puce-didaquest.png Concepts ou notions associés

Emblem-important-blue.svg

(+)


More-didaquest.png Java - Glossaire / (+)



Puce-didaquest.png Exemples, applications, utilisations


Blue-circle-target.png Domaine d'applications:
Sun fournit un grand nombre de frameworks et d’API afin de permettre l’utilisation de Java pour des usages très diversifiés. On distingue essentiellement quatre grands frameworks : 

   * Java SE (anciennement J2SE) : Ce framework est destiné aux applications pour poste de travail ;
   * Java EE (anciennement J2EE) : Ce framework est spécialisé dans les applications serveurs. Il contient pour ce faire un grand nombre d’API et d’extensions ;
   * Java ME (anciennement J2ME) : Ce framework est spécialisé dans les applications mobiles ;
   * JavaFX (à ne pas confondre avec JavaFX) : Ce framework est spécialisé dans les applications liées aux cartes à puces et autres SmartCards.


Blue-circle-target.pngOutils de développement
La programmation peut se faire depuis une invite de commande en lançant un compilateur Java (souvent nommé javac), mais pour avoir plus de confort, il est préférable d’utiliser un environnement de développement intégré ou IDE (qui permet de compiler automatiquement), certains sont gratuits. Par exemple : 

   * NetBeans 
   * BlueJ 
   * CodeWarrior 
   * Eclipse 
   * JBuilder 
   * JCreator 
   * jDeveloper

(+)


Puce-didaquest.png Erreurs ou confusions éventuelles

Emblem-important-blue.svg

(+)



Puce-didaquest.png Questions possibles



Puce-didaquest.png Liaisons enseignements et programmes

Idées ou Réflexions liées à son enseignement

Emblem-important-blue.svg
  • Utiliser le même exemple durant tous le cours:
  • Il est préférable d'utiliser un exemple simple pour expliquer les différents parties du cours( l'exemple du point est le plus simple)

(+)



Aides et astuces

Emblem-important-blue.svg
  • Pour introduire la notion du boucle :
  • on peut demander au élèves qui ont un niveau cognitif faible d'utiliser Scratch
  • Utilisation de Netbeans :
  • Installation du JDK.



Education: Autres liens, sites ou portails




Puce-didaquest.png Bibliographie

Emblem-important-blue.svg

Pour citer cette page: ([1]) 

ABROUGUI, M & al, 2020. Java. In Didaquest [en ligne]. <http:www.didaquest.org/wiki/Java>, consulté le 24, novembre, 2024


Récupérée de « https://didaquest.org/w/index.php?title=Java&oldid=62421 »