Java

 

Caractéristique de java :

            Architecture neutre

            Orienté objet

            Distribué

            Compilé et interprété   

            Robuste

            Dynamique

            Sécurisé

Indépendant du système d’exploitation.

 

Limites de Java :

            Moins rapide qu’un vrai exécutable (C).

                        Solutions : Optimiser les machines virtuelles, compilateur JIT

                        (Just In Time).

 

2 types de programmes :

            Application (programme indépendant)

            Applet (Exécuté a automatiquement quand ils sont chargé dans une page HTML.

 

Commentaire :

            Identique au C++

            // sur une ligne

            /* plusieurs lignes */

 

            Javadoc

            /** déscription  pour la création Automatique de documentations.*/

 

Afficher un texte.

            En C++ ( cout<< ‘’hello World !’’<<endl ;

            En Java :

                        System.out.printl(‘’hello World !’’) ;

 

 

 

 

 

 

 

 

 

 

 

 

 

1 exemple d’application : (format :ASCII)

 

            //fichier HelloWorld.java

            class HelloWorld

            {

                        static public void main(String args[])

                        {

                                    system.out.printl(‘’HelloWorld’’) ;

                        }

            }

 

 

Compilation de l’exemple :

                                                javac HelloWorld.java

                                                -g ou –g :none :compile avec ou sans les infos de debug.

                                                -d <dir> spécifie le répertoire de destination des .class .

 

Execution de l’exemple :

                                                Java HelloWorld

 

Les types natifs Java :

           

            Entiers (byte, short, int, long)

            Nombre réels (float, double)

            Caractère (char)

                        128 premiers = codes ASCII ‘a’,’1’

                        ‘\n’ pour un saut de ligne

                        ‘\t’ pour une tabulation

                        ‘\’’ pour une ‘

                        ‘\\’ pour \

            Booléen (true, false)

 

Conversion automatique :

            Erreur :

                        double d =0.0d ;

                        int i = d ;  // ‘’possible loss of precision’’

            Necessite une conversion explicite :

                        double d = 0.0d ;

                        int i = (int)d ; // ok

 

Références :

            En java pas de pointeur, une variable est soit de type natif, soit une référence.

 

 

 

 

 

Les blocs :

            Identique au C

            {

            }

            On peut déclarer les variables à tout instant, elles sont locales et temporaires.

            Les variables sont automatiquement détruite en dehors de sa portée.

 

Les tests

            Identique au C :

 

            if(conditions)   {  }

 

            if() { }

            else { }

 

            switch ()

            {

                        case : break ;

                        default : break ;

            }

 

            ! différence : les expressions à tester doivent être de type boolean.

 

Les boucles

            Identique au C :

           

            while() { }

 

            do { }

            while () ;

 

            for ( ; ; ) { }

 

L’opérateur new 

            Sert à créer des instances d’une classe

                        String s = new String() ;

 

            Ne s’applique pas aux types natifs en Java (sauf pour l’initialisation des tableaux)

 

 

 

 

 

 

 

Les tableaux

            Déclaration similaire au C

                        On peut mettre les [] avant ou après la variable

                        Possibilité de créer des tableaux multidimensionnels

                        L’indexage est protégé (dépassement génère une exception d’erreur)

 

2 exemple : tableaux

 

            //Déclaration

            int [] tInt ;

            float tfloat [] ;

 

            //Création

            int [] tInt2 = new int[4] ;

            double tDboule[] [] = new double[2][3] ;

           

            //Création avec initialisation

            long [] tLong = {3L, 2L} ;

            short [] [] tShort = {{4,5},{1,2,3}

       , null } ;//Dimension

            int [] vide = {} ;

 

Les classes de base :

Les chaînes de caractères

            Deux types :

                        Pour les constantes : String

                        Pour les variables : StringBuffer

            Les types natifs peuvent être convertis

                        String s= ´´total = ´´+3 + ´´CHF´´ ;

            Retrouver la longueur d’une chaîne

                        int lg = s.lenght() ;

 

 

 

 

 

 

            Accès en lecture (String ou StringBuffer) à

un caractère donné de la chaine :

                        .charAt (int index) ;

                                    String s =´´total´´ ;

                                    char c = s.charAt(1) ;  // c = ‘o’

                       

au tableau de caractère donné de la chaîne :

.toCharArray() ; // ou .toString().toCharArray() ;

            char[ ] ctab = s.toCharArray() ; //ctab[] = {´t´,…}

.getChars ( int deb, int fin,

                        char[] dst, int dstdeb) ;

            char [] ctab = new char [s.lengh()] ;

            s.getChars(0, s.length(), ctab, 0) ; //ctab[]=(´t´,…)

           

            Accès en écriture (StringBuffer)

                        A un caractère donné de la chaine

                        .setCharAt (int index, char c) ;

                                    StringBuffer s = new StringBuffer(´´total´´) ;

                                    s.setCharAt(2,´n´) ; // s = ´´tonal´

 

La classe System et les E/S

            Cette classe permet d’accéder à la console pour les entrées et les sorties avec

            out, err pour la sortie standard et d’erreur.

            in pour l’entrée standard

 

 

 

 

 

 

 

3 exemple : lire ligne clavier

            import java.io.* ;

            public class LireLigneClavier

            {

            public static void main (String[] args)

                                    throws java.io.IOException

                        {

                        BufferedReader inr = new BufferedReader

(new InputStreamReader (System.in)) ;

                        System.out.print(´´tapez un nombre ; ´´) ;

                        String s = inr.readLine() ;

                        Int a = Integrer.parseInt(s) ;

                        System.out.println(a*a) ; // imprime a au carré

                        }

            }

 

EXERCICE 1

            Faire un programme qui calcule la moyenne de N notes saisies au clavier

            ( la somme des notes sera calculée au fur et à mesure de la saisie).

            Pas à pas :

            Déclaration des variables :

                        N = nombre de note à saisir

                        I = compteur de 1 à N

                        somme = cumul de la somme

                        note = note saisie par l’utilisateur

                        moyenne = résultat

 

 

 

 

 

            Algorithme :

                        Somme ß 0

                        Saisir N

                        Pour i = 1 à N

                                    Saisir note

                                    Somme ß somme + note

                        Moyenne ß somme/N

                        Afficher (moyenne)

 

            Solution :

import java.io.* ;

class lireligne

{

    public static void main(String args[])

    throws java.io.IOException

    {

    BufferedReader inr = new BufferedReader(new InputStreamReader(System.in));

   

    System.out.print("Entrez le nombre de notes a saisir : ");

    String s =inr.readLine();

    int nbNotes = Integer.parseInt(s);

   

    int somme = 0;

    int i;

    for(i=0; i<nbNotes; i++)

        {

            System.out.println("entez votre note numero : " +i);

            s = inr.readLine();

            somme += Integer.parseInt(s);

        }

    System.out.println("La somme est =" +somme);

    }

}

 

 

 

 

 

 

EXERCICE 2 :

            Faire un programme simulant une calculatrice 4 opérations

            (saisir un nombre, une opération, et un nombre puis afficher le résultat).

            = pour terminer le programme.

 

            Exemple :

            2*5 à10

            4=6 àfin du programme

 

            Pas à pas :

1.      saisir les données (valeurs et opérateurs)

2.      Faire les calculs

3.      Afficher le résultat

 

Déclaration des variables

            float val et val2 = les 2 valeurs courantes de l’opérations

            float res = résultat de l’opération

            Bool fin = fin des calculs ?

            Fin ß faux

            faire {

                        saisir val1, op et val2

                        suivant op

                                    si op =´*´alors res ß val1*val2

                                    si op =´/´alors res ß val1/val2

                                    si op=´+´ alors res ß val1+val2

                                    si op =´-´alors resß val1-val2

                                    si op=´=´alors finß vrai

                        fin suivant

                        afficher res

                        } tant que (non fin)

 

Solution :

 

import.java.io.* ;

class calculette {

public static void main(String args[])throws java.io.IOException

{

            int val1,val2,res = 0 ;

            char oper ;

            boolean fin=false ;

 

BufferedReader inr = new BufferedReader(new  InputStreamReader(System.in)) ;

String sval1, soper, sval2 ;

 

do

{

System.out.println(´´NOMBRE OPERATEUR NOMBRE, par exemple : 5*2´´) ;

System.out.println(´´Operateur = pour terminer \n´´) ;

System.out.println(´´Calcul : ´´) ;

sval1 = inr.readLine() ;

soper = inr.readLine() ;

sval2 = inr.readLine() ;

 

val1 = Integer.parselnt(sval1) ;

val3 = Integer.parselnt(sval2) ;

oper = soper.charAt(0) ; //prendre le premier caractère

 

 

 

 

switch(oper)

{

case ‘*’ : res=val1*val2 ; break ;

case’/’ : res=val1/val2 ; break ;

case ‘+’ : res=val1+val2 ;break ;

case’-‘ : res=val1-val2 ;break ;

case’=’ : fin=true ;

}

if(fin == false)

{

System.Out.Println(val1 + ‘’ ‘’+oper +’’ ‘’+val2+’’ =’’+res) ;

}

}

while(fin !=true) ;

}//main

}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 Java Classes et Objets

 

Notions :

            Classe : c’est un type d’objet

            Définition d’un objet en terme de

                        Conteneus (variables)

                        Méthodes à exécuter pour accéder /modifier son contenu

           

Objet : c’est une instance d’une classe

Créé par un constructeur (méthode spéciale fournie par la classe)

 

Héritage : Relation entre les classes, donc entre les objets.

 

Classe

Définit un type d’objet en termes de

            Variables = stockage d’état

            Méthodes = opérations changeant l’état de l’objet

 

            Different type de variable

                        Variable de classe : commun à tous les objets

                        Variable d’instance : Lié à une instance d’objet.

 

            Variable d’instance : Utilise ces mots clés comme qualificatifs (modifier)

                        Public : indique un accès libre à la variable

                        Private : indique un accès exclusif par les méthodes de classe

Protected : indique un accès réservé aux méthode de la classe et de ses descendants.

Sans mots clef : accessible seulement par les autres classes du même package.

 

 

Variable d’instance, exemple :

 

            class Compte

            {

                        public int numero ; //variable d’instance

                        private float solde ;//variable d’instance

static public int nb2comptes = 0 ; //variable de classe

{

 // bloc d’initialisation

            numero = 0 ;

            solde = 0.0f ;

            nb2compte++ ;

}

            }

 

Objet :

Instance d’une classe :

            Contient les valeurs associées à un objet particulier

            Pour chaque variable d’instance de la classe qui  le définit.

 

Difference classe VS objet

Classe : définit le modèle de l’objet, de ses propriétés et attributs généraux

            Ex : classe vélo couleur, nombredevitesse

 

Objet : Incarne une instance avec des paramètres propres :

            Ex : objet vélo              couleur=bleu, vitesse = 10, …

 

 

 

 

 

Constante

            Déclaration, puis première initialisation

                        final int numeroBanque ;

                        numeroBanque = 2345 ; // ok

                        numeroBanque = 2345 ; // erreur (car valeur est final)

            Déclaration avec initialisation

                        final int numeroBanque = 2345 ;

                        numeroBanque = 2345 // erreur

           

Exemple de constante : Float

Champs :

            public final static float POSITIVE_INFINTY

            public final static float NEGATIVE_INFINITY

            public final static float NaN

            public final static double MAX_VALUE

                        1.40129846432481707^e-45f

            public final static double MIN _VALUE

                        3.40282346638528860e+38f

 

Variable de classe 

            Utilise le mot clé static .

            class Compte

            {

            static int nb2comptes = 0 ;

            static String nomBanque = ‘’MiraB’’ ;

            static finl int numeroBanque ;

            static

                        {

                        // bloc d’initialisation static

                        numeroBanque = 0 ;

                        }          }

Accès à une variable d’un objet

            Se fait en précisant le nom de l’objet suivit de ’’.’’ et du nom de la variable

 

            Compte client1 = new Compte() ;

            if(client1.numero == 1)

            client1.solde += 10000.0f ;

 

            class Compte

 {

                        public int numero ;

                        private float solde ;

                        public float calculerSolde()

                        { return this.solde ; }

                        }         

            class AutreCompte

                        {

                        private Compte c = new Compte() ;

                        public float autresolde()

                        {

                        if (c.numero >0) //ok

                                    return c.solde ; //erreur

                                    return 1.0f ;

                        }

                        }

 

 

 

 

 

 

 

Structure d’un programme Java

 

            3 sections optionnelles :

                        Déclaration de package

                        Import de packages ou de classes : import

                        Déclarations des classes et des interfaces du fichier.

            Package :

                        Définit un groupe de travail dans lequel les classe doivent être rangées

                        Cette directive doit être placée au début du fichier

                        Le nom de package correspond à un répertoire dans lequel les

                        classes doivent être placées.

 

                        Exemple

                        package alternet ;   // Répertoire : alternet/

                        class AltClasse1 {} // alternet/Altclasse1.class

           

            Import :

Permet de charger des classes d’autre packages en vue d’utiliser leurs fonctionnalités.

On peut spécifier le nom du package qui contient la ou les classes

 

Exemple :

import cePackage.* ; (nom du package d’ou on utilise la classe)

import package.autreClasse ;

import cetteClasse ;

 

 

 

 

 

 

            Déclaration de classses

                        Syntaxe : qualificatif class nomClasse{}

                                    public class Classe2

                                    { // corps de classe2 }

                        Les qualificatifs sont

public : indique la classe exporté par le fichier .java (même nom que le fichier.java

final : indique que la classe ne peut pas être dérivée

abstract : obligatoire pour les classes contenant les méthodes abstract

            (on ne peut pas créér d’instance d’objet de ces classes)

 

Le corps d’une classe peut contenir :

            des dclarations de varialbes

            des déclarations de méthodes

            des blocs d’intialisatilons

            des classes internes (déclarée à l’interieur d’une classe)

 

Classe interne :

Les qualificatifs sont :

public, private, protected ( comme variable d’instance)

final, abstract (comme les classes externes)

static ( indique que la classe est indépendante des instances d’objet)

 

 

 

 

 

 

 

 

 

Création de classe interne static

 

class Externe

{

 static class Interne {}

 }

class Autre

{

public Externe.Interne ei ;

            { ei= new Externe.Interne() ; }

}

 

Création de classe interne non static

 

class Externe

{

oublic class Interne {}

}

final class Autre

{

            public Externe e = new Externe() ;

            public Externe.Interne ei ;

            {

            ei= new Externe.Interne() ; //erreur

            ei= e.new Interne() ; //ok

            }

}

 

 

 

 

Classe interne non static

Dépend de l’instance de la classe externe

2 objets d’une même classe externe peuvent stocker des instances internes différentes

 

                                    Conserve une éférence vers cette classe

                                    Permet d’appeler les méthodes de la classe externe

 

                        Classes internes imbiquées

                                    Une classe interne peut à son tour contenir des classes internes

 

                                    class Externe

                                    { public class Interne1

                                      {

                                                private class Interne2 {}

                                       }

                                    }

 

Compilation : chaque classe d’un fichier .java génère un fichier .class

                        lors de la compilation.

            Pour une classe interne le nom du fichier :

                        Externe$Intrne.class

                        Externe$Interne1$interne2.class

 

 

 

 

 

 

 

 

Exemple :

// 1 debut du fichier maClasse.java

 

//déclaration de package :

package MonPackage

 

// 2 déclaration d’Import

 

//classe sans package :

 import MaClasse

// classe d’un package :

import MonPackage.MaClasse ;

//toutes les classes d’un package

import MonPackage.* ;

 

//3 déclarations des classes

            public class MaClasse

            (1 seule classe déclarée public, par convention porte le même nom que le fichier.)

            {//corps de MaClasse}

           

            class MaClasse2

            { //corps de Maclasse2}

 

 

 

 

 

 

 

 

 

Introduction à la programmation objet

 

La programmation par objet PPO

 

On peut dire que la complexité des problèmes qu’opn est capable de resoudre est directement proportionnelle au type et à la qualité de nos capacités d’abstraction.

 

Le fortran, Basic et le C sont de nettes amélioration par rapport au langage assembleur mais leur abstraction première requiert une réflexion en termes de structure ordinateur plutôt qu’à la structure du problème.

 

L’approche orienté objet va un cran plus loin en fournissant un concepteur des outils premettant de représenter des éléments dans l’éspace problème.

L’idée est que :

            Le programmeur est autorisé à s’adapter à l’ésprit du problème en ajoutant de nouveaux types d’objet, de façon à ce que, quand on lit le code décrivant la solution,

on lit aussi quelque chose qui décrit le problème.

 

La programmation orienté objet (POO) permet de décrire le rpoblème avec les termes même du problème plutôt qu’avec les termes de la machine ou la solution sera mise en œuvre.

Tous les objets ont leur propre caractéristique et comportement.

1.      Toute chose est un objet (=variable amélorée)

2.      Un programme est un ensemble d’objet se disant les uns aux autre quoi faire.

3.      Chaque objet à son propre espace de mémoire composé d’autres objets.

4.      Chaque objet est d’un type précis.

5.      Tous les objets d’un type particulier peuvent recevoir le même message.(=substituablité)

 

 

 

Un objet dispose d’une interface :

Une classe décrit un ensemble d’objet partageant des caractéristiques communes et des comportements.

 

Une fois qu’une classe est créée, on peut créer autant d’objets de cette classe qu’on veut et les manipuler comme s’ils étaient les éléments du problème.

 

Comment utiliser un objet ?

            Il faut pouvoir lui demander d’exécuter une requète.

Chaque objet ne peut traiter que certaine requetes (définis par son interface).

 

Limite d’accès :

            Java utilise 3 mots clés pour fixer les limites au sein d’une classe :

                        public (tt le monde à accès au définition)

                        private (personne y a accès)

                        protected (seul la classe et ses dérivée y ont accès)

                        par defaut (accès dans le même package sinon se comporte en private)

 

 

 

 

 

 

 

 

 

 

 

 

 

 Les méthodes

 

Définition : fonction, procédure définie dans une classe.

On distingue

            Les méthodes de classe (invoquées sans faire référence à un objet)

Les méthodes d’instance (invoquées pour une instance d’objet)

 

Encapsulation : séparation entre le service rendu par la classe et son implementation.

Il est judicieux de cacher les varaibles d’instance private en fournissant un accès par des méthodes qui testent la validité des paramètres.

 

Déclaration d’une méthode (symilaire au C)

            type nomDeFonction (type param1,…)

            {

            }

 

Pas de déclaration sans définition ( sauf méthode abstract c.f héritage)

 

Méthode de classe static :

            class compte

            {

            static String nomBanque = "mirab " ;

            static bool initialise ()

            {

            return true;

            }

            static String getnomBanque()

            {

                        return nomBanque

            }

            }

Méthode d'instance :

            class Compte

            {

            private float solde;

            private boolean testSolde()

            { … }

            public float getSolde()

            {

                        if (testsolde())

                                    retun solde; //défini après

                        return 0.0f;

            }

            }

 

Autres qualificatifs :

            native : indique un code spécifique à une architecture matérielle (C/C++)

                        donc non portable !

            synchronised : bloque l'accès à l'objet durant l'opération.

                                    Utile pour garantir les opérations en mode d'exécution concurrente.

 

Pas de fonction globale mais fonction de classe :

class A

{

            public static float puiss_n(float x, int n)

            {

            float puiss = 1.0f;

           

            for ( ; n > 0; -- n)

                        puiss *= x;

                        return puiss;

            }          }

Appel :

class b

{

            static public void main (String args[])

            {

            A.puiss_n(3.0f, 5);

            }

}

 

Ordre des déclarations quelconque:

class Compte

{

            private bool testSolde()

            { … }

            public float getSolde()

            {

                        if (testSolde())

                                    return solde; //défini après

                        return 0.0f;

            }

            private float solde;

 

Surcharge de méthode :

interdit de surchargé la fonction par type de retour :

            public int methodeCoue()

            { retun1 ; }

            public boolean methodeCoue() //erreur

            { return true ; }

 

 

 

Constructeur :

            méthode spéciale :

                        appelée pour crée un objet

                        reprend le nom de la classe par convention

                        pas de type

                        Qualificatifs : public, private

Par défaut : constructeur public et sans paramètre qui ne fait que l'allocation mémoire.

 

class Compte

{

            public Compte()

            { solde = 0.0f; }

            public Compte(float solde1)

            { solde = solde1; }

            private float solde;

}

 

Appel d'un constructeur : (new)

class Comptablilite

{

            private Compte compte1;

            public Comptabilité ()

            { compte1 = new Compte(); }

            public Comptabilité (Compte c)

            { compte1 = c; }

}

 

 

 

 

Destruction des objets :

            Réalisée automatiquement par le garbage collector

            quand l'objet n'est plus utilisé

            pas forcement immédiatement

           

            Le garbage collector appelle la fonction finalize() juste avant de détruire un objet.

 

Passage de paramètres :

Pour les types de base = par valeur (il faut utiliser une classe conteneur pour les modifier).

Pour les objets = par référence.

 

exemple :

                        class Compte

{

 public Compte()

 { reset(this); }

private void reset(Compte c)

{ c.solde = 0.0f; }

 private float solde;

}

 

 

 

 

 

 

 

 

 

 

Contre exemple :

class Compte

{         

            public Compte()

            {

            reset(this.solde); //passage par valeur

            }

            private void reset (float s)

            { s = 0.0f; }

            private boolean reset (float s) // erreur

            { s = 0.0f; return true; }

            private float solde;

}

 

Paramètre constant final :

Un paramètre comme une variable locale peut être qualifié de constant

Avec le mot clé final :

                        public void reset (final Compte c) {}

            Un paramètre final ne peut pas être modifié

                        compte b = new Compte ();

                        c = b // erreur

            Mais l'objet référencer peut être modifié

                        c.val = b.val; // ok

 

 

 

 

 

 

 

 

Classe conteneur :

Pour pouvoir modifier un type de base passé en parmètre.

class DoubleCont // classe conteneur

{

            public double val = -1.0;

            public DoubleCont ()

            {}

            public DoubleCont (double v)

            { val = v;}

}

class Compte

{

            public Compte ()

            {

            solde = new DoubleCont();

            reset (this.solde);

            }

            private void reset (DoubleCont s)

            { s.val = 0.0; }

            private DoubleCont solde ;

}

 

 

 

 

 

 

 

 

 

 

Les exceptions : interruption de l'exécution du programme (erreur).

 

try : sert à délimiter un bloc dans lequel une exception peut survenir

            try

            { // bloc d'instruction}

 

catch : associé à try {}, sert à spécifier une action pour un typde d'excepetion donné

            catch (TypeException1 e)

            { // instruction gérant l'erreur }

 

finally : associé à try {}, sert à spécifier une action à effectuer erreur ou pas.

            finally

            { //instruction finales }

 

Exemple :

public Object securedPop (pile p)

{

            Object o = null;

            try { o = p.pop(); }

            catch (IOEception e)

                        { System.err.println("Erreur IOException : " + e.getMessage() ); }

            finally

            {

            if (o == null)

                        system.out.println("objet null!");

            return o ;

            }

}

 

 

 

throw : génère une exception sous forme d'un objet de type donné, Throwable …

            throw objetException;

 

indique qu'une classe ou méthode est suceptible de générer une exception de type donné.

class X throws objetExcption;

 

Exemple Throws :

public Object pop() throws IOException

{

            object obj ;

            if (size == 0)

                        throw new IOException();

            obj = objectAt (size – 1 );

            setObjectAt (size – 1, null);

            size -- ;

            return obj;

}

 

 

 

 

 

 

 

 

 

 

 

 

 

Héritage

 

Hiérarchie des classes :

            On peut organiser les classes sous formes de hiérarchie

            En Java, une classe peut avoir au plus une classe parente directe.

                        qualficatif class X extends Y{}

                        à la X hérite de la classe Y

 

Une sous classe hérite :

            Des paramètres des classes parentes

            Des méthodes des classes parentes (super classes)

           

Elle peut :

Soit redéfinir des méthodes de la classe parente (overload)

Soit les réutiliser et ajouter ses propres paramètres et méthodes.

 

Exemple :

class Compte

{

            private int numero;

            public float solde;

            public Compte()

            {

                        numero = 0;

                        solde = 0.0f;

            }

            public float CalculerSolde ()     

            { return solde; }

            public void CahngerNumero (int n )

            { numero = n ; }

}

class CompteDepot extends Compte

{

            public float operations [];

            public int nbop = 0 ;

            public CompteDepot () {}

            public float CalculerSolde ()

            {

            for (int i = 0; i < nbop; ++i)

            solde += operations [i]

            nbop = 0;

            return solde;

            }

}

 

 

Utilité de l'héritage :

            Généralement utilisé pour modifier le comportement d'une classe( spécialisation).

            Réutilisation de méthodes communes.

            Empêche la modification directe de la classe existente.

 

Héritage versus compostion

Héritage se fait sur des classes partageant des mêmes fonctionalités (nombreDeroues, nombreDePassager).

 

Le lien entre des classes sans rapport se fait par simple composition.

à Une classe autobus peut utiliser une classe roue mais pas en hériter !

 

Constructeur & Héritage :

            Lors de la création d'une instance (objet)

                        les constructeurs de toutes les classes parentes sont appelés,

                        dans l'orde parent -> enfant.

Constructeur :

            On peut rediriger l'appel d'un constructuer vers un autre avec :

            this(param, …) pour un constructeur de la même classe.

            super(param, …) pour un constrcuteur de la classe parent.

 

Exemple : Entier

class Entier

{

            public int _e;

            Entier (int i)

            { _e = i ; }

            Entier ()

            { this(0); }

}

class EntierPos extends Entier

{

            entierpos(int i )

            {

            super(i);

            if (i>=0)

            _e = 0;

            }

            EntierPos()

            {

            super(0);

            }

}

 

 

 

 

Appel super() implicite :

class EntierPos extends Entier

{

            EntierPos (int i)

            { //super(); implicite

            if (i<0)

            _e = 0 ;

            else

            _e = i;

            }

            EntierPos()

            { super(); }

 

            Conséquences :

            Il faut soit :

                        créer un constructeur sans paramètre dans la super classe.

                        soit appeler explicitement super(params, …)

                        dans  les constructeurs de la classe.

 

Autre utilisation de super :

            On peut utiliser ce mot clé pour appeler des méthodes de la classe parente directe.

            class CompteDepto extends Compte

            {

            //…

            public CompteDepot (int num)

            { super.ChangerNumero(num) ; }

            }

 

 

 

 

Redéfinition de varfiable :

Lorsqu'une variable d'une super classe est redéfinie dans une sous classe en respectant exactement son nom, elle masque la variable de la super classe.

 

class Entier

{ public int _e; }

class EntierPos entends Entier

{ public int _e ; }

 

Exemple : Qualificatifs 

class Entier

{

            public int e;

            protected int f;

            private int g;

            Entier ()

            {

            e = 0;

            f = 1;

            g = 2;

            }

}

class EntierPos extends Entier

{

            EntierPos()

            {

                        e = 0 ;

                        f = 1 ;

                        g = 2; // non! car private !

            }

}

Exemple 2 : qualificatifs

class Entier

{

            public int e;

            prototected int f;

            private int g;

            Entier ()

            {

                        e = 0 ;

                        f = 1;

                        g = 2;

            }

}

class Autre // ne dérive donc pas

{

            Autre(Entier ent)

            {

            ent.e = 0;

            ent.f = 1; // non car protected = seulement pour les mêmes classes ou parentes

            ent.g = 2; // non car private.

 

Redéfinition d'une méthode :

            Lorsqu'une méthode d'une super classe est redéfinie dans une clase en respectant :

            son nom, le nombre, l'ordre et les types des paramètres elle remplace la méthode

            de la super classe pour les objets de cette sous classe.

 

class Entier {             public int a ()             { return 0; } }

class EntierPos extends Entier { public int a()             { return 1 ; } }

 

 

 

Qualificatifs de classe :

            qualif.class X [extends super X] {}

           

            Les qualificatifs sont :

                        final : la classe ne peut être dérivée (pas de sous classe)

abstract : utilisé pour fournir des méthodes et des champs commun à toutes les classes qui en dérivent.

public : désigne la classe correpsondant au nom de fichier, une seule par .java

 

Autre qualificatifs de méthode :

Rappel : public, protected, private, static, native, synchronised

En + :

            final : indique que la méthode ne peut pas être redéfinie dans une sous classe.

abstract : défini un modèle de méthode sans corps qui doit être redéfini dans toute sous classe dérivée.

 

Utilité des classes abstraites :

            Permet de modéliser des concepts qui n'ont pas de sens en termes d'existence.

 

 

 

Exemple de la nourriture (concept abstrait) :

abstract class Food

{

            abstract public boolean isFruit();

}

class Carot extends Food

{

public boolean isFruit

{

            return true;

}

}

class Apple extends Food

{

public boolean isFruit()

            { return true; }

}

class Chocolate extends Food

{

            public boolean isFruit()

            { return false; }

}

 

 

 

 

 

 

 

 

 

Interface & Applet

Interface:

déf : c'est une collection de définition de méthode sans implémentations.

Syntaxe : qualificatif interface I extends J

            {}

            qualificatifs :

absent : l'inerfeace n'est utilisable que par les classes du même package.

public : l'interface est utilisable par toutes les classes (1 par fichier)

 

Interet :

Permet de savoir qu'une classe possède ces méthodes, se comporte de telle manière.

Relation avec une classe

            class C implemets I //,k,…

            { // implémentation de toutes les méthodes de I }

 

Autre utilisation des interfaces :

Masquage de classe d'implémentation.

Certaine classe java sont cachées derrière une interface commune.

Permet de créer des classe liées à differents système d'exploitation.

 

Interface vide :

            Permet de créer une catégorie de classes :

chaque classe implémentant ce type d'interface appartient à telle ou telle catégorie.

Pour tester si la classe d'un objet appartient à une catégorie, il suffit d'utiliser l'opérateur instanceof() avec le nom de l'interface.

ex : interface Cloneable

 

Déclaration d'un ensemble de constantes : utiliser dans des classes sans liens d'héritage.

interface ConstatntesCommunes

{ // déclaration des constantes A,B,C

}

class Classe1 extends SuperClasse1 implements ConstantesCommunes

{//les constantes A,B,C sont utilisables dans la Classe1

}

class Classe2 extends SuperClasse2 implements ConstantesCommunes

{//Les constantes A,B,C sont utilisables dans la classe Classe2

}

 

Exemple d'interface :

            public interface appareilElectrique

            { // teste si l'appareil est enclenché

                        public boolean estEnclenché();

/* on appelle cette méthode lorsqu'on branche  l'aapareil dans une source de courant active (=true) */

public void alimenté(boolean alim);

            }

Exemple de classe

            Class lampe implements appareilElectrique

            {

            private boolean allumé = false;

            public boolean estEnclenché()

                        { return allumée;}

            public void alimenté(boolean alim)

                        {allumée = alim;}

 

 

 

Differences avec les classes abstract

            Une interface ne peut définir de variable seulement des constantes.

            Une classe ne peut hériter que d'une seule super classe (abstract incluse)

            Mais elle peut implémenter plusieurs interfaces.

            On peut implementer des méthodes (non abstract) dans une classe abstract,

            Aucune implémentation accepetée dans une interface.

 

Héritage des interfaces :

Attention une classe qui implémente une interface qui hérite d'une super-interface doit implémenter toutes les méthodes définies dans ces interfaces.

            interface A

            { // Déclaration des méthodes de A }

            interface B extends A

            {//Déclaration des méthodes de B}

            class Classe1 implements B

            { // définitions des méthodes de B et A }

 

Interface comme type d'objet :

            Le nom d'une interface peut être utilisé comme type d'objet.

Seules des instances de classes implémentant cette interface peuvent être assignées à des variables de ce type.

            public interface A

            {//Déclaration méthodes A }

            class ClasseA implements A

            {

                        public void méthode(A objetdetypeA)

                        { objetdetypeA = new ClasseA();}

            }

 

 

 

Tout objet de type interface X sont garantis d'avoir les méthodes déclarées dans cette interface X.

            public interface A

            {public int méthodeA(A objetdetypeA);}

            class ClasseA implements A

            {

public void méthodeC(A objetdetypeA);

                        {objetdetypeA.méthodeA();}

                        public int méthodeA(A objetdetypeA)

                        {…}

            }

 

Application & Applet

Rappel :

            Application :

                        Programme indépendant

                        Point d'entrée du programme

                                    public static void main(String [] args)

            Applet :

                        Programme téléchargeable

                        Executé automatiquement quand ils sont integrés à l'intérieur des pages

                        HTML.

 

Applet Java :

            La classe d'un applet doit :

                        dériver de la classe Applet, être public

                        avoir un constructeur public sans paramètre

                                    public class monApplet exetends Applet

                                    {

                                                public monApplet (){}

                                    }

            Pour l'exécution il faut 2 fichiers :

                        L'exécutable de l'applet : monApplet.class

                        Le fichier .html qui décri l'applet au navigateur

                        tag html :

<APPLET CODE =monApplet.class WIDTH=150 HEIGHT=25></APPLET>

 

Exemple Hello World :

            import java.applet.Applet;

            import java.awt.Graphics;

            public class AppletHelloWorld

                        extends Applet

            {

                        public void paint(Graphics g)

                        { g.drawString("Applet Hello World",20,20);

                        }

                        public static void main (String [] args)

                        { System.out.println("Applet Hello World");

            }

 

Syntaxe complète des tag html

            <APPLET CODE=ClasseApplet.class

                        WIDTH = largeur, HEIGHT = Hauteur

                        CODEBASE ="répertoire" ALT="marche pas"

                        NAME="NomApplet"

                        ALIGN=alignement

ARCHIVE="fichier.jar"> Message HTML pour les clients non java</applet>