Différences
Ci-dessous, les différences entre deux révisions de la page.
Les deux révisions précédentes Révision précédente Prochaine révision | Révision précédente | ||
public:java:misc [2016/02/08 15:46] – [Notes sur les tutoriaux d'Oracle] cchatel | public:java:misc [2016/02/26 09:23] (Version actuelle) – fbrucker | ||
---|---|---|---|
Ligne 1: | Ligne 1: | ||
+ | ====== Notes sur les tutoriaux d' | ||
+ | Une petite collection de notes concernant le tutoriel Java d' | ||
+ | * [[https:// | ||
+ | * [[https:// | ||
+ | |||
+ | ===== Trail getting started ===== | ||
+ | |||
+ | [[https:// | ||
+ | |||
+ | Une fois le tutoriel lu, vous pourrez l' | ||
+ | |||
+ | ===== Trail learning the Java Langage ===== | ||
+ | |||
+ | [[https:// | ||
+ | |||
+ | ==== Concepts ==== | ||
+ | |||
+ | [[https:// | ||
+ | |||
+ | Pendant Java de la partie [[public: | ||
+ | |||
+ | ==== Language basics ==== | ||
+ | |||
+ | [[https:// | ||
+ | |||
+ | === Variable === | ||
+ | |||
+ | En java tout est typé. Une variable ne peut contenir que des objets d'un seul type. On les déclare ainsi : | ||
+ | <code java> | ||
+ | type nom; | ||
+ | </ | ||
+ | Le code ci-dessus a déclaré une variable qui s' | ||
+ | |||
+ | <code java> | ||
+ | int x; | ||
+ | String nom; | ||
+ | </ | ||
+ | |||
+ | |||
+ | == Type primitif == | ||
+ | |||
+ | <note warning> | ||
+ | Un énorme piège de Java est que bien qu'il soit un langage objet, le poids de l' | ||
+ | </ | ||
+ | |||
+ | [[https:// | ||
+ | |||
+ | * **int** : entier sur 32 bits | ||
+ | * **float** : réel flottant sur 32 bit | ||
+ | * **double** : réel sur 64 bits | ||
+ | * **char** : nombre correspondant à un caractère | ||
+ | * **boolean** : true et false | ||
+ | |||
+ | En gros les nombres et les booléens. Ce ne sont **pas** des objets (leur type ne commence pas par des majuscules). | ||
+ | * Ils ne possèdent **pas** de méthodes. | ||
+ | * L' | ||
+ | |||
+ | == tableaux == | ||
+ | |||
+ | [[https:// | ||
+ | |||
+ | Les tableaux en Java : | ||
+ | * sont fixes (on ne peut pas en augmenter la taille) | ||
+ | * contiennent uniquement un type d' | ||
+ | * sont construits avec '' | ||
+ | | ||
+ | Ne confondez pas : | ||
+ | * la variable : '' | ||
+ | * et l' | ||
+ | |||
+ | |||
+ | '' | ||
+ | |||
+ | la classe [[https:// | ||
+ | * '' | ||
+ | * '' | ||
+ | | ||
+ | <code java> | ||
+ | package com.mco; | ||
+ | |||
+ | |||
+ | import java.util.Arrays; | ||
+ | |||
+ | public class Main { | ||
+ | |||
+ | public static void main(String[] args) { | ||
+ | |||
+ | int[] tableauEntier; | ||
+ | |||
+ | tableauEntier = new int[] {1, 3, 2, 6, 4, 5}; | ||
+ | |||
+ | System.out.println(tableauEntier); | ||
+ | String tableauConvertiEnString = Arrays.toString(tableauEntier); | ||
+ | System.out.println(tableauConvertiEnString); | ||
+ | |||
+ | Arrays.sort(tableauEntier); | ||
+ | |||
+ | System.out.println(Arrays.toString(tableauEntier)); | ||
+ | } | ||
+ | } | ||
+ | </ | ||
+ | |||
+ | |||
+ | <note warning> | ||
+ | La création de l' | ||
+ | - crée une variable pouvant contenir un tableau de 2 cartes, | ||
+ | - crée le tableau, | ||
+ | - pour chaque case du table crée un objet '' | ||
+ | |||
+ | La création des objet à mettre dans un tableau est **indispensable**. | ||
+ | |||
+ | <code java> | ||
+ | Card [] deuxCartes; | ||
+ | deuxCartes = new Card[2]; | ||
+ | |||
+ | deuxCartes[0] = new Card(1, " | ||
+ | deuxCartes[1] = new Card(7, " | ||
+ | </ | ||
+ | |||
+ | Si l'on omet la création des 2 cartes, les deux objets sont '' | ||
+ | </ | ||
+ | == Operator == | ||
+ | [[https:// | ||
+ | |||
+ | |||
+ | [[https:// | ||
+ | |||
+ | <note warning> | ||
+ | Je préfère que vous utilisiez '' | ||
+ | <code java> | ||
+ | int i = 1; | ||
+ | System.out.println(i++); | ||
+ | </ | ||
+ | </ | ||
+ | |||
+ | == Expressions, | ||
+ | |||
+ | [[https:// | ||
+ | |||
+ | En python les blocs sont déterminés par des indentations, | ||
+ | |||
+ | |||
+ | |||
+ | <note warning> | ||
+ | Je sais bien que des blocs d'une seule ligne n'ont pas besoin d' | ||
+ | |||
+ | Un code est fait pour évoluer et lorsque l'on rajoute une instruction on oublie souvent de rajouter l' | ||
+ | |||
+ | <code java> | ||
+ | int i; | ||
+ | for (i=0 ; i < 10 ; i += 1) | ||
+ | System.out.println(" | ||
+ | System.out.println(i); | ||
+ | </ | ||
+ | </ | ||
+ | |||
+ | == Control Flow Statements == | ||
+ | |||
+ | [[https:// | ||
+ | |||
+ | |||
+ | |||
+ | Boucles For : [[https:// | ||
+ | |||
+ | Pour les boucles '' | ||
+ | * préférez dans la mesure du possible la forme en //pour chaque// ('' | ||
+ | * avec les stream de java 8 (bien au-delà de ce cours introductif), | ||
+ | |||
+ | ==== Lesson: Classes and Objects ==== | ||
+ | |||
+ | [[https:// | ||
+ | |||
+ | < | ||
+ | Comprenez bien cette partie. Tout l' | ||
+ | </ | ||
+ | |||
+ | === Classes === | ||
+ | |||
+ | [[https:// | ||
+ | |||
+ | Pour Java tout est une classe, même le point de départ de notre programme. | ||
+ | |||
+ | Le fichier '' | ||
+ | |||
+ | <code java> | ||
+ | |||
+ | package com.exemple; | ||
+ | |||
+ | public class Main { | ||
+ | |||
+ | public static void main(String[] args) { | ||
+ | //le code | ||
+ | } | ||
+ | } | ||
+ | </ | ||
+ | |||
+ | |||
+ | |||
+ | |||
+ | == Declaring Classes == | ||
+ | |||
+ | [[https:// | ||
+ | |||
+ | |||
+ | Un programme Java est constitué de classes. Chaque classe est décrite dans un fichier ayant le nom de la classe et chaque fichier ne contient qu'une seule classe. | ||
+ | Fichier '' | ||
+ | |||
+ | <code java> | ||
+ | package com.domaine.application; | ||
+ | |||
+ | import les.méthodes.Utilisée.ici; | ||
+ | import mais.définies.ailleurs; | ||
+ | |||
+ | class MaClasse { | ||
+ | |||
+ | // des attributs, constructeurs et méthodes. | ||
+ | } | ||
+ | </ | ||
+ | |||
+ | Une classe particulière (donc un fichier) contient une méthode statique nommée " | ||
+ | |||
+ | == Declaring Member Variables == | ||
+ | |||
+ | [[https:// | ||
+ | |||
+ | La plupart du temps les attributs sont réservés au package ou privés (accessibles directement uniquement par la classe) et on y accède //via// des méthodes dites //getter// ('' | ||
+ | |||
+ | Fichier '' | ||
+ | |||
+ | <code java> | ||
+ | // package et imports | ||
+ | |||
+ | class MaClasse { | ||
+ | private type1 attribut; | ||
+ | | ||
+ | public type1 getAttribut(); | ||
+ | public void setAttribut(type1 attribut); | ||
+ | | ||
+ | // constructeurs et méthodes. | ||
+ | |||
+ | } | ||
+ | </ | ||
+ | |||
+ | |||
+ | |||
+ | === Defining Methods === | ||
+ | |||
+ | [[https:// | ||
+ | |||
+ | Une méthode est définie par une **signature** : typeRetour nomMethode(typeParametre1 parametre1, ...) | ||
+ | |||
+ | Pour Java 2 méthodes sont différentes si : | ||
+ | * leurs noms sont différents | ||
+ | * leurs noms sont identiques mais le nombre de paramètres ou le type des paramètres sont différents. | ||
+ | |||
+ | On peut donc avoir plusieurs méthodes avec le même nom du moment que leurs paramètres sont différents. C'est ce que l'on appelle la **surcharge**. | ||
+ | |||
+ | < | ||
+ | Pour Java, deux méthodes de même nom ont même type de retour. Cela évite les ambiguïtés avec des méthodes n' | ||
+ | </ | ||
+ | |||
+ | === Providing Constructors for Your Classes === | ||
+ | |||
+ | [[https:// | ||
+ | |||
+ | On a coutume de présenter (grâce à la surcharge) plusieurs constructeurs. Celui ayant le plus de paramètres étant appelé par tous les autres (avec [[#Using the this Keyword|le mot clé this]]) : | ||
+ | |||
+ | <code java> | ||
+ | // package et imports | ||
+ | |||
+ | class MaClasse { | ||
+ | private type1 attribut; | ||
+ | | ||
+ | public type1 getAttribut(); | ||
+ | public void setAttribut(type1 attribut); | ||
+ | | ||
+ | public MaClasse (type1 attribut) { | ||
+ | this.attribut = attribut; | ||
+ | } | ||
+ | | ||
+ | public MaClasse() { | ||
+ | this(objetDeType1); | ||
+ | } | ||
+ | | ||
+ | // méthodes. | ||
+ | |||
+ | } | ||
+ | </ | ||
+ | |||
+ | === Passing Information to a Method or a Constructor === | ||
+ | |||
+ | [[https:// | ||
+ | |||
+ | === Object === | ||
+ | |||
+ | La partie [[https:// | ||
+ | |||
+ | == Creating Objects == | ||
+ | |||
+ | On n' | ||
+ | |||
+ | [[https:// | ||
+ | |||
+ | On utilisera **toujours** le mot clé '' | ||
+ | |||
+ | <code java> | ||
+ | Point originOne; //déclare une variable pouvant nommer un objet | ||
+ | origineOne = new Point(); // on crée un Point que l'on nomme par origineOne. | ||
+ | |||
+ | Point aPoint = origineOne; // aPoint est un autre nom pour l' | ||
+ | </ | ||
+ | |||
+ | == Using Objects == | ||
+ | |||
+ | [[https:// | ||
+ | |||
+ | <note warning> | ||
+ | Attention à l' | ||
+ | <code java> | ||
+ | new String(" | ||
+ | </ | ||
+ | est faux. Ce sont deux objets différents. Pour | ||
+ | vérifier que leur contenu est identique on utilise la méthode '' | ||
+ | |||
+ | <code java> | ||
+ | (new String(" | ||
+ | </ | ||
+ | est ainsi vrai. | ||
+ | |||
+ | En python c'est le contraire : | ||
+ | * is pour savoir si deux objets sont les mêmes, | ||
+ | * == pour savoir si le contenu de deux objets est identique | ||
+ | </ | ||
+ | |||
+ | <note warning> | ||
+ | Ne vous laissez pas abuser : ''" | ||
+ | </ | ||
+ | |||
+ | === More on Classes === | ||
+ | |||
+ | == Using the this Keyword == | ||
+ | |||
+ | [[https:// | ||
+ | |||
+ | S' | ||
+ | |||
+ | * **dans le premier constructeur**. L' | ||
+ | * **dans le constructeur sans paramètre**. On appelle le constructeur avec un paramètre. | ||
+ | * **dans la méthode**. Elle rend un tableau contenant l' | ||
+ | |||
+ | <code java> | ||
+ | class Exemple { | ||
+ | int x; | ||
+ | | ||
+ | Exemple(int x) { | ||
+ | this.x = x; | ||
+ | } | ||
+ | | ||
+ | Exemple() { | ||
+ | this(42); | ||
+ | } | ||
+ | | ||
+ | Exemple[] encapsule() { | ||
+ | Exemple[] tableau = new Exemple[1]; | ||
+ | tableau[0] = this; | ||
+ | return tableau; | ||
+ | } | ||
+ | |||
+ | } | ||
+ | </ | ||
+ | |||
+ | == Controlling Access to Members of a Class == | ||
+ | |||
+ | [[https:// | ||
+ | |||
+ | Permet de contrôler l' | ||
+ | |||
+ | En Java, on peut contrôler cette visibilité de 4 façons (qui ont leur pendant en [[public: | ||
+ | * '' | ||
+ | * '' | ||
+ | * '' | ||
+ | * aucun modificateur : les classes du package peuvent voir et utiliser la méthode/ | ||
+ | |||
+ | |||
+ | Si l'on ne veut pas s' | ||
+ | * de laisser les attributs sans modificateur (ou à la rigueur en '' | ||
+ | * de placer les méthodes/ | ||
+ | |||
+ | |||
+ | == Understanding Class Members == | ||
+ | |||
+ | [[https:// | ||
+ | |||
+ | Les méthodes et attributs de classes sont caractérisés par le mot clé '' | ||
+ | |||
+ | * **pour la classe principale**. Dans la méthode main bien sûr mais aussi pour les différentes parties du programme principal. | ||
+ | * ** pour les classes sans objet ou les constantes**. La classe [[https:// | ||
+ | * **pour construire des objets**. En utilisant [[http:// | ||
+ | |||
+ | === Nested Classes === | ||
+ | |||
+ | [[https:// | ||
+ | |||
+ | Vous pouvez sauter cette partie en première lecture. Cela permet des techniques de programmation très utiles mais ce n'est pas pour des débutants. | ||
+ | |||
+ | === Enum Type === | ||
+ | |||
+ | [[https:// | ||
+ | |||
+ | Idéal pour traiter avec des constantes comme les jours de la semaine, les couleurs d'un jeu de carte, etc. | ||
+ | |||
+ | |||
+ | ==== Annotations ==== | ||
+ | |||
+ | [[https:// | ||
+ | |||
+ | L'IDE les met souvent tout seul comme '' | ||
+ | |||
+ | Un tutorial sympa (et en français) : [[https:// | ||
+ | |||
+ | ==== Lesson: Interfaces and Inheritance ==== | ||
+ | |||
+ | [[https:// | ||
+ | |||
+ | Grouper les objets par : | ||
+ | * ce qu'ils **sont** : héritage | ||
+ | * ce qu'ils **font** : interfaces | ||
+ | |||
+ | |||
+ | === Interfaces === | ||
+ | |||
+ | [[https:// | ||
+ | |||
+ | Permet de définir des objets par ce qu'ils **FONT**. | ||
+ | |||
+ | Les variables peuvent être définies comme pouvant contenir des objets | ||
+ | [[https:// | ||
+ | |||
+ | === Héritage === | ||
+ | |||
+ | [[https:// | ||
+ | |||
+ | Le mot clé [[https:// | ||
+ | |||
+ | == Object as a Superclass == | ||
+ | |||
+ | [[https:// | ||
+ | |||
+ | Les trois méthodes ici qu'il faudra a priori toujours redéfinir sont : | ||
+ | * '' | ||
+ | * '' | ||
+ | * '' | ||
+ | |||
+ | ==== Number and Strings ==== | ||
+ | |||
+ | [[https:// | ||
+ | |||
+ | === Number === | ||
+ | |||
+ | [[https:// | ||
+ | |||
+ | Les classes et objets associés aux nombres. | ||
+ | |||
+ | <note warning> | ||
+ | **int** n'est pas une classe alors qu' | ||
+ | </ | ||
+ | |||
+ | === String === | ||
+ | |||
+ | [[https:// | ||
+ | |||
+ | Les chaînes de caractères se comportent comme en python. | ||
+ | |||
+ | ==== Generics ==== | ||
+ | |||
+ | [[https:// | ||
+ | |||
+ | Peut être extrêmement pénible et compliqué. Nous serons forcés de l' | ||
+ | |||
+ | <note warning> | ||
+ | Les generics ne fonctionnent qu' | ||
+ | </ | ||
+ | |||
+ | Un [[http:// | ||
+ | |||
+ | ==== Packages ==== | ||
+ | |||
+ | [[https:// |