8 Présentation du langage Java

Survol des principaux traits de Java : noyau du langage, couche objet, types

Slide: 1

JAVA

Simple
Orienté Objet
Typé
Compilé/Interprété
Indépendant de l'architecture machine
Distribué
Processus Légers (Threads)
Robuste
Petit
Rapide
Sûr
à chargement dynamique

Slide: 2

Historique

Þ 1994, Java SUN
James Gosling (emacs, NeWS)

``Un coktail innovant de techniques éculées!''

``L'originalité de Java est de n'en avoir aucune!''

Influences C, C++, Lisp, ML, Modula3

Slide: 3

Mise en Oeuvre

Slide: 4

JDK

Slide: 5

Noyau impératif

à la C

Expressions

expression :=  variable
      |  operateur expression
      |  expression operateur
      |  expression operateur expression
      |   ( expression )
      |   (type de base) expression
      |  expression ? expression
                    : expression
      |  variable = expression
      |  variable operateur= expression

Slide: 6

Types de base

type	tnb bit		défaut
`boolean`	false,true	1	false
`char`	Unicode	16	`\u0000`
`byte`	tous signés	8	0
`short`	`` ``	16	0
`int`	`` ``	32	0
`long`	`` ``	64	0
`float`	IEEE 754	32	0.0 (F)
`double`	`` ``	64	0.0 (D)

Remarque Ces valeurs ne sont pas des objets, il existe cependant des classes associées qui sont Boolean, Char, Byte, ..., Double.

Slide: 7

Exemples d'expressions

z=18                           x = x + 1
x += 1                         x++
(byte)i                        (z % 3) << 2
(x<2) ? 2.7 : 3.14
(x != null) || (y >= 3.14)
(b = !b) & (( i ^= ~i) == 0)

s + "Hello" : concaténation
"an " + 1998 : avec conversion

Stricte séparation entre booléens et entiers
Non conversion pointeur - booléen

Slide: 8

Instructions

instruction ::= { instruction; ... }
    | if ( bool) {instructions};
    | if ( bool ) {instructions}
      else {instructions}
    | L: while (bool) {instructions}
    | L: do {instructions} while (bool);
    | L: for (expressions;
              bool;
              expressions)
           {instructions}
    | L:switch (expressions)
          {case constant : intruction;
            ... default : instruction;}

continue label;
continue;
break label;
break;

Slide: 9

Exemple d'instructions

                                  i=1;
for (i=1; i < j ; i++) {          while (i < j) {
  if  (i*i > j ) break;             if  (i*i > j ) break;
                                    i++;
}                                 }

switch (x % 5) {
  case 0: { ... ; break;}
  case 1: case 3: { ...; break;}
  default: {... }
}

Slide: 10

Types des variables

les types de base
les noms de classe
les noms d'interface
les types tableaux

Slide: 11

Variables locales

à l'intérieur d'un bloc

{ // debut du bloc 1
  ...
  int i;
  int j = 18;
  ...
  int h = 22;
  { // debut du bloc 2

    int w = J + 4;
    // float i = 3.14;
 
  } // fin du bloc 2

  { double w = 3.14;
    ...}
} // fin du bloc 1

  for (int i = 0; i < 10; i++) { ...}

Slide: 12

Premier programme

indentation

/*premierprogramme
calculdefibonacci
*/

class Fibo {

public static void main (String [] args){
int i;
int j = 1;
int n = 8;
int r = 0;

for (int v = 1; v < n; v++) {
r = r + j;
i = j;
j = r;
}//quevautrensortie?
}
}

Slide: 13

Tableaux

type [] : un type suivi du symbole []

Déclaration

instruction ::= type [] variable;
              | type [] variable  = {value ...} ;

Création

expression ::= new type [taille];

Allocation dynamique de l'espace
Vérification des indices - indice à partir de 0
Pas de dimension multiple : utilisation de tableaux de tableaux.

Slide: 14

Tableau : un exemple

{ int [] ft;
  int i;
  int n = 8;

  ft = new int [n+1];
  ft[0]=1;
  ft[1]=1;
  for (i = 2; i < ft.length; i++) {
    ft[i] = ft[i-1] + ft[i-2];
  }
// que contient ft a`la sortie
}

Slide: 15

Tableaux de Tableaux

...
int [][] m,t;
int p = 4;
int q = 5;

m = new int [p][q];
t = new int [q][p];
// remplissage
for (i=0; i<p; i++) {
  for (j=0; j< q; j++) {
    m[i][j] = i*j;
  }
}
// transposee
for (i=0; i<p; i++) {
  for (j=0; j< q; j++) {
    t[j][i]=m[i][j];
  }
}
...

Slide: 16

Tableaux (suite)

dimension possiblement hétérogène

int [] [] a;
a = new int [5] [];
a[0] = new int[1];
a[1] = new int [ a[0].length + 1];
a[0][0] = 33;
a[2].length;   // BOOM !!!!

Les tableaux sont des objets avec une classe associée.

Slide: 17

Généralités

Encapsulation

Classes et Instances

Surcharge

Héritage

Redéfinition et Liaison Retardée

Polymorphisme et Sous-Typage

Slide: 18

Terminologie Objet

classe = description des données et des procédures qui les manipulent Þ définit des comportements
objet = instance d'une classe (possède tous les comportements de la classe)
méthode = action (procédure, fonction) que lón peut effectuer sur un objet
envoi de message = demande d'exécution d'une méthode

Slide: 19

Déclaration de Classes

[ modifieur ]* class la_classe [ extends la_superclasse ] {
  // champs
  [modifieur]* type champ [ = expression] ;
  // constructeurs
  [modifieur]* la_classe ( [type variable]*) {
       instructions // sans return
  }
  // methodes
  [modifieur]* TypeRetour methode ([Type variable)*)
                   [throws [exception]+] {
            instructions // avec return
  }
}

Slide: 20

Statique ou Dynamique

modifieur static variable ou méthode de classe!!!

variables de classe ¹ variables d'instance
méthodes de classe ¹ méthodes d'instance

Par défaut dynamique (non statique) Þ variables ou méthodes d'instances!!!

Possibilité de mélanger les 2.

Slide: 21

Java statique : programmation modulaire

Les variables et méthodes de classes :

sont déclarées avec static
existent dès le chargement de la classe (sans instance)
existent en un unique exemplaire
accessible par la notation ``point''

Une classe qui ne contient que des champs statiques peut être considérée comme un module classique (Unit Pascal) :
où les méthodes sont les fonctions du modules et les variables les variables globales.

Slide: 22

Exemple en Java statique

indentation

class ES {

static void writeln( String s) {
System.out.println(s);
}

}

class TestES {

public static void main (String [] args) {
ES.writeln("Salut tout le monde");
}
}

Enfin, un point d'entrée d'un programme est une classe qui contient une méthode public static void main ... : java TestES

Slide: 23

Java dynamique : programmation objet

Les variables et méthodes de d'instances :

ne sont pas déclarées avec static
sont allouées à la création d'une instance (new)
existent pour chaque instance
accessible aussi par la notation ``point''

o.m(a) : envoi du message m avec le paramètre a sur l'objet o dúne classe c.

Slide: 24

Constructeur

Chaque classe possède au moins un constructeur pour initialiser un nouvel objet de ce type.

méthode de même nom que la classe
sans type de retour
appelé dès l'allocation (new)

Slide: 25

Surcharge

La surcharge (overloading) permet de définir au sein de la même classe des méthodes de même nom qui diffèrent par le type des paramètres ou par le type du résultat.

y compris pour les constructeurs.

Slide: 26

Classe Point

indentation

class Point {
//variablesd'instance
int x, y;
//constructeurs
Point(int a, int b){x=a;y=b;}
Point(){x=0;y=0;}
//methodesd'instance
void moveto (int a, int b){x=a;y=b;}
void rmoveto (int dx, int dy){x+=dx;y+=dy;}
void affiche(){ES.writeln("(" + x + "," + y + ")");}
double distance(){return Math.sqrt(x*x+y*y);}
}

Slide: 27

Programme test de Point

indentation

class Test {

public static void main(String args[])
{
Point p0 = new Point();
Point p1 = new Point(3,4);

p0.affiche(); p1.affiche();
p0.rmoveto(7,12);
p1.rmoveto(5,6);
p0.affiche(); p1.affiche();
if (p0.distance() == p1.distance())
ES.writeln("c'est le hasard");
else
ES.writeln("on pouvait parier");
}
}

Slide: 28

Héritage

Avantage principal de la programmation objet :

Extension du comportement d'une classe existante tout en continuant à utiliser les variables et les méthodes décrites par la classe originale.

Toute définition de classe étend une classe existante.

Si l'on ne précise rien on étend la classe Object
Þ on hérite toujours de quelqu'un!!!

Slide: 29

Exemple d'Héritage

indentation

class PointColore extends Point {

String c;

PointColore(){c="blanc";}
PointColore(int a, int b, String x){moveto(a,b);c=x;}

void affiche_bis(){
ES.writeln("(" + x + "," + y + ") de couleur " + c);
}
}//findelaclassePoinColore

Slide: 30

Redéfinition

La redéfinition (overriding) permet de définir une méthode de même nom et de même signature (type) qu'une méthode héritée.

Ce sera donc cette dernière qui sera appelée lors de l'envoi d'un message de ce nom avec les paramètres correspondants.

indentation

class PointColore extends Point {
String c;
PointColore(){c="blanc";}
PointColore(int a, int b, String x) {
moveto(a,b);c=x;
}
void affiche(){//redefinition
ES.writeln("(" + x + "," + y +
") de couleur " + c);
}
}//findelaclassePointColore

Slide: 31

this et super

this correspond à l'instance qui exécute la méthode. Tout envoi de message sans récepteur est un envoi à this (paramètre implicite).

Utile pour distinguer les variables locales ou les paramètres des variables d'instance. :

void Point(int x, int yy){ this.x=x; y = yy;}

En cas de redéfinition d'une méthode, il peut être utile d'appeler la méthode ancêtre : super

void affiche() {
  super.affiche();
  ES.write("de couleur "+c);
}

Slide: 32

Retour sur les constructeurs

Un constructeur dúne classe descendante effectue un appel explicite au constructeur ancêtre sans paramètre (super()).

Pour appeler un constructeur ancêtre avec paramètres, il faut expliciter l'appel : super(3,2.1)

Comme toute classe descend au moins d'Object, un constructeur est toujours appelé au new.

Slide: 33

Liaison retardée

Le choix de la méthode s'effectuera à l'exécution (runtime).

Intérêts :

permet donc de modifier facilement le comportement d'une classe
y compris pour une classe compilée (sans le source)
autorise le polymorphisme d'inclusion (voir sous-typage)

Slide: 34

Exemple

indentation

class InputString{
String txt;
InputString(){txt="";}
String value(){return txt;}

void input(String msg) {
ES.write(msg + " : ");
txt=this.read_str(); //
ES.writeln();
}

String read_str() {
String s = new String();
char c;
while ((c=ES.readkey()) ¹ '\n')
{ES.write(c);s=s+c;}
return s;
}
}

Slide: 35

Exemple de redéfinition

indentation

class InputPasswd extends InputString {

String read_str() {
String s = "";
char c;
do {
c = ES.readkey();
if (c ¹ '\n') {ES.write('*'); s = s + c;}
}while (c ¹ '\n');
return s;
}
}

Slide: 36

Exécution

indentation

class TestInput {

public static void main(String args[])
{InputString s1 = new InputString();
InputPasswd s2 = new InputPasswd();

s1.input("login");
s2.input("passwd");
ES.writeln("\n\n");
ES.write(s1.value() + " a " + s2.value());
ES.write(" comme mot de passe");
}
}

java TestInput
login : emmanuel
passwd : *******
emmanuel a pilpoil comme mot de passe

Slide: 37

Polymorphisme

Réutilisation du même nom sur des types différents.

paramétrique (à la Caml) : même code pour n'importe quel paramètre;
ad hoc (surcharge) : code différent selon le type des paramètres;
d'inclusion (ou d'héritage) : code différent selon les sous-types.

En Java polymorphisme ad hoc et d'inclusion (sous-cas plus fin du premier).

Slide: 38

Relations

Est-un (is-a) :
s'il est un descendant
A-un (has-a) :
s'il possède une variable d'instance

Une difficulté de conception objet provient de la communication entre objets!!!

Slide: 39

Mémoire et Egalité

pointeur = référence = adresse mémoire
pointeur nul = null

les objets et les tableaux sont des références!!!
pas les types de base

opérateur == teste uniquement les adresses, pas le contenu de la zone pointée
Utiliser alors la méthode equals(o) héritée d'Object!!!

Allocation explicite (new mais récupération automatique (GC).

Slide: 40

Exceptions

Une exception est une rupture de calcul.

utilisée :

pour éviter les erreur de calcul
- division par zéro
- accès à la référence null
- ouverture dún fichier inexistant
- ...
comme style de programmation

En Java une exception est un objet

Slide: 41

Exceptions : Syntaxe

pose d'un récupérateur :

instruction ::=
  try {instructions}
  catch (type variable) { instructions}
  ...
  finally { instructions }

déclenchement :

  throw ThrowableObject ;

indication d'échappement d'une méthode ``

throws ExceptionClass}

Slide: 42

Exemples d'exceptions

indentation

class Exemple1 {
public int division(int a,int b) {
return (a/b);
}
}

class Division_par_zero extends Exception {
}

class Exemple2 {

private int division_aux(int a,int b)
throws Division_par_zero
{if (b == 0)
throw new Division_par_zero();
else return (a/b);
}

public int division(int a, int b)
{
try {return division_aux(a,b); }
catch(Division_par_zero e) {return 0;}
finally {ES.writeln("on passe ici");}
}
}

La clause finally est facultative. Son code est exécuté à la sortie du try.

Slide: 43

Interfaces

[ public ] interface l_intf [ extends [ a_intf]+ ] {
  declarations
}

Une interface déclare un protocole de communication.
Les déclarations peuvent mentionner des méthodes et des constantes.

Les interfaces sont souvent nommées par des adjectifs.

Slide: 44

Implantation d'interfaces

[public] class la_classe [extends superclasse]
   [implements [l_intf]+] {
}

Une classe peut implanter une ou plusieurs interfaces.
Elle est alors conforme au protocole décrit dans l'interface.

Intérêts :

permet d'être vu de différentes manières
ne nécessite pas d'hériter
simule de l'héritage multiple (sans code)

Slide: 45

Types des variables

les types de base
les noms de classe
les noms d'interface
les types tableaux

Slide: 46

Sous-type

ST £ T : ST est sous-type de T :
une valeur ST peut toujours être utilisée à la place d'une valeur T!

En Java : une sous-classe est un sous-type
En effet une instance d'une sous-classe saura toujours répondre aux messages que peuvent recevoir les instances de la classe ancêtre.

De même une sous-interface est un sous-type!

Slide: 47

Conversion implicite

pour le passage d'arguments (et l'affectation) :

C x = new C();
SC y = new SC(); // SC sous-classe de C

x = y;  // OK

Pas de problème à l'exécution, le nouvel x saura répondre à tous les messages de C.

Slide: 48

Conversion explicite

est utilisée quand la relation de sous-typage n'est pas vérifiée :

SC z = (SC) x;

un test dynamique (à l'exécution) est alors effectué.

Utile car il n'y a pas de polymorphisme paramétrique en Java!

Slide: 49

sous-type, surcharge et redéfinition

Java évite les problèmes de typage des méthodes en différenciant redéfinition et surcharge y compris si les types des paramètres ou le type du résultat est un sous-type.

Simplification quelques fois gênante, car cela force a` coercer le type dans le programme.

Slide: 50

Exemple

indentation

class TestC {
public static void main(String args[])
{
PointColore p0 = new PointColore();
Point p1 = new PointColore(3,4,"bleu");

p0.affiche(); p1.affiche();
p0.rmoveto(7,12);
p1.rmoveto(5,6);
p0.affiche(); p1.affiche();
if (p0.distance() == p1.distance())
ES.writeln("c'est le hasard");
else
ES.writeln("on pouvait parier");
}
}

Slide: 51

Polymorphisme

Réutilisation du même nom sur des types différents.

paramétrique (à la Caml) : même code pour n'importe quel paramètre;
ad hoc (surcharge) : code différent selon le type des paramètres;
d'inclusion (ou d'héritage) : code différent selon les sous-types.

En Java polymorphisme ad hoc et d'inclusion (sous-cas plus fin du premier).

Slide: 52

Paquetage

Regroupement de classes et d'interfaces dans un archivage hiérarchique (.class).

Déclaration
La déclaration d'un paquetage est la première instruction d'un programme.

package nom[.nom]* ;

utilisation

import nomqualifie;
       nomqualifie.*;

autorise les références abrégées.
collisions interdites.

Slide: 53

Paquetage (suite)

Sans rien préciser dans son programme, celui-ci est considéré faisant partie du ``paquetage anonyme''.

La hierarchie des paquetages suit la hiérarchie des catalogues du système.

L'appartenance à un paquetage modifie les règles de visibilité.

Slide: 54

Modifieurs généraux

abstract		final
doit être sous-classée	C	ne peut être sous-classée
doit avoir une implantation	M	ne peut être raffinée
	V	ne peut être modifiée

et toujours static :
M et V : méthode ou variable de classe.
(pas de this dans ces méthodes)

Slide: 55

Classe abstraite : un exemple

Listes

abstract class List { // classe abstraite racine
                      // de l'arbre d'heritage
    abstract  boolean empty() ;
    abstract int head() throws EmptyList;
    abstract List tail() throws EmptyList;
    abstract List cons(int x);
    abstract void display();
}

class EmptyList extends Exception {}

Slide: 56

classes concrètes : Nil

class Nil extends List {
   static List NIL = null;
   boolean empty(){return true;}
   List cons(int x){return new Cons(x,this);}
   int head()throws EmptyList {throw new EmptyList();}
   List tail()throws EmptyList{throw new EmptyList();}
   void display(){System.out.print("[]");}
}
\end{slide}
\begin{slide}
\heading{Classes concr\`etes : Cons}
\begin{verbatim}
class Cons extends List {
  int car;
  List cdr;
  Cons(){car=0;cdr=Nil.NIL;}
  Cons(int a, List b){car=a;cdr=b;}
 
  boolean empty(){return false;}
  List cons(int x) {return new Cons(x,this);}
  int head(){return car;}
  List tail(){return cdr;}
  void display(){System.out.print(car + "::"); cdr.display();}
}

Slide: 57

final

static final pour une variable en fait une constante!!!

final empêche de raffiner une méthode

final d'une classe empêche le sous-classement.

Slide: 58

Modifieurs de visibilité

C
M	public			C	protected
V				V
		C
		M	default
		V
M	private			M	private
V	protected			V

Slide: 59

Visibilité

// P.A.ja             // Q.D.java
package P;            package Q;
public class A {      import P.*;
  int i;              class D {
}                     }

// P/B.java           // Q/E.java
package P;            package Q;
class B extends A {   import P.*;
}                     class E extends A {
                      }
// P/C.java
package P;
class C {
}

Slide: 60

Représentation graphique

This document was translated from L^AT_EX by H^EV^EA.