5

Click here to load reader

PROGRAMMATION PAR OBJETS - rudametw.github.io€¦PROGRAMMATION PAR OBJETS Java Environnement et constructions spécifiques Walter Rudametkin Maître de Conférences Bureau F011 Walter.Rudametkin@polytech

  • Upload
    lythien

  • View
    212

  • Download
    0

Embed Size (px)

Citation preview

Page 1: PROGRAMMATION PAR OBJETS - rudametw.github.io€¦PROGRAMMATION PAR OBJETS Java Environnement et constructions spécifiques Walter Rudametkin Maître de Conférences Bureau F011 Walter.Rudametkin@polytech

PROGRAMMATION PAR

OBJETS Java

Environnement et constructions spécifiques

Walter Rudametkin

Maître de Conférences

Bureau F011

[email protected]

Java (Sun 1995) • Entre Smalltalk et C++ • C++

• Syntaxe familière à la C/C++

• fortement typé • gestion des exceptions

• Smalltalk • “tout objet” • machine virtuelle

• gestion automatique de la mémoire: garbage collector (pas de pointeurs explicites) • Portable

• machine virtuelle (bytecode) • standards (arithmétique IEEE 754, Caractères 16 bits Unicode) • même au niveau graphique (java2D, java.awt et javax.swing)

• Intègre le réseau • Applets (clients WEB) / Standalone applications (interprète java)

• Code mobile (internet), chargement dynamique de code • Nombreuses bibliothèques de classes (JDK : Java Development Kit)

• java.util : SD (listes, piles, itérateurs...) ...

• java.sql : accès aux BD (jdbc) • java.awt, javax.swing : graphique et interface

• java.rmi : réseaux et objets distribués • Free:

http://java.sun.com = http://www.oracle.com/technetwork/java

• JDK = Java SE (Standard Edition) Development Kit (V5 ou 6)

© B. Carré Polytech Lille 2

© B. Carré Polytech Lille 3

Applets Programme Java, non autonome, destiné à être invoqué dans des

documents HTML:

• sous un navigateur intégrant un interprète Java (JVM) (sous la forme d’un plugin de navigateur)

• ou un visualisateur d’applets (outil appletviewer du JDK)

//fichier Salut.java a compiler:

//javac Salut.java => Salut.class

import java.applet.*;

import java.awt.*;

public class Salut extends Applet {

public void paint(Graphics g) {

g.drawString("Salut!",20,20);

}

}

<HTML>

<!-- fichier salut.html sur la meme machine -->

<APPLET CODE="Salut.class" WIDTH=200 HEIGHT=50> </APPLET>

</HTML>

© B. Carré Polytech Lille 4

Applications autonomes

• Une classe, dite principale et public, introduit une méthode “main“ particulière qui détermine une application exécutable par la commande java

// fichier HelloWorld.java

public class HelloWorld {

public static void main(String[] args) {

System.out.println(“Hello World!“);

}

}

bash>javac HelloWorld.java

bash>java HelloWorld

Fichiers source Un fichier peut contenir plusieurs classes, javac générera autant de .class

Mais un fichier ne peut contenir qu’une classe public et doit porter son nom

Règle : un fichier par classe (compilable séparément).

© B. Carré Polytech Lille 5

Ligne de commande

Un seul paramètre : tableau d’objets String • n’incluant pas le nom du programme, • sa taille (équivalent de argc) peut être obtenue comme pour tout

tableau par son champ length

public class Echo {

public static void main(String[] argv) {

for (int i=0; i<argv.length; i++)

System.out.print(argv[i]+" ");

System.out.println();

}

}

bash>java Echo bonjour le monde

bash>bonjour le monde

© B. Carré Polytech Lille 6

Applications autonomes

Exemple depuis java 5.0

public class Echo {

public static void main(String[] argv) {

//sequence de valeurs : « for each »

for (String chaine : argv){

// sortie formattée a la C :

System.out.printf("%s ", chaine);

}

System.out.print("\n");

}

}

Page 2: PROGRAMMATION PAR OBJETS - rudametw.github.io€¦PROGRAMMATION PAR OBJETS Java Environnement et constructions spécifiques Walter Rudametkin Maître de Conférences Bureau F011 Walter.Rudametkin@polytech

© B. Carré Polytech Lille 7

Entrées/sorties standards

• Les e/s (fichiers, “standards”) sont définies par une hiérarchie de Streams (flots) dans le package java.io

InputStream //lecture d’octets dont System.in

OutputStream

FilterOutputStream

PrintStream //sortie standard System.out

• Les flots chargés des e/s «standards » sont fournis dans 3 « variables statiques » de la classe System:

public class System {...

// variables de classe

public static PrintStream err;

public static InputStream in;

public static PrintStream out;

...}

© B. Carré Polytech Lille 8

Sortie standard • System.out.print(..) et println(...)

• Ces méthodes sont surchargées pour chaque type de base (char, int,

double, boolean...)

• pour un objet, invoque sa méthode toString() qui doit fournir une

String de représentation textuelle de l’objet

• toString() est fournie par défaut dans Object. Il suffit de la redéfinir.

• Exemple

class And {...

public String toString() {

return (

"e1= "

+ String.valueOf(e1) // transformation explicite

+ " e2= "

+ e2 // transformation automatique

+ " s= "

+ s;

);

}

...

}

© B. Carré Polytech Lille 9

Java 5.0 : sortie standard formattée

• System.out.printf(String format, Object… args) • printf « à la C »

• format : %d, %f, %s, ...

• Remarque : dans le cas d ’objet utiliser %s => appel automatique à toString()

• Exemple :

And a1 = new And(), a2 = new And();

// utilisation de a1 et a2

// affichage :

System.out.printf(“%d ands a1: %s a2: %s\n”, 2, a1, a2);

© B. Carré Polytech Lille 10

Entrée standard (depuis Java 5.0) • System.in

flot de bytes à “scanner” en l'enrobant (“wrapper”) dans la classe Scanner public class java.util.Scanner {

public String next()

public int nextInt()

public double nextDouble()

public String nextLine()

...}

• Exemple : import java.util.*;

Scanner in = new Scanner(System.in);

System.out.printf("entrer 1 int, 1 double, une chaine,

et le reste : \n");

int i = in.nextInt();

double d = in.nextDouble();

String s = in.next();

String reste = in.nextLine();

System.out.printf("i=%d\n d=%f\n s=%s\n reste=%s\n",i,d,s,reste);

© B. Carré Polytech Lille 11

static : variables et méthodes de classe

• Déclarées au niveau de la classe par le « modifier » static

• Permet de définir une ressource • attachée à la classe

• en exemplaire unique

• commune à toutes ses instances (accessibles directement)

• et même “globale” puisque la classe l’est! Accessible en désignant la classe, comme c’est le cas de : System.out, System.in, …

• La déclaration final la rend en plus non modifiable et permet donc de déclarer des constantes

© B. Carré Polytech Lille 12

static : variables et méthodes de classe

class Circle {

static final double PI = 3.14159265;

// variables d’instance double rayon;

// methodes d’instance double circonference() {

return 2*PI*rayon; // ou 2*Circle.PI*rayon // final => constante => calculee statiquement

}

}

• Méthodes de classes: exemples du langage (package java.lang)

public class System

public static void exit(int status) public static Properties getProperties()

public class Math {

public static double min(double a, double b) public static double sin(double a)

Page 3: PROGRAMMATION PAR OBJETS - rudametw.github.io€¦PROGRAMMATION PAR OBJETS Java Environnement et constructions spécifiques Walter Rudametkin Maître de Conférences Bureau F011 Walter.Rudametkin@polytech

© B. Carré Polytech Lille 13

Syntaxe et éléments de base

• Commentaires /* ceci est

un commentaire sur plusieurs lignes*/

// ceci est un commentaire ligne

• Identificateurs • variables, classes, méthodes, packages

• syntaxe identificateur = initiale suivant*

initiale = “a“|...|“z“|“A“...“Z“|“$“|“_“ suivant = initiale |“0“...“9“|unicode > 00C0

• pas de limitation de longueur, tout caractère significatif (minuscules et majuscules)

• conventions : • ne pas utiliser $ et _ (librairies C)

• ceciEstUnIdentificateur • NomDeClasse • CONSTANTE

© B. Carré Polytech Lille 14

Mots réservés

abstract boolean break byte byvalue case cast

catch char class const continue default do

double else extends false final finally float

for future generic goto if implements import

inner instanceof int interface long native new

null operator outer package private protected

public return short static super switch

synchronized this thread throw throws

transient true try void volatile while

© B. Carré Polytech Lille 15

Variables

• Déclaration <modifier> type variable_declarator <“,“ variable_declarator> “;“

variable_declarator = identifier <“[“ “]“> [“=“ initializer]

modifier = “abstract“ | “public“ | “private“ | “protected“ |

“static“ | “final“ ...

type = type_primitif | classe | interface

• tableaux: type identifier[] ou type[] identifier

• modifier : concerne la programmation des classes

• 2 catégories de variables :

• de type d’objets (classes et interfaces) : contiennent des références

• de type primitif : contiennent des valeurs

© B. Carré Polytech Lille 16

Types primitifs

• C (C++) + boolean et byte

• de taille constante quelque-soit la machine

• gérés par valeur, ce ne sont pas des objets, mais

«enrobables» par les Wrapper classes

• les boolean ne sont pas des entiers

• les char sont codés sur deux octets Unicode compatible

ASCII. les caractères spéciaux sont notés (comme en C) \n \t \b \r \f \\ \’ \“

© B. Carré Polytech Lille 17

Types primitifs

Double 64 bits 0.0D|0.0d IEEE 754 double

Float 32 bits 0.0F|0.0f IEEE 754 (0.5E-3) float

Long 64 bits 0L|0l entier signé long

Integer 32 bits 0 entier signé int

Short 16 bits 0 entier signé short

Byte 8 bits 0 entier signé byte

Character 16 bits ‘\u0000’ Unicode char

Boolean 1 bit false true false boolean

Wrapper class Taille Init Valeurs Type

© B. Carré Polytech Lille 18

Wrapper Classes

• « Pont » entre valeurs primitives et objets

• Permet de considérer une valeur de type primitif comme un objet quand

cela est requis (cf. collections d’objets)

Integer nObject = new Integer(2); // wrapping

int n = nObject.intValue();// unwrapping

• Offre des utilitaires (static) comme le parsing String -> valeur

inverse de String.valueOf(…) (cf. entrée standard avant 5.0,

paramètres du main, saisies de champs texte dans les interfaces)

public class Plus {

public static void main(String[] args) {

double x = Double.parseDouble(args[0]);

double y = Double.parseDouble(args[1]);

System.out.printf("x+y=%.2f\n", x+y);

}}

Page 4: PROGRAMMATION PAR OBJETS - rudametw.github.io€¦PROGRAMMATION PAR OBJETS Java Environnement et constructions spécifiques Walter Rudametkin Maître de Conférences Bureau F011 Walter.Rudametkin@polytech

© B. Carré Polytech Lille 19

Initialisation d’objets : constructeur

new <Classe>()

• <Classe>() est appelé « constructeur par défaut » et initialise les variables d’instances de l’objet: • aux valeurs déclarées, si elles existent • par défaut sinon (et en standard) :

• valeur d’init pour les types primitifs (cf. tableau des types) • null pour les types d’objets

• Il est possible de le redéfinir, de le surcharger en le paramétrant:

new <Classe>([<parametres>])

• C’est le premier traitement exécuté par l’instance

© B. Carré Polytech Lille 20

Constructeurs • Un constructeur permet de réaliser tout traitement à l’initialisation

class And {

And(boolean in1, boolean in2) {

e1=in1;

e2=in2;

run(); // this.run();

}

}

• Pas de destructeur (contrairement à C++) : • automatique par garbage-collector (objets non-référencés). • Il existe cependant un protocole de “finalisation” utilisable dans des

cas particuliers (libération de ressources systèmes...) : méthode finalize().

© B. Carré Polytech Lille 21

Construction d’objets composites • Construction d’objets par composition d’autres objets

class Rectangle {

Point origin, corner;

}

• Initialisation par défaut des objets : null, d’où :

class Rectangle {

Rectangle(Point p1, Point p2) {

origin=p1;

corner=p2;

}

Rectangle(double x1, double y1, double x2, double y2) {

origin = new Point(x1,y1);

corner = new Point(x2,y2);

}

}

© B. Carré Polytech Lille 22

Tableaux

• Les tableaux sont des objets : • créés dynamiquement (avec leur length) par instanciation : new <type des elements>[<length>]

• libérés automatiquement (gc=garbage collector)

• manipulés par référence : variables tableaux et passage en paramètre

• compatibles avec le type Object dont les méthodes sont applicables.

• Mais syntaxe spécifique (à la C): création avec initialisation par : {} , accès par : [], …

• Type des éléments : types primitifs (homogènes) ou classes (tableaux polymorphes).

• Tableaux multidimensionnels = vrais tableaux de tableaux

© B. Carré Polytech Lille 23

Tableaux

• Exemples int[] t1= new int[10];

// declaration avec initialisation:

int[] t2= {1,2,3,4,5};

// affectation de variables tableaux

t1=t2; // t1 et t2 sont des variables

int[][] matrice = new int[50][100];

int[][] matrice = new int[][100]; //impossible!

© B. Carré Polytech Lille 24

Tableaux public class test {

static void uns(int tab[]) { // passage en parametre

for (int i=0;i<tab.length;i++) tab[i]=1;

}

public static void main(String args[]) {

int tabtab[][]=new int[3][]; //tableau de 3 tableaux d'int

tabtab[0]=new int[10]; // de tailles quelconques...

tabtab[1]=new int[20];

tabtab[2]=new int[30];

uns(tabtab[0]); uns(tabtab[1]); uns(tabtab[2]);

for (int i=0;i<tabtab.length;i++) {

for (int j=0;j<tabtab[i].length;j++){

System.out.print(tabtab[i][j]);

}

System.out.print("\n");

}}}

//for en 5.0

for (int[] ligne : tabtab) { // ligne : variable tableau

for (int x : ligne)

System.out.print(x);

Page 5: PROGRAMMATION PAR OBJETS - rudametw.github.io€¦PROGRAMMATION PAR OBJETS Java Environnement et constructions spécifiques Walter Rudametkin Maître de Conférences Bureau F011 Walter.Rudametkin@polytech

© B. Carré Polytech Lille 25

Chaînes de caractères

• Ce sont des objets à part entière • instances de la classe String

• mais admettent une forme littérale :

String s = “deux\nlignes“;

• Deux classes principales • String = objets chaînes de taille constante

• StringBuffer = objets chaînes de taille variable

© B. Carré Polytech Lille 26

Chaînes de caractères

• String : quelques opérations • opérateur + (String)

• les méthodes valueOf(...)

• int length()

• int compareTo(String) (équivalent de strcmp)

• boolean equals(Object)

• char charAt(int) throws StringIndexOutOfBoundsException

• String substring(int,int) throws StringIndexOutOfBoundsException

• StringBuffer : chaine modifiables, en contenu et en taille : • StringBuffer append(String)

• StringBuffer insert(int,String)

throws StringIndexOutOfBoundsException

• void setCharAt(int, char)

throws StringIndexOutOfBoundsException

© B. Carré Polytech Lille 27

Expressions et structures de contrôle

• Pour l’essentiel, très semblables à C (C++).

• L’appel de fonction est remplacé par l’envoi de message: • c’est une instruction si la méthode est de type void

• une expression sinon.

• Opérateurs • en moins: *, &, ->, sizeof (inutiles)

• en plus: instanceof et + de concaténation de chaînes

• les opérateurs logiques procèdent sur le type boolean

• mêmes règles de priorité et d’associativité

• Structures de contrôle

if/else, while, do/while, switch, for, break • les prédicats sont de type boolean • for (int i=0;i<n;i++) // indice local a la boucle

• depuis Java 5.0 le « for each »permet d'itérer sur toute séquence de valeurs « itérable », en particulier tableaux et collections.