Le langage Java

Les mots

Langage composé de mots de l'alphabet de a à z, de A à Z et de 0 à 9

Booléens représentés par les valeurs true et false

Constantes caractère représentées entre simples cotes ('a', 'z', ...), constantes chaîne de caractères entre guillemets ("abc'(-678")

Caractères // pour une mise en commentaire jusqu'au bout de la ligne, /* ... */ pour une mise en commentaire sur plusieurs lignes

Les types

Types prédéfinis :

boolean : booléen
char : caractère
byte : entier signé 8 bits
short : entier signé 16 bits
int : entier signé 32 bits
long : entier signé 64 bits
float : réel 32 bits
double : réel 64 bits

Une variable déclarée final est constante.

Exemples de déclaration :

int indice ;

final double valeur = 2.9 ;

Les tableaux

Syntaxe :

char tab[] = new char[100] ;

-> définition d'un tableau de 100 caractères

double mat[][] = new double[4] [4] ;

-> définition d'un tableau à deux indices de 4x4 doubles

Les opérateurs

Identiques à ceux du C/C++ :

Numériques : +, -, *, \, %
Binaires : & , |, ^, >>, <<, <<<, >>>
Comparaison : >, <, >=, <=, ==, !=

Les instructions de contrôle d'exécution

Identiques à celles du C/C++ :

if ( condition ) { ... } ;
switch ( variable ) {
    const1 : { ... }
             break ;
    const2 : { ... }
             break ;
    ...
    default : { ... }
    } ;
for ( init ; condition ; modif ) { ... } ;
while ( condition ) { ... } ;

Les classes et les objets

Classe : Description informatique des caractéristiques d'un objet abstrait (destiné à modéliser un objet réel) -> description des constituants élémentaires de l'objet ainsi que des seules opérations (méthodes) pouvant s'appliquer à cet objet.

Exemple :

class Vehicule {
  int age ;
  float taille ;
  float poids ;
  boolean moteur ;

  int getWeight() {
    return(poids) ;
  }
}

Une classe Vehicule sauvegardée dans une fichier Vehicule.java

Quatre "variables membre" : age, taille, poids et moteur

Une "fonction membre" ou méthode : getWeight
-> poids d'un véhicule

Instance d'une classe : Objet informatique concret généré à partir d'une classe (stocké dans une variable)
Utilisation de l'opérateur new pour effectuer la création de l'objet
Vehicule v = new Vehicule() ;
Constructeur : Méthode spécifique appelée automatiquement lors de l'instanciation d'un objet (identifiée par son nom : celui de la classe et par le fait qu'il n'y a pas de type retourné)

class Vehicule {
  int age ;
  float taille ;
  float poids ;
  boolean moteur ;

  Vehicule() {
    age = 0 ;
    taille = 0.0F ;
    poids = 0.0F ;
    moteur = false ;
  }

  int getWeight() {
    return(poids) ;
  }
}

Possibilité de définir un ou plusieurs constructeurs avec paramètres en plus du constructeur mimimum

class Vehicule {
  int age ;
  float taille ;
  float poids ;
  boolean moteur ;

  Vehicule(int a,float t
        ,float p,boolean m) {
    age = a ;
    taille = t ;
    poids = p ;
    moteur = m ;
  }

...
}

...
Vehicule v = new Vehicule(2,4.6F,1.5F,true) ;
...

static : Une variable ou une fonction membre déclarée static dans une classe est commune à toute les instances de cette classe. Une telle variable ou méthode yyy de la classe Xxxx pourra être utilisée en faisant directement référence à Xxxx.yyy.

class Vehicule {
  ...
  static float taxation ;
  static final int type ;

  static float Taxation() {
    return(taxation) ;
  }

...
}

...
Vehicule.taxation = 100.0F ;
System.out.println(Vehicule.taxation()) ;
...

instanceof : Test d'appartenance d'un objet à une classe par l'opérateur instanceof

if ( donald instanceof Duck) ...

L'encapsulation

Possibilité de limiter la visibilité des variables et fonctions membres définies à l'intérieure des classes.

public : pas de limitation
protected : visible depuis l'intérieur de la classe et depuis classes qui en héritent
private : visible uniquement depuis intérieur de la classe

Exemple :

public class Vehicule {
  public float age ;
  protected float taille ;
  private int poids ;
  private boolean moteur ;

  public Vehicule() {
    age = 1.0F ;
    taille = 1.0F ;
    poids = 1 ;
    moteur = false ;
  }

  public int getWeight() {
    return(poids) ;
  }
}

La déclaration public des classes elles-mêmes répond à un impératif de sécurité, par une déclaration public elles seront rendues accessibles aux autres classes.

L'héritage

Possibilité de décrire une nouvelle classe en la faisant hériter (dériver) d'une classe.

héritage des variables et fonctions membres de la classe mère (superclasse) et des propres superclasses de celle-ci jusqu'à la classe object
possibilité d'ajouter de nouvelles variables et fonctions membres

Exemple :

public class Voiture extends Vehicule {
  public int places ;

  public Voiture() {
    moteur = true ;
    places = 4 ;
  }
}

Important : Impossibilité de faire dériver une classe de plus d'une autre classe

Important : Dérivation implicite de la classe Object pour toute classe ne dérivant d'aucune classe

Le polymorphisme

Déclaration dans une sous-classe A d'une méthode dont la signature est identique (nom, nombre et types d'arguments) à celle d'une méthode de sa superclasse S

Remplacement de la méthode de S par la méthode de A pour les objets intanciant A
Implantation de comportements spécifiques

Les interfaces

Interface : Collection de noms de méthodes sans définition

Indication qu'une classe implante obligatoirement un modèle de comportement (des méthodes) en plus de ceux hérités de sa superclasse

Compilation obligatoire des interfaces

Possibilité d'utilisation comme si elles étaient des classes à la différence qu'elles ne peuvent servir à instancier des objets -> utilisation des interfaces quand on désire indiquer directement des objets implantant leurs comportements

Exemple :

interface Moteur {
public int nombreSoupapes() ;
public float Cylindree() ;
}

public classe V8 implements Moteur {
private int ns ;
private float cyl ;

  public V8(int ns,float c) {
    ns = n ;
    cyl = c ;
    }

  public int nombreSoupapes () {
    return(ns) ;
    }

  public float Cylindree() ;
    return(cyl) ;
    }

  public int rpmMax() {
    return(7000) ;
    }
}

...
private void affichage(Moteur m) {
  System.out.println(m.nombreSoupapes()) ;
  System.out.println(m.Cylindree()) ;
  }
...
...
V8 engine = new V8(32,3500) ;
System.out.println(engine.rpmMax()) ;
affichage((moteur) engine) ;
...

L'API JAVA de Sun

Utilisation d'une directive d'importation import pour indiquer l'utilisation d'une classe existant dans un des packages de l'API de Sun

Exemple :

Import java.util.Vector ;
...
...
Vector v = new Vector() ;
v.addElement(new V8(32,3000)) ;
...

Importation implicite de toutes les classes du package java.lang -> pas d'import obligatoire pour ces classes

Les exceptions

Production d'une exception lorsqu'une erreur intervient dans un programme JAVA

Un programmeur devra obligatoirement gérer les exceptions générées par ses programmes (instructions try et catch) pour traiter les problèmes rencontrés au cours de l'exécution -> programmation de code sans erreur.

Un programmeur pourra programmer des classes générant des exceptions.

Exemple 1 : Gestion d'une exception générée par une tentative d'instanciation d'un objet Float à partir de la chaîne "abc" qui n'est pas une chaîne "numérique".

Try {
  Float f = new Float("abc") ;
  System.out.println(f) ; }
catch(NumberFormatException e) {
  System.out.println(e) ; }

Exemple 2 : Ecriture d'une classe exception, écriture d'une méthode générant cette exception (Intanciation d'une fraction avec un dénominateur égal à 0).

public class MyException extends Exception {

  public String toString() {
    return("Attention") ;
    }
  }

public class Fraction {
  private float a ;
  private float b ;

  public Fraction(float aa,float bb)
                   throws MyException {
    if ( bb != 0 ) {
      a = aa ;
      b = bb ; }
      else {
      throw new MyException() ; }
    }

  public String toString() {
    return(a+" sur "+b) ;
    }
  }

    try {
      Fraction f = new Fraction(1.0F,0.0F) ;
      System.out.println(f) ; }
    catch(MyException e) {
      System.out.println(e) ; }