{"id":49,"date":"2017-09-09T15:30:03","date_gmt":"2017-09-09T15:30:03","guid":{"rendered":"https:\/\/wp-systeme.lip6.fr\/potop-butucaru\/?p=49"},"modified":"2023-04-03T16:29:29","modified_gmt":"2023-04-03T16:29:29","slug":"java-et-poo","status":"publish","type":"post","link":"https:\/\/wp-systeme.lip6.fr\/potop-butucaru\/2017\/09\/09\/java-et-poo\/","title":{"rendered":"Java et POO"},"content":{"rendered":"<section>\n<h3>UE Java 2017-2018 :<\/h3>\n<ul>\n<li>8 S\u00e9ances Cours<\/li>\n<li>12 S\u00e9ances de TD\/TP<\/li>\n<li>Disponible en ligne sur <a href=\"https:\/\/pagesperso-systeme.lip6.fr\/Maria.Gradinariu\/spip.php?article\">Maria Potop-Butucaru<\/a><\/li>\n<\/ul>\n<\/section>\n<section>\n<h2>Plan de l&#8217;UE :<\/h2>\n<ul>\n<li>Introduction au Java et POO<\/li>\n<li>H\u00e9ritage et polymorphisme<\/li>\n<li>Fiabilit\u00e9 (exceptions, assertions)<\/li>\n<li>Entr\u00e9es\/Sorties (flux de donn\u00e9es, gestion de fichiers, s\u00e9rialisation,\u2026)<\/li>\n<li>Programmation r\u00e9seaux (sockets TCP\/UPD)<\/li>\n<li>Programmation concurrente (multi-threading, synchronisation, interruption)<\/li>\n<li>Programmation g\u00e9n\u00e9rique, collections et algorithmes<\/li>\n<li>Biblioth\u00e8que graphique (JavaFX)<\/li>\n<\/ul>\n<\/section>\n<section>\n<h2>Notation de l&#8217;UE<\/h2>\n<ul>\n<li>60% Examen final<\/li>\n<li>20% Travaux pratiques<\/li>\n<li>20% Mini-projet<\/li>\n<\/ul>\n<p>&nbsp;<\/p>\n<\/section>\n<section>\n<section class=\"toc-pause\">\n<h1>Le langage Java<\/h1>\n<\/section>\n<section>\n<h2>Le Langage <b>Java<\/b><\/h2>\n<p>Langage Orient\u00e9 Objet statiquement et fortement typ\u00e9.<\/p>\n<p><small>Fortement typ\u00e9: il n&#8217;y a pas de conversion implicite entre types.<br \/>\nStatiquement typ\u00e9: une variable poss\u00e8de un type d\u00e9termin\u00e9 \u00e0 la compilation.<\/small><\/p>\n<p>Il s&#8217;execute dans un environement d&#8217;execution (<b>J<\/b>ava<b>R<\/b>untime<b>E<\/b>nvironment)<\/p>\n<p><small>Une machine virtuelle<\/small><\/p>\n<\/section>\n<section>\n<h2>Histoire du <b>Java<\/b><\/h2>\n<p>Le JAVA a \u00e9t\u00e9 cr\u00e9\u00e9 en 1991 par des ing\u00e9nieurs de chez SUN (projet GREEN) pour des applications d\u00e9did\u00e9es aux syst\u00e8mes embarqu\u00e9s.<\/p>\n<p>Puis, il est utilis\u00e9 pour d\u00e9velopper un navigateur Web en 1995<\/p>\n<p><small>Ceci permet le developpement d&#8217;application Java s&#8217;executant dans le navigateur.<\/small><\/p>\n<\/section>\n<section>\n<h2>Histoire du <b>Java<\/b><\/h2>\n<p>D\u00e8s sa cr\u00e9ation, il a la particularit\u00e9 de s&#8217;ex\u00e9cuter dans une machine virtuelle.<\/p>\n<p>Une fois compil\u00e9, un programme Java peut s&#8217;ex\u00e9cuter dans n&#8217;importe quel environement <small>capable d&#8217;ex\u00e9cuter la machine virtuelle<\/small>.<\/p>\n<\/section>\n<section>\n<h3>Historique des versions<\/h3>\n<table>\n<tbody>\n<tr>\n<td>1.0<\/td>\n<td>1996<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>1.1<\/td>\n<td>1997<\/td>\n<td><small>S\u00e9rialisation, fichiers JAR, &#8230;<\/small><\/td>\n<\/tr>\n<tr>\n<td>1.2<\/td>\n<td>1998<\/td>\n<td><small>Collections, &#8230;<\/small><\/td>\n<\/tr>\n<tr>\n<td>1.3<\/td>\n<td>2000<\/td>\n<td><small>Nouvelle machine virtuelle<\/small><\/td>\n<\/tr>\n<tr>\n<td>1.4<\/td>\n<td>2002<\/td>\n<td><small>API I\/O, Regex, XML, assert<\/small><\/td>\n<\/tr>\n<tr>\n<td>5 (1.5)<\/td>\n<td>2004<\/td>\n<td><small>Types g\u00e9n\u00e9riques, \u00e9num\u00e9rations, for(:)<\/small><\/td>\n<\/tr>\n<tr>\n<td>6 (1.6)<\/td>\n<td>2006<\/td>\n<td><small>Open source (GPL): OpenJDK<\/small><\/td>\n<\/tr>\n<tr>\n<td>7 (1.7)<\/td>\n<td>2011<\/td>\n<td><small>switch avec des String, inf\u00e9rence des types, multicatch, Tasks<\/small><\/td>\n<\/tr>\n<tr>\n<td>8 (1.8)<\/td>\n<td>2014<\/td>\n<td><small>Lambda, stream<\/small><\/td>\n<\/tr>\n<tr>\n<td>9 (1.9)<\/td>\n<td>2017<\/td>\n<td><small>Support natif json et HTTP\/2<\/small><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/section>\n<section>\n<h2>Version de <b>Java<\/b><\/h2>\n<p>En plus de l&#8217;\u00e9dition standart (SE), Java propose:<\/p>\n<p>&nbsp;<\/p>\n<p>Une version entreprise (EE) qui comprend des librairies suppl\u00e9mentaires, notamment pour des applications tr\u00e8s complexes (ex\u00e9cut\u00e9es sur plusieurs serveurs par exemple)<\/p>\n<p>Une version micro (ME) pour des applications embarqu\u00e9es (librairie pour les communications sans fil, faible consommation, &#8230;)<\/p>\n<\/section>\n<section>\n<h2>Java vs C++<\/h2>\n<p>Java est tr\u00e8s proche de C++ dans la syntaxe.<\/p>\n<p>Cependant Java n&#8217;utilise pas<\/p>\n<ul>\n<li>de pointeurs<\/li>\n<li>de la surcharge d&#8217;op\u00e9rateur<\/li>\n<li>de l&#8217;h\u00e9ritage multiple<\/li>\n<\/ul>\n<p>&nbsp;<\/p>\n<p>La m\u00e9moire est g\u00e9r\u00e9e automatiquement (la m\u00e9moire est lib\u00e9r\u00e9e par un ramasse miettes).<\/p>\n<\/section>\n<section>\n<h2>Java vs C++<\/h2>\n<p>Le C++ est compil\u00e9 en code natif (ex\u00e9cutable), qui ne s&#8217;ex\u00e9cute que sur une architecture particuli\u00e8re.<\/p>\n<p>Le Java est compil\u00e9 en <i>bytecode<\/i> qui s&#8217;ex\u00e9cute sur toutes les architectures (o\u00f9 une machine virtuelle Java est install\u00e9e).<br \/>\nLe programme est distribu\u00e9 \u00e0 la fois de mani\u00e8re <b>compil\u00e9<\/b> et <b>portable<\/b>.<\/p>\n<\/section>\n<section>\n<h2>Java vs C++<\/h2>\n<p>Le bytecode g\u00e9n\u00e9r\u00e9 par le compilateur <b>ne d\u00e9pend pas de l\u2019architecture de la machine o\u00f9 a \u00e9t\u00e9 compile\u0301 le code source<\/b>, c\u2019est-a\u0300-dire que les bytecodes produits sur une machine pourront s&#8217;ex\u00e9cuter (via une machine virtuelle) sur des architectures diff\u00e9rentes.<\/p>\n<\/section>\n<section>\n<h2>Ex\u00e9cution du code <b>Java<\/b><\/h2>\n<p>Lors de l&#8217;ex\u00e9cution d&#8217;un programme Java compil\u00e9, la machine virtuelle Java JVM:<\/p>\n<ul>\n<li>Lit le bytecode<\/li>\n<li>V\u00e9rifie qu&#8217;il est correct<\/li>\n<li>Optimise les instructions<\/li>\n<li>Compile le bytecode en code natif<\/li>\n<li>Ex\u00e9cute le code natif<\/li>\n<\/ul>\n<p>&nbsp;<\/p>\n<p>On dit que la compilation en code natif est <b>&#8220;Just In Time (JIT)&#8221;<\/b><\/p>\n<\/section>\n<section>\n<h2>En r\u00e9sum\u00e9<\/h2>\n<p>Java produit du code interm\u00e9diaire (bytecode) qui est portable. Il est robuste (il est s\u00fbr, typ\u00e9 statiquement et fortement) et performant (il est ex\u00e9cut\u00e9 apr\u00e8s une compilation en code natif JIT)<\/p>\n<\/section>\n<\/section>\n<section>\n<section class=\"toc-pause\">\n<h1>Java et la Programmation Objet<\/h1>\n<\/section>\n<section>\n<h2>Concept d&#8217;Objet<\/h2>\n<p>Un programme est constitu\u00e9 de donn\u00e9es et de proc\u00e9dures.<\/p>\n<p class=\"fragment\">La programmation objet consiste \u00e0 associer au sein d&#8217;un <b>objet<\/b>, les donn\u00e9es avec les proc\u00e9dures agissant sur ces donn\u00e9es.<\/p>\n<\/section>\n<section>\n<h2>Concept d&#8217;Objet<\/h2>\n<p>Donn\u00e9es et proc\u00e9dures ind\u00e9pendantes:<\/p>\n<div class=\"row\">\n<div class=\"col-md-6\">\n<p>Donn\u00e9es:<\/p>\n<div>Voiture<br \/>\n&#8211; mod\u00e8le<br \/>\n&#8211; position<\/div>\n<\/div>\n<div class=\"col-md-6\">\n<p>Proc\u00e9dures:<\/p>\n<div>void voiture_avance(Voiture, int)<br \/>\nvoid voiture_recule(Voiture, int)<\/div>\n<\/div>\n<\/div>\n<\/section>\n<section>\n<h2>Concept d&#8217;Objet<\/h2>\n<p>Donn\u00e9es et proc\u00e9dures dans un objet:<\/p>\n<p>Voiture:<\/p>\n<div><b>Attributs<\/b> :<br \/>\n&#8211; mod\u00e8le<br \/>\n&#8211; position<br \/>\n<b>Methodes<\/b> :<br \/>\nvoid avance(int)<br \/>\nvoid recule(int)<\/div>\n<\/section>\n<section>\n<h2>Concept d&#8217;Objet<\/h2>\n<p>Un objet ne d\u00e9voile que ses m\u00e9thodes publiques (son interface):<\/p>\n<p>Voiture :<\/p>\n<div><b>Methodes<\/b> :<br \/>\nvoid avance(int)<br \/>\nvoid recule(int)<\/div>\n<p class=\"fragment\">L&#8217;objet maitrise ses donn\u00e9es ce qui limite les risques d&#8217;effet de bord (lorsqu&#8217;un composant modifie les donn\u00e9es d&#8217;autres composants).<\/p>\n<p>On dit que les donn\u00e9es sont <b>encapsul\u00e9es<\/b>.<\/p>\n<\/section>\n<section>\n<h2>Concept d&#8217;Objet<\/h2>\n<p>On peut alors utiliser l&#8217;objet maVoiture avec la notation suivante:<\/p>\n<pre><code class=\"java\" data-trim=\"\">\r\n\t\t\t\t\t\t\tmaVoiture.avance(10);\r\n\t\t\t\t\t\t<\/code><\/pre>\n<p>L&#8217;ensemble des m\u00e9thodes modifiant l&#8217;\u00e9tat de maVoiture peuvent \u00eatre appel\u00e9es \u00e0 la suite de maVoiture[point]&#8230;<\/p>\n<p>On dit aussi que l&#8217;objet maVoiture est de <b>type<\/b> Voiture<\/p>\n<\/section>\n<section>\n<h2>Concept d&#8217;Objet<\/h2>\n<p>Lorsque l&#8217;on programme avec un langage objet, on se pose la question &#8220;de quoi est compos\u00e9 notre programme?&#8221; et on organise les composants en diff\u00e9rents objets.<\/p>\n<\/section>\n<section>\n<h2>S\u00e9paration des pr\u00e9occupations<\/h2>\n<p class=\"fragment\">C&#8217;est un principe de programmation propos\u00e9 par E. W. Dijkstra.<\/p>\n<p class=\"fragment\">Il consiste \u00e0 d\u00e9couper un programme en plusieurs parties <b>ind\u00e9pendantes<\/b>, chacun s&#8217;occupant d&#8217;une t\u00e2che. On peut le voir comme un ensemble de modules.<\/p>\n<p class=\"fragment\">La modularit\u00e9 et la s\u00e9paration des pr\u00e9occupations sont obtenues en <b>encapsulant<\/b> l&#8217;information dans une section de code proposant uniquement une interface.<\/p>\n<p class=\"fragment\">L&#8217;encapsulation permet de cacher l&#8217;information et le fonctionnement interne d&#8217;un module.<\/p>\n<\/section>\n<section>\n<h2>S\u00e9paration des pr\u00e9occupations<\/h2>\n<p class=\"fragment\">En Java, les pr\u00e9occupations sont d\u00e9coup\u00e9es en <b>objets<\/b>.<\/p>\n<p class=\"fragment\">Un objet poss\u00e8de des donn\u00e9es qui lui sont propres et met a disposition une interface.<\/p>\n<p class=\"fragment\">L&#8217;interface (l&#8217;ensemble des m\u00e9thodes publiques) permet de modifier l&#8217;\u00e9tat de l&#8217;objet sans ce soucier de l&#8217;impl\u00e9mentation.<\/p>\n<p class=\"fragment\">Le programme est ainsi plus facile \u00e0 maintenir et \u00e0 faire \u00e9voluer.<\/p>\n<\/section>\n<section>\n<h2>Objets et classes<\/h2>\n<p class=\"fragment\">Il y a plusieurs mani\u00e8res de d\u00e9finir la structure d&#8217;un objet<\/p>\n<p class=\"fragment\">En Java, les Objets sont d\u00e9finis par des classes.<\/p>\n<p class=\"fragment\">Java va m\u00eame plus loin car <b>tout<\/b> est d\u00e9fini par des classes.<\/p>\n<\/section>\n<\/section>\n<section>\n<section class=\"toc-pause\">\n<h1>Principes de la POO<\/h1>\n<\/section>\n<section>\n<h2>Principes de la POO<\/h2>\n<p class=\"fragment\">Un objet poss\u00e8de des <b>attributs<\/b> (des donn\u00e9es) et des <b>methodes<\/b> (des fonctions).<\/p>\n<p class=\"fragment\">Ces attributs et m\u00e9thodes peuvent \u00eatre <b>publics<\/b> (peuvent \u00eatre utilis\u00e9 par d&#8217;autres objets) ou <b>priv\u00e9s<\/b> (cach\u00e9, ils ne servent que pour le fonctionnement interne de l&#8217;objet).<\/p>\n<p class=\"fragment\">On parle tr\u00e8s rarement des attributs priv\u00e9s car leurs caract\u00e9ristiques (leur nom, leur utilit\u00e9, leur impl\u00e9mentation) n&#8217;ont pas d&#8217;importance et <b>peuvent m\u00eame changer au fil des versions<\/b><\/p>\n<\/section>\n<section>\n<h2>Principes de la POO<\/h2>\n<pre><code class=\"java\" data-trim=\"\">\r\nSystem.out.println(\"Hello World\");\r\n\t\t\t\t\t\t<\/code><\/pre>\n<p class=\"fragment\">L&#8217;objet <code>System<\/code> poss\u00e8de un attribut <code>out<\/code>. L&#8217;objet <code>out<\/code> poss\u00e8de une m\u00e9thode println(). Cette m\u00e9thode utilise (surement) des attributs et des m\u00e9thodes priv\u00e9s internes.<\/p>\n<p class=\"fragment\">On pourra remarquer qu&#8217;aucun objet (ou presque) en Java ne poss\u00e8de d&#8217;attribut public. En effet, l&#8217;encapsulation (&#8220;les donn\u00e9es sont cach\u00e9es, et un objet ne laisse apparaitre qu&#8217;une interface de haut niveau&#8221;) est appliqu\u00e9 \u00e0 la lettre.<\/p>\n<\/section>\n<section>\n<h2>Principes de la POO<\/h2>\n<p>Un objet <code>monCompte<\/code> repr\u00e9sentant un compte bancaire par exemple peut proposer une m\u00e9thode <code>getBalance()<\/code> qui retourne la quantit\u00e9 d&#8217;argent sur le compte.<\/p>\n<p class=\"fragment\">Cette quantit\u00e9 peut \u00eatre stock\u00e9e dans l&#8217;objet par un attribut priv\u00e9 <code>balance<\/code>. Dans ce cas, on dit que <code>getBalance<\/code> est un <b>accesseur<\/b> de l&#8217;attribut <code>balance<\/code>.<\/p>\n<p class=\"fragment\">On trouvera parfois une m\u00e9thode <code>setBalance(int)<\/code> permettant de remplacer la valeur de l&#8217;attribut priv\u00e9 <code>balance<\/code>. Dans ce cas, on dit que <code>setBalance<\/code> est un <b>mutateur ou modificateur<\/b> de l&#8217;attribut <code>balance<\/code>.<\/p>\n<\/section>\n<section>\n<h2>Principes de la POO<\/h2>\n<p class=\"fragment\">Les <b>accesseurs<\/b> et les <b>modificateurs<\/b> permettent d&#8217;exposer une donn\u00e9e interne d&#8217;un objet. L&#8217;inter\u00eat et que cette exposition est <b>maitris\u00e9e<\/b>.<\/p>\n<p class=\"fragment\">Par exemple l&#8217;objet <code>monCompte<\/code> pourrait proposer comme modificateurs de l&#8217;attribut <code>balance<\/code> deux m\u00e9thodes <code>draw(int)<\/code> et <code>add(int)<\/code> permettant de retirer et ajouter de l&#8217;argent. Ces m\u00e9thodes effectuent des v\u00e9rifications.<\/p>\n<pre class=\"fragment\"><code class=\"java\" data-trim=\"\">\r\nmonCompte.getBalance(); \/\/ retourne 50\r\nmonCompte.draw(30);\r\nmonCompte.getBalance(); \/\/ retourn 20;\r\nmonCompte.draw(30);     \/\/ erreur, il n'y a pas assez d'argent\r\nmonCompte.getBalance(); \/\/ retourn 20;\r\nmonCompte.add(-30);     \/\/ erreur, on doit ajouter un nombre positif.\r\nmonCompte.getBalance(); \/\/ retourn 20;\r\n\t\t\t\t\t\t\t<\/code><\/pre>\n<\/section>\n<\/section>\n<section>\n<section class=\"toc-pause\">\n<h1>Instance de Classe<\/h1>\n<\/section>\n<section>\n<h2>Instance de Classe<\/h2>\n<p class=\"fragment\"><b>Une classe est une mani\u00e8re de d\u00e9crire un objet<\/b> (un peu comme un moule).<\/p>\n<p class=\"fragment\">On peut utiliser une classe pour cr\u00e9er des objets qui auront les attributs et les m\u00e9thodes d\u00e9crits par la classe.<\/p>\n<p class=\"fragment\">Avec une class <code>MonSuperObjet<\/code> on peut cr\u00e9er autant d&#8217;objets souhait\u00e9s. On les appelle des <b>Instances de la classe MonSuperObjet<\/b>.<\/p>\n<pre class=\"fragment\"><code class=\"java\">MonSuperObjet objet1 = new MonSuperObjet();\r\nMonSuperObjet objet2 = new MonSuperObjet();\r\nMonSuperObjet objet3 = new MonSuperObjet();\r\n<\/code><\/pre>\n<p class=\"fragment\">On instancie la classe lorsqu&#8217;on cr\u00e9e une instance de cette classe.<\/p>\n<\/section>\n<section>\n<h2>Classe et Objet<\/h2>\n<p>Dans une classe on d\u00e9finit les attributs et les m\u00e9thodes de l&#8217;objet.<\/p>\n<pre><code class=\"java\">\r\npublic class MaSuperClasse {\r\n\tprivate String attribut1; \/\/ attribut priv\u00e9e\r\n\r\n\t\/\/ modificateur public\r\n\tpublic void setAttribut1(String a) { \/* ... *\/ }\r\n\r\n\t\/\/ accesseur public\r\n\tpublic String getAttribut1()  { \/* ... *\/ }\r\n\r\n\t\/\/ autres m\u00e9thodes publiques\r\n\tpublic void methode1() { \/*\r\n\t        Lorsqu'un objet de type MaSuperClasse ex\u00e9cute\r\n\t        methode1(), CET OBJET est modifi\u00e9 de telle fa\u00e7on...\r\n\t    *\/\r\n\t}\r\n\r\n\t\/\/ autres m\u00e9thodes priv\u00e9es\r\n\tprivate void methodePrivee1() { \/* ... *\/ }\r\n}\r\n\t\t\t\t\t\t<\/code><\/pre>\n<\/section>\n<section>\n<h2>Classe et Objet<\/h2>\n<p>Un exemple plus concret :<\/p>\n<pre><code class=\"java\">\r\npublic class Person {\r\n\tprivate String name;\r\n\tprivate int birthYear;\r\n\r\n\t\/\/ accesseur public\r\n\tpublic String getName()  { \/* ... *\/ }\r\n\r\n\t\/\/ accesseur public\r\n\tpublic String getAge()  { \/* ... *\/ }\r\n}\r\n\t\t\t\t\t\t<\/code><\/pre>\n<p class=\"fragment\">Les objets cr\u00e9\u00e9s avec cette classe poss\u00e8dent les m\u00e9thodes d\u00e9finies dans cette classe<\/p>\n<pre class=\"fragment\"><code class=\"java\">Person personne1 = new Person();\r\nPerson personne2 = new Person();\r\npersonne1.getAge();\r\npersonne2.getAge();\r\n<\/code><\/pre>\n<\/section>\n<section>\n<h2>Classe et Objet<\/h2>\n<p>Une classe permet aussi de d\u00e9finir un <b>constructeur<\/b>: une fonction appel\u00e9 lors de la cr\u00e9ation de l&#8217;objet.<\/p>\n<pre><code class=\"java\">\r\npublic class Person {\r\n\tprivate String name;\r\n\tprivate int birthYear;\r\n\r\n\t\/\/ Constructeur\r\n\tpublic Person(String name, int birthYear) { \/* ... *\/ }\r\n\r\n\tpublic String getName()  { \/* ... *\/ }\r\n\r\n\tpublic String getAge()  { \/* ... *\/ }\r\n}\r\n\t\t\t\t\t\t<\/code><\/pre>\n<pre class=\"fragment\"><code class=\"java\" data-trim=\"\">\r\nPerson alice = new Person(\"Alice\", 1977);\r\nPerson bob = new Person(\"Bob\", 1978);\r\nalice.getAge();\r\nbob.getAge();\r\n<\/code><\/pre>\n<\/section>\n<section>\n<h2>Constructeur et mot clef <code>this<\/code><\/h2>\n<p>Un constructeur est surtout utile pour initialiser les attributs priv\u00e9s de l&#8217;objets.<\/p>\n<p class=\"fragment\">Dans une m\u00e9thode (ou dans le constructeur), l&#8217;objet en train d&#8217;\u00eatre manipul\u00e9 est appel\u00e9 <code>this<\/code> (signifie CET OBJET).<\/p>\n<pre class=\"fragment\"><code class=\"java\">\r\npublic class Person {\r\n  private String name;\r\n  private int birthYear;\r\n\r\n  public Person(String name, int birthYear) {\r\n    \/\/ Un objet de type Person est en train d'\u00eatre cr\u00e9\u00e9\r\n    \/\/ Cette objet s'appelle this. A la fin de l'ex\u00e9cution\r\n    \/\/ de ce constructeur, l'objet this est retourn\u00e9 automatiquement\r\n    this.name = name;\r\n    this.birthYear = birthYear;\r\n  }\r\n  \/* Reste des m\u00e9thodes\r\n  ... *\/\r\n}\r\n\t\t\t\t\t\t<\/code><\/pre>\n<\/section>\n<section>\n<h2>Constructeur et mot clef <code>this<\/code><\/h2>\n<pre><code class=\"java\" data-trim=\"\">\r\npublic class Person {\r\n\tprivate String name;\r\n\tprivate int birthYear;\r\n\r\n\tpublic Person(String name, int birthYear) {\r\n\t\tthis.name = name;\r\n\t\tthis.birthYear = birthYear;\r\n\t}\r\n \tpublic int getAge() {\r\n \t\treturn 2017 - this.birthYear;\r\n \t}\r\n}\r\n<\/code><\/pre>\n<pre><code class=\"java\" data-trim=\"\">\r\nPerson alice = new Person(\"Alice\", 1977);\r\nPerson bob = new Person(\"Bob\", 1978);\r\nalice.getAge(); \/\/retourne 40\r\nbob.getAge(); \/\/retourne 39<\/code><\/pre>\n<p class=\"fragment\">Lorsqu&#8217;on appelle la m\u00e9thode <code>getAge()<\/code> sur un objet, cette objet est appel\u00e9 <code>this<\/code> dans le corps de la m\u00e9thode.<br \/>\n<small>Lors du 1<small>er<\/small> appel, <code>this<\/code> correspond \u00e0 l&#8217;objet <code>alice<\/code><br \/>\nLors du 2<small>\u00e8me<\/small> appel, il correspond \u00e0 l&#8217;objet <code>bob<\/code>.<\/small><\/p>\n<\/section>\n<section>\n<h2>Constructeur et mot clef <code>this<\/code><\/h2>\n<p>Lorsqu&#8217;il n&#8217;ya pas d&#8217;ambigu\u00eft\u00e9, le mot clef <code>this<\/code> peut \u00eatre omis.<\/p>\n<pre><code class=\"java\" data-trim=\"\">\r\npublic class Person {\r\n  private String name;\r\n  private int birthYear;\r\n\r\n  public Person(String name, int birthYear) {\r\n    this.name = name;\r\n    this.birthYear = birthYear;\r\n  }\r\n  public int getAge() {\r\n    return 2017 - birthYear; \/\/ Aucune variable locale ne s'appelle\r\n                             \/\/ birthYear, donc on fait bien r\u00e9f\u00e9rence\r\n                             \/\/ \u00e0 l'attribut de l'objet courant\r\n  }\r\n}\r\n<\/code><\/pre>\n<\/section>\n<section>\n<h2>Le Mot Cl\u00e9 <code>final<\/code><\/h2>\n<p>Le mot-cl\u00e9 <code>final<\/code> indique qu&#8217;un \u00e9l\u00e9ment ne peut \u00eatre chang\u00e9 dans la suite du programme.<\/p>\n<p>Il peut s&#8217;appliquer aux m\u00e9thodes et attributs d&#8217;une classe ainsi qu&#8217;\u00e0 la classe elle-m\u00eame.<\/p>\n<\/section>\n<section>\n<h2>Le Mot Cl\u00e9 <code>final<\/code><\/h2>\n<pre><code class=\"java\" data-trim=\"\">\r\npublic class Person {\r\n  private final String name;\r\n  private final int birthYear;\r\n\r\n  public Person(String name, int birthYear) {\r\n    this.name = name;\r\n    this.birthYear = birthYear;\r\n  }\r\n  public int getAge() {\r\n    return 2017 - birthYear;\r\n  }\r\n  public int getName() {\r\n    return name;\r\n  }\r\n}\r\n<\/code><\/pre>\n<p>Ici \u00e7a tombe bien car il n&#8217;y a pas de modificateurs.<\/p>\n<p class=\"fragment\">Lorsqu&#8217;un objet ne poss\u00e8de aucun modificateur (son \u00e9tat ne peut pas \u00eatre modifi\u00e9 apr\u00e8s sa cr\u00e9ation), on dit qu&#8217;il est <b>immuable<\/b>.<\/p>\n<\/section>\n<\/section>\n<section>\n<section class=\"toc-pause\">\n<h1>l&#8217;Objet Classe<\/h1>\n<\/section>\n<section>\n<h2>l&#8217;Objet Classe<\/h2>\n<p>Une classe est aussi elle-m\u00eame <b>un objet<\/b>.<\/p>\n<p class=\"fragment\">Elle peut poss\u00e9der des attributs et des m\u00e9thodes qu&#8217;on appelle <b>attributs de classe<\/b> et <b>m\u00e9thodes de classe<\/b> (ou attributs et m\u00e9thodes statiques) d\u00e9clar\u00e9s avec la mot cl\u00e9 <code>static<\/code>.<\/p>\n<p class=\"fragment\"><b>L&#8217;objet classe existe m\u00eame si la classe n&#8217;est pas instanci\u00e9e<\/b>.<\/p>\n<\/section>\n<section>\n<h2>l&#8217;Objet Classe<\/h2>\n<pre><code class=\"java\" data-trim=\"\">\r\npublic class Person {\r\n  private final String name;\r\n  private final int birthYear;\r\n  static private int population = 0;\r\n\r\n  public Person(String name, int birthYear) {\r\n    this.name = name;\r\n    this.birthYear = birthYear;\r\n    Person.population++;\r\n  }\r\n  static int getPopulation() {\r\n  \treturn population;\r\n  }\r\n}\r\n<\/code><\/pre>\n<pre><code class=\"java\" data-trim=\"\">\r\nPerson.getPopulation(); \/\/ return 0\r\nPerson alice = new Person(\"Alice\", 1977);\r\nPerson.getPopulation(); \/\/ return 1\r\nalice.getPopulation(); \/\/ return 1\r\n<\/code><\/pre>\n<\/section>\n<section>\n<h2>l&#8217;Objet Classe<\/h2>\n<pre><code class=\"java\" data-trim=\"\">\r\npublic class Personne {\r\n  private final String name;\r\n  private final int birthYear;\r\n  static private int population = 0;\r\n  static final public int majority = 18;\r\n\r\n  public Person(String name, int birthYear) {\r\n    this.name = name;\r\n    this.birthYear = birthYear;\r\n    Person.population++;\r\n  }\r\n  public int getAge() {\r\n  \treturn 2017 - birthYear;\r\n  }\r\n  static int getPopulation() {\r\n  \treturn population;\r\n  }\r\n  public boolean isAdult() {\r\n  \treturn getAge() &gt;= majority;\r\n  }\r\n}\r\n<\/code><\/pre>\n<pre><code class=\"java\" data-trim=\"\">\r\nPersonne.majority; \/\/ return 18\r\nPersonne alice = new Personne(\"Alice\", 1977);\r\nalice.isAdult(); \/\/ return true\r\n<\/code><\/pre>\n<p><small><a href=\"https:\/\/repl.it\/Csus\" target=\"blank\" rel=\"noopener\">Run!<\/a><\/small><\/p>\n<\/section>\n<section>\n<h2>l&#8217;Objet Classe<\/h2>\n<pre><code data-trim=\"\">\r\nSystem.out.println(\"Hello World\");\r\n\t\t\t\t\t\t<\/code><\/pre>\n<p class=\"fragment\"><code>out<\/code> est un attribut statique de type <code>PrintStream<\/code> de la classe <code>System<\/code>.<\/p>\n<p class=\"fragment\"><code>println(String)<\/code> est une m\u00e9thode publique de la classe <code>PrintStream<\/code><\/p>\n<\/section>\n<\/section>\n<section>\n<section class=\"toc-pause\">\n<h1>Notions de Base du Java<\/h1>\n<\/section>\n<section>\n<h2>D\u00e9claration des variables<\/h2>\n<pre><code class=\"java\" data-trim=\"\">\r\n\/\/ types primitifs\r\nint a = 5, b = 3;\r\nchar c;\r\n\r\n\/\/ Objets\r\nLocalDateTime currentTime;\r\ncurrentTime = LocalDateTime.now();\r\n\r\nScanner sc = new Scanner(System.in);\r\n\t\t\t\t\t\t<\/code><\/pre>\n<\/section>\n<section>\n<h2>Les instructions simples<\/h2>\n<pre><code class=\"java\" data-trim=\"\">\r\nint a = 5, b = 3;\r\nint sum;\r\nsum = a + b;\r\nSystem.out.println(a + \"+\" + b + \"=\" + sum);\r\n\r\ndouble quot = a \/ (double)b;\r\nSystem.out.println(a + \"\/\" + b + \"=\" + quot);\r\n\r\nLocalDateTime currentTime = LocalDateTime.now();\r\nSystem.out.println(\"Current DateTime: \" + currentTime);\r\n\t\t\t\t\t\t<\/code><\/pre>\n<\/section>\n<section>\n<h2>Conditions<\/h2>\n<pre><code class=\"java\" data-trim=\"\">\r\nScanner sc = new Scanner(System.in);\r\nint i = sc.nextInt();\r\n\r\nif(i % 2 == 1) {\r\n\tSystem.out.println(\"Odd\");\r\n} else {\r\n\tSystem.out.println(\"Even\");\r\n}\r\n\t\t\t\t\t\t<\/code><\/pre>\n<\/section>\n<section>\n<h2>Conditions<\/h2>\n<pre><code class=\"java\" data-trim=\"\">\r\nString s = System.getProperty(\"os.name\");\r\nswitch(s) {\r\n\tcase \"Linux\":\r\n\t\t\/\/ Execute something for Linux\r\n\tcase \"Mac OS X\":\r\n\t\t\/\/ Execute something for Mac OS X\r\n\tcase \"FreeBSD\":\r\n\t\t\/\/ Execute something for FreeBSD\r\n\t\t\/\/...\r\n\tdefault:\r\n\t\t\/\/ Otherwise\r\n}\r\n\t\t\t\t\t\t<\/code><\/pre>\n<\/section>\n<section>\n<h2>Boucles<\/h2>\n<pre><code class=\"java\" data-trim=\"\">\r\n\r\nScanner sc = new Scanner(System.in);\r\n\r\nint i = sc.nextInt();\r\nwhile (i &gt;= 0){\r\n\tif(i % 2 == 1) {\r\n\t\tSystem.out.println(\"Odd\");\r\n\t} else {\r\n\t\tSystem.out.println(\"Even\");\r\n\t}\r\n\r\n\ti = sc.nextInt();\r\n}\r\n\t\t\t\t\t\t<\/code><\/pre>\n<p><small><a href=\"https:\/\/repl.it\/Cm18\" target=\"blank\" rel=\"noopener\">Run!<\/a><\/small><\/p>\n<\/section>\n<section>\n<h2>Boucles<\/h2>\n<pre><code class=\"java\" data-trim=\"\">\r\n\r\nScanner sc = new Scanner(System.in);\r\n\r\nboolean stop = false;\r\ndo {\r\n\tint i = sc.nextInt();\r\n\r\n\tif(i &lt; 0) {\r\n\t\tstop = true;\r\n\t} else if(i % 2 == 1) {\r\n\t\tSystem.out.println(\"Odd\");\r\n\t} else {\r\n\t\tSystem.out.println(\"Even\");\r\n\t}\r\n} while (!stop);\r\n\t\t\t\t\t\t<\/code><\/pre>\n<p><small><a href=\"https:\/\/repl.it\/Cm1f\" target=\"blank\" rel=\"noopener\">Run!<\/a><\/small><\/p>\n<\/section>\n<section>\n<h2>Boucles<\/h2>\n<pre><code class=\"java\" data-trim=\"\">\r\n\r\nScanner sc = new Scanner(System.in);\r\n\r\ndo {\r\n\tint i = sc.nextInt();\r\n\r\n\tif(i &lt; 0) {\r\n\t\tbreak;\r\n\t}\r\n\tif(i % 2 == 1) {\r\n\t\tSystem.out.println(\"Odd\");\r\n\t} else {\r\n\t\tSystem.out.println(\"Even\");\r\n\t}\r\n} while (true);\r\n\t\t\t\t\t\t<\/code><\/pre>\n<\/section>\n<section>\n<h2>Boucles<\/h2>\n<pre><code class=\"java\" data-trim=\"\">\r\nfor(int i = 1; i &lt; 11; ++i) {\r\n\tSystem.out.println(i+\"\u00b2 = \"+(i*i));\r\n}\r\n\t\t\t\t\t\t<\/code><\/pre>\n<p><small><a href=\"https:\/\/repl.it\/Cm1k\" target=\"blank\" rel=\"noopener\">Run!<\/a><\/small><\/p>\n<\/section>\n<section>\n<h2>Boucles<\/h2>\n<pre><code class=\"java\" data-trim=\"\">\r\nString mail = \"quentin.bramas@lip6.fr\";\r\nfor (String part : mail.split(\"[^\\\\w]\")) {\r\n    System.out.println(part);\r\n}\r\n\t\t\t\t\t\t<\/code><\/pre>\n<p><small><a href=\"https:\/\/repl.it\/Cm1s\" target=\"blank\" rel=\"noopener\">Run!<\/a><\/small><\/p>\n<\/section>\n<\/section>\n<section>\n<section class=\"toc-pause\">\n<h1>Une application simple<\/h1>\n<\/section>\n<section>\n<h2>Premier programme<\/h2>\n<p>Un programme est d\u00e9fini dans une classe, par une m\u00e9thode statique et public nomm\u00e9e <i>main<\/i><\/p>\n<pre><code class=\"java\" data-trim=\"\">\r\n\/\/ Ce code ce trouve dans un fichier portant le m\u00eame nom que la classe: MonProgramme.java\r\npublic class MonProgramme {\r\n  public static void main(String[] args) {\r\n    System.out.println(\"hello world\");\r\n  }\r\n}\r\n\t\t\t\t\t\t<\/code><\/pre>\n<p><small><a href=\"https:\/\/repl.it\/\" target=\"blank\" rel=\"noopener\">Run!<\/a><\/small><\/p>\n<\/section>\n<section>\n<h2>Execution du programme<\/h2>\n<p>La compilation s&#8217;effectue avec la commande<\/p>\n<pre><code class=\"bash\">javac MonProgramme.java<\/code><\/pre>\n<p>&nbsp;<\/p>\n<p>L&#8217;execution du programme s&#8217;effectue avec la commande<\/p>\n<pre><code class=\"bash\">java MonProgramme<\/code><\/pre>\n<p>&nbsp;<\/p>\n<\/section>\n<\/section>\n<section>\n<section class=\"toc-pause\">\n<h1>Les plateformes pour les TPs<\/h1>\n<\/section>\n<section>\n<h2>Outils de D\u00e9veloppement<\/h2>\n<p><a href=\"http:\/\/www.oracle.com\/technetwork\/java\/javase\/downloads\/jdk8-downloads-2133151.html\">JDK Java SE 8<\/a><br \/>\nEditeur : <a href=\"https:\/\/netbeans.org\/downloads\/\">NetBeans<\/a> &#8211; <a href=\"https:\/\/eclipse.org\/downloads\/\">Eclipse<\/a> &#8211; <a href=\"https:\/\/www.jetbrains.com\/idea\/\">IntelliJ IDEA<\/a> &#8211; <a href=\"https:\/\/atom.io\/\">Atom<\/a><\/p>\n<\/section>\n<section>\n<h2>Travaux Pratiques (charg\u00e9 Wafa Badreddine)<\/h2>\n<\/section>\n<\/section>\n","protected":false},"excerpt":{"rendered":"<p>UE Java 2017-2018 : 8 S\u00e9ances Cours 12 S\u00e9ances de TD\/TP Disponible en ligne sur Maria Potop-Butucaru Plan de l&#8217;UE : Introduction au Java et POO H\u00e9ritage et polymorphisme Fiabilit\u00e9 (exceptions, assertions) Entr\u00e9es\/Sorties (flux de donn\u00e9es, gestion de fichiers, s\u00e9rialisation,\u2026) Programmation r\u00e9seaux (sockets TCP\/UPD) Programmation concurrente (multi-threading, synchronisation, interruption) Programmation g\u00e9n\u00e9rique, collections et algorithmes Biblioth\u00e8que [&hellip;]<\/p>\n","protected":false},"author":55,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[8,5],"tags":[6],"class_list":["post-49","post","type-post","status-publish","format-standard","hentry","category-java","category-teaching","tag-java-language"],"_links":{"self":[{"href":"https:\/\/wp-systeme.lip6.fr\/potop-butucaru\/wp-json\/wp\/v2\/posts\/49","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/wp-systeme.lip6.fr\/potop-butucaru\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/wp-systeme.lip6.fr\/potop-butucaru\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/wp-systeme.lip6.fr\/potop-butucaru\/wp-json\/wp\/v2\/users\/55"}],"replies":[{"embeddable":true,"href":"https:\/\/wp-systeme.lip6.fr\/potop-butucaru\/wp-json\/wp\/v2\/comments?post=49"}],"version-history":[{"count":2,"href":"https:\/\/wp-systeme.lip6.fr\/potop-butucaru\/wp-json\/wp\/v2\/posts\/49\/revisions"}],"predecessor-version":[{"id":77,"href":"https:\/\/wp-systeme.lip6.fr\/potop-butucaru\/wp-json\/wp\/v2\/posts\/49\/revisions\/77"}],"wp:attachment":[{"href":"https:\/\/wp-systeme.lip6.fr\/potop-butucaru\/wp-json\/wp\/v2\/media?parent=49"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/wp-systeme.lip6.fr\/potop-butucaru\/wp-json\/wp\/v2\/categories?post=49"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/wp-systeme.lip6.fr\/potop-butucaru\/wp-json\/wp\/v2\/tags?post=49"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}