Vous êtes sur la page 1sur 31

Annexe

Notations mathématiques et vocabulaire utile

Ensembles
Ensemble : un ensemble est un regroupement d'objets de même type, chaque objet n'étant présent
qu'une seule fois. En informatique on n'utilise que des ensembles finis (ensembles dont le
nombre d'éléments est fini).
 : ensemble vide ne contenant aucun élément.
 : symbole d'appartenance d'un élément à un ensemble donné; on dit qu'un objet x appartient à
l'ensemble A le fait que x se trouve dans la liste des éléments de A et l'on écrit x  A.
 : ensemble vide ne contenant aucun élément.
P(E) : Notation pour l'ensemble des parties d'un ensemble, c'est l'ensemble de tous les sous-
ensembles que l'on peut construire à partir de E y compris E et l'ensemble vide. On montre que
si E possède n éléments, P(E) possède alors 2n éléments. Exemple : si E = {0,1} on a alors
P(E) = { {0}, {1}, {0,1},  }
Cardinal : le cardinal d'un ensemble E est le nombre d'éléments de cet ensemble, noté card(E).

Soient A et B deux sous-ensembles d'un ensemble E

Il est possible d'effectuer un certain nombre d'opération sur les sous-ensembles A et B.

 (union) : A  B est le sous-ensemble de P(E) contenant tous les éléments de A ou bien tous les
éléments de B, on écrit A  B = { x  E / (x  A) ou (x  B) }

En gris l'ensemble A  B

 (intersection) : A  B est le sous-ensemble de P(E) contenant tous les éléments de A et aussi tous
les éléments de B, on écrit A  B = { x  E / (x  A) et (x  B) }

Les bases de l’informatique - programmation - ( rév. 04.01.2005 ) page 982


En gris l'ensemble A  B

CE (complémentaire) : CE(A ) est le sous-ensemble de P(E) contenant tous les éléments de E qui ne
sont pas dans A, on écrit CE(A ) = { x  E / (x  A) }

En gris l'ensemble CE(A )

- (différence) : A - B est le sous-ensemble de P(E) contenant tous les éléments de A privé de ceux
de A  B, on écrit A - B = { x  E / (x  A) et (x  B) }

En gris l'ensemble A - B

 (inclusion) : On dit que A  B lorsque tous les éléments de A appartiennent à B.

L'ensemble A est inclus dans l'ensemble B

Produit cartésien d'ensemble : Soient E et F deux ensembles non vides, on note E x F leur produit
cartésien E x F = { (x , y) / (x  E) et (y  F) }

 : quantificateur universel signifiant "pour tout", exemple x ( x  E ) /…. se lit <quelque soit x
appartenant à l'ensemble E tel que….>
 : quantificateur existenciel signifiant "il existe au moins un", exemple x ( x  E ) /…. se lit <
il existe au moins un x appartenant à l'ensemble E tel que ….>
 : quantificateur existenciel unique signifiant "il existe uniquement un", exemple x ( x  E )
/…. se lit < il existe un seul x appartenant à l'ensemble E tel que ….>

Symboles
 : implication logique.
 : équivalence logique.

Les bases de l’informatique - programmation - ( rév. 04.01.2005 ) page 983


 : sommation de termes, exemple : représente la somme : f(3)+f(4)+…+f(10)

 : produit de termes, exemple : représente le produit : f(3) x f(4) x…x f(10)

: union généralisée, exemple : représente : A1  A2  ….  An


n! : factorielle n est le produit des n premiers entiers, n! = 1 x 2 x 3 x….x (n-1) x n , avec comme
convention 0! = 1.
Cn , p : est le nombre de combinaisons de p éléments distincts pris dans un ensemble à n éléments,
ou encore le nombre de sous-ensembles à p éléments d'un ensemble à n éléments;
Cn , p =

(a+b)n : binôme de Newton, (a+b)n =

Fonctions
Fonction : Soient E et F deux ensembles non vides, tout procédé permettant d'associer un élément
de E à un élément unique au plus, dans l'ensemble F est appelé une correspondance notée par
exemple f, ou aussi une fonction f de E vers F.
On note ainsi f : E  F , E est appelé ensemble de départ de la fonction f, F est appelé
ensemble d'arrivée de la fonction f.

Image d'un élément par une fonction : si f est une fonction de E vers F, x un élément de E, et y
l'unique élément de F associé à x par la fonction f, on écrit y = f(x) et l'on dit que f(x) est l'image
dans F de l'élément x de E, on dit aussi que x est l'antécédent de y.
On note ainsi : f : x  f(x)

On écrit la correspondance entre l'image et


l'antécédent ainsi :

 soit x  E , y ( y  F ) / y = f(x) } et
{il existe au plus un y de F répondant à cette
définition.}

Certains éléments de l'ensemble de départ peuvent


ne pas avoir d'image par f.

Domaine de définition d'une fonction : si f est une fonction de E vers F, le sous-ensemble des
éléments x de l'ensemble de départ E ayant une image dans F par la fonction f, est appelé le
domaine de définition de la fonction f, noté Dom(f).

Les bases de l’informatique - programmation - ( rév. 04.01.2005 ) page 984


On écrit :

Dom(f) = {x ( x  E ) , y ( y  F ) / y = f(x) }

Ci-contre Dom(f) est figuré en grisé.

Application : Une application est une fonction dans laquelle tous les éléments de l'ensemble de
départ ont une image dans F par la fonction f. Ci-après deux schémas figurant la différence
entre application et fonction.

Remarque : toute fonction devient une application lorsque l'on prend comme ensemble de départ
son domaine de définition, nous appelons restriction de f à Dom notée fDom cette application

En informatique, par abus de langage nous utiliserons indifféremment les dénomination application
et fonction, car nous ne considérons que des fonctions qui portent sur leur domaine de définition.

Application injective (injection) : Lorsque deux éléments distincts de l'ensemble de départ E ont
toujours deux images distinctes dans l'ensemble d'arrivée, on dit que l'application est injective.

On écrit :

x1 ( x1  E ), x2 ( x2  E )
x1  x2  f(x1)  f(x2)
ou la contrapposée :
f(x1)  f(x2)  x1  x2

card(E)  card(F)

Application surjective (surjection) : Lorsque tout élément de l'ensemble d'arrivée F possède au


moins un antécédent dans l'ensemble de départ E, on dit que l'application est surjective.

Les bases de l’informatique - programmation - ( rév. 04.01.2005 ) page 985


On écrit :

y ( y  F ) , x ( x  E ) / y = f(x)

card(E)  card(F)

Application bijective (bijection) : Lorsque tout élément de l'ensemble d'arrivée F possède un


unique antécédent dans l'ensemble de départ E et tout élément de E possède une image unique
dans F, on dit alors que l'application est bijective.

On écrit :

y ( y  F ) , x ( x  E ) / y = f(x)

card(E)  card(F)

Remarques : une application bijective est une application qui est à la fois surjective et injective.
Comme nous travaillons en informatique avec des ensembles finis dire qu'il existe une bijection
d'un ensemble E vers un ensemble F revient à dire qu'ils le même cardinal (le même nombre
d'éléments).

Suite récurrente : une suite d'éléments u0 , u1 , … , un est dite récurrente lorqu'il existe une relation
fonctionnelle entre un terme quelconque un et les termes qui le précèdent u0 , u1 , … , un-1, notée
ainsi : un = f(u0 , u1 , … , un-1).

Démonstration par récurrence : soit une proposition P(n) dépendant d'une variable entière n.
On suppose que P(1) est vérifiée
Si l'on montre que pour un entier n quelconque supérieur à 1, P(n) est vraie implique que
P(n+1) est vraie on en conclu que : n, n  1, P(n) est vraie. En effet P(1) vraie  P(2)
vraie, mais P(2) vraie  P(3) vraie etc…

Structures algébriques
Loi de composition interne : toute application f, telle que f : E x E  E, est appelée "loi de
composition interne" dans E. Par exemple la loi + dans N, + : N x N  N, la notation
fonctionnelle s'écrit + (a,b)  y = +(a,b) on la dénomme notation préfixée pour une loi. Dans
certains cas on préfère une autre notation dite notation infixée pour représenter l'image du
couple (a,b) par une loi. Par exemple, la notation infixée de la loi + est la suivante : + (a,b) 
y = a + b. D'une manière générale, pour une loi ¤ sur une ensemble E nous noterons a ¤ b
l'image ¤(a,b) du couple (a,b) par la loi ¤.

Associativité : La loi ¤ est dite associative par définition si :


x ( x  E ), y ( y  E ), z ( z  E ) on a : ( x ¤ y ) ¤ z = x ¤ ( y ¤ z )

Les bases de l’informatique - programmation - ( rév. 04.01.2005 ) page 986


Commutativité : La loi ¤ est dite commutative par définition si :
x ( x  E ), y ( y  E ), on a : x ¤ y = y ¤ x

Elément neutre : La loi ¤ est dite posséder un élément neutre noté e si :


x ( x  E ), on a : x ¤ e = e ¤ x = x

Distributivité : La loi ¤ est dite distributive par rapport à la loi * si :


x ( x  E ), y ( y  E ), z ( z  E ) on a : x * ( y ¤ z ) = ( x * y ) ¤ ( x * z )

Symétrique : On dit qu'un élément x d'un ensemble E est symétrisable (ou qu'il possède un
symétrique unique) pour la loi ¤ sur E (nous notons x' le symétrique de x) lorsque cette loi possède
un élément neutre e et que : x ( x  E ),  x' ( x'  E ) / x' ¤ x = x ¤ x' = e. Par exemple dans
l'addition dans Z l'entier -x est le symétrique de l'entier x, car nous avons x + (-x) = (-x) + x =0
(l'entier 0 est l'élément neutre de la loi +)

Absorbant : On dit qu'un élément a d'un ensemble E est absorbant pour la loi ¤ lorsque : x ( x 
E ), x ¤ a = a ¤ x = a. Par exemple dans Z l'entier 0 est absorbant pour la multiplication.

Idempotent : Un élément a d'une loi ¤ est dit idempotent lorsque a ¤ a = a. Par exemple dans la loi
 sur P(E) (union de deux sous-ensembles de l'ensemble E non vide), tous les éléments de P(E)
sont idempotents, en effet : A ( A  P(E) ),     

Les bases de l’informatique - programmation - ( rév. 04.01.2005 ) page 987


Annexe
Syntaxes de base comparées LDFA - Delphi - Java/C#

LDFA Delphi Java - C#


pas de traduction
 (instruction vide) pas de traduction
{ i1; i2; i3; ...... ; ik; }
debut i1 ; i2; i3; ...... ; ik fin begin i1 ; i2; i3; ...... ; ik end
x=a;
x  a x := a
(ordre d'exécution + fin
; (ordre d'exécution) ; instruction) ;

if ( P ) E1; else E2 ;
if P then E1 else E2
( attention défaut, pas de
Si P alors E1 sinon E2 Fsi ( attention défaut, pas de
fermeture !)
fermeture !)
while ( P ) E ;
while P do E
Tantque P faire E Ftant ( attention, pas de fermeture)
( attention, pas de fermeture)
do E; while ( !P )
répeter E jusquà P repeat E until P
en C# :
System.Console.Read( )
System.Console.ReadLine( )
read(fichier,x1,x2,x3......,xn )
lire (x1,x2,x3......,xn ) readln(x1,x2,x3......,xn )
en Java :
Get(fichier)
System.in.read( )
System.in.readln( )

en C# :
System.Console.Write( )
System.Console.WriteLine( )
write(fichier,x1,x2,x3......,xn )
ecrire (x1,x2,x3......,xn ) writeln(x1,x2,x3......,xn )
en Java :
Put(fichier)
System.out.print( )
System.out.println( )

for ( x = a ; x < b ; x++ ) E ;


for x:=a to b do E (croissant)
pour x<-a jusquà b faire E for x:=a downto b do E
for ( x = a ; x < b ; x-- ) E ;
Fpour (décroissant)
( attention, pas de fermeture)
( attention, pas de fermeture)
if ( P ) Break ; (sort d'une
if P then Break (sort d'une
boucle)
boucle)
SortirSi P if ( P ) return ; (sort d'une
if P then exit (sort d'une
méthode)
méthode)

N (entiers naturels) integer uint en C#

Les bases de l’informatique - programmation - ( rév. 04.01.2005 ) page 988


int en Java

int en C#
Z (entiers relatifs) integer int en Java

double en C# et Java
Q (rationnels) real
double en C# et Java
R (réels) real
Boolean en C#
{ Vrai , Faux } (logique) boolean bool en Java

char en C# et Java
caractère char
+,-,/,*
+,-,/,* +,-,/,*
> , < , = , !=
>,<,=, > , < , = ,<>
>= , <=
,  >= , <=
! , && , ||
,  ,  not , and , or

Les bases de l’informatique - programmation - ( rév. 04.01.2005 ) page 989


Annexe
Agrégation ou héritage

choisissez entre "EST UN" ou bien "A UN"

Est Un
Lorsque vous spécifiez un problème en termes d'objets et que vous analysez les relations entre
un Objet1 et un Objet2, si vous énoncez une phrase du genre : << Objet2 est un Objet1 qui
possède les particularités supplémentaires.....>> , vous devez implémenter la notion d'héritage
entre la classe d'Objet1 notée Classe1 et celle d'Objet2 notée Classe2.

Lorsque vous construisez une classe dérivée (héritant de) d'une autre classe, vous implémentez
le concept "EST UN".

A Un

Lorsque vous spécifiez un problème en termes d'objets et que vous analysez les relations entre
un Objet1 et un Objet2, si vous énoncez une phrase du genre : << Objet2 a un (ou possède un)
Objet1 .....>> , vous devez implémenter la notion d'agrégation entre la classe d'Objet1 notée
Classe1 et celle d'Objet2 notée Classe2.

Lorsque vous construisez dans une classe un attribut d'une autre classe, vous implémentez le
concept "A UN".

Prenons en exemple trois classes Moteur , Vehicule et Voiture représentant chacune les
concepts physiques des entités réelles de moteur, de véhicule et de voiture dans le vocabulaire
courant :

Les bases de l’informatique - programmation - ( rév. 04.01.2005 ) page 990


Lorsque nous décrirons les relations entre les entités physiques, nous dirons que :

Une voiture est un véhicule qui a un moteur.

Traduisons cette phrase en terme de relations de classes en notation UML :

AGREGATION FORTE ou AGREGATION FAIBLE


Reprenons notre voiture en y ajoutant le fait qu'elle contient aussi des roues, des rivets et des
soudures, nous créons les classes Rivet , Roue , Soudure.

Décrivons les relations entre les entités physiques par une phrase :

Une voiture est un véhicule qui a un seul moteur, qui a quatre roues, qui a
un nombre quelconque de soudures et un nombre quelconque de rivets.

Cette phrase traduit les relations de classes en notation UML précédente.

Les bases de l’informatique - programmation - ( rév. 04.01.2005 ) page 991


En fait il y a une différence plus subtile dans les objets agrégés de notre voiture. Nous pouvons
distinguer les objets qui sont fortement liés à la voiture, qui ne seront jamais changés lors de la
vie de la voiture et qui partiront à la casse avec la voiture : les soudures et les rivets en font
partie. Nous savons en revanche que les roues peuvent être changées plusieurs fois au cours de
la vie de la voiture, enfin nous savons qu'il est possible d'effectuer un "échange standard"
permettant de remettre un moteur neuf dans notre voiture.

Nous avons donc des objets fortement liés à la voiture (rivets, soudures) et des objets faiblement
liés à cette même voiture. En terme informatique nous parlerons d'agrégation forte pour les
objets fortement liés et d'agrégation faible pour ceux qui sont liés faiblement.

Vocabulaire aussi employé par les auteurs et notation UML :

agrégation = agrégation faible

composition = agrégation forte

En utilisant les notations de composition (agrégation forte) et de d'agrégation (agrégation faible)


nous obtenons les diagrammes de classe UML suivants :

Utilisation pratique des relations de classes dans le code

UML n'étant qu'une notation voici ci-dessous comment en Delphi par exemple les notions
d'association, d'agrégation et de composition sont implantables :

Les bases de l’informatique - programmation - ( rév. 04.01.2005 ) page 992


Ci-dessus une application plus concrète reprenant l'exemple précédent en y ajoutant une
association de la classe voiture avec un numéro de série (objet de classe numSerie ).

Diagrammes UML de définition :

Un exemple d'implantation des diagrammes précédents sous forme d'une Unit en Delphi :

unit Unit1 ;
interface
type
vehicule = class
end;
moteur = class
end;
roue = class
end;
rivet = class
end;
soudure = class
end;
numSerie = class
end;

voiture = class (vehicule)


private

Les bases de l’informatique - programmation - ( rév. 04.01.2005 ) page 993


V16 : moteur ;
EnsRivets : rivet ;
EnsSoudure : soudure ;
TrainRoue : roue ;
procedure MonterRoues(x : roue) ;
procedure MonterMoteur(x : moteur) ;
public
constructor Create ;
destructor Destroy ;override;
end;

implementation

{ voiture }

constructor voiture.Create ;
begin
EnsRivets := rivet.Create ; // composition (agrégation forte)
EnsSoudure := soudure.Create ; //composition (agrégation forte)
end;

destructor voiture.Destroy ;
begin
EnsRivets.Free ;
EnsSoudure.Free :
inherited;
end;

procedure voiture.MonterMoteur(x : moteur) ;


var numCorrect : numSerie ;
begin
V16 := x ; // agrégation (faible)
numCorrect := numSerie .Create ; // association simple (ni agrégation, ni compsition)
....
numCorrect.Free ;
end;

procedure voiture.MonterRoues(x : roue) ;


begin
TrainRoue := x ; // agrégation (faible)
end;

end.

Les bases de l’informatique - programmation - ( rév. 04.01.2005 ) page 994


Annexe
Cinq composants visuels utiles, générés dynamiquement
en Delphi, Java swing, C#

Ces composants sont les outils minimum que l'on trouve dans une interface interactive. Ils sont
présentés avec le code qui les engendre sans avoir à passer par le l'environnement RAD; le
lecteur est incité à comparer les similitudes et les différences selon le langage d'implantation, il
pourra aussi réutiliser les lignes fournies lorsqu'il voudra générer dynamiquement de tels
composants dans son programme pendant l'exécution.

Le bouton poussoir
Langage Delphi : bouton poussoir - classe TButton
Une unit pour afficher un TButton dans une fiche Form1 :
unit Ubutton ;

interface

uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls ;

type
TForm1 = class (TForm)
procedure FormCreate( Sender: TObject) ;
private
{ Déclarations privées }
Button1 : TButton ;
public
{ Déclarations publiques }
end;

var
Form1 : TForm1 ;

implementation

{$R *.dfm}

Les bases de l’informatique - programmation - ( rév. 04.01.2005 ) page 995


procedure TForm1.FormCreate( Sender: TObject) ;
begin
Button1 := TButton.Create( self ) ;
Button1.Parent :=self ;
Button1.Caption := 'Valider';
Button1.SetBounds(30,50,100,30) ;
end;

end.

Langage Java : bouton poussoir- classe JButton

Deux classes minimales en Java-swing pour afficher un JButton dans une fiche nommée Fen de
type Fiche héritant des JFrame :
import java.awt.* ;
import javax.swing.* ;

public class ApplicationButton


{
public static void main ( String [ ] args ) {
Fiche Fen = new Fiche ( );
Fen.setVisible ( true );
}
}

class Fiche extends JFrame


{
private Container contentPane ;
private JButton jButton = new JButton ( );

public Fiche ( ) {
contentPane = ( Container ) this .getContentPane ( );
contentPane.setBackground ( SystemColor.info );
jButton.setBackground ( Color.cyan );
jButton.setText ("Bonjour");

Les bases de l’informatique - programmation - ( rév. 04.01.2005 ) page 996


jButton.setBounds ( 30, 50, 100, 30 );
contentPane.setLayout ( null );
contentPane.add ( jButton );

this .setBounds ( 100,100, 271, 165 );


this .setTitle ("Titre du cadre");
this .setDefaultCloseOperation ( EXIT_ON_CLOSE )
}
}

Langage C# : bouton poussoir - classe Button


Deux classes minimales en C# pour afficher le Button dans une fiche :
using System ;
using System .Drawing ;
using System .Collections ;
using System .ComponentModel ;
using System .Windows.Forms ;
using System .Data ;

namespace ProgTest
{
public class WinForm : System .Windows.Forms.Form
{
private System .Windows.Forms.Panel panel1 ;
private System .Windows.Forms.TextBox textBox1 ;
private System .Windows.Forms.Button button1 ;

public WinForm ( ) {
this .button1 = new System .Windows.Forms.Button ( );
this .button1.SetBounds ( 15, 70,60, 25 );
this .button1.Text = "Ok";
this .button1.BackColor = System .Drawing.Color.Aquamarine ;

// WinForm
this .BackColor = System .Drawing.Color.Moccasin ;
this .Controls.Add (this .button1 );
this .Text = "WinForm";
this .SetBounds ( 100,80,270,165 );
}

protected override void Dispose ( bool disposing ) {


base .Dispose ( disposing );
}
}

Les bases de l’informatique - programmation - ( rév. 04.01.2005 ) page 997


class Application1
{
static void Main ( string [ ] args ) {
WinForm F = new WinForm ( );
F.BackColor = System .Drawing.Color.Bisque ;
Application.Run ( F );
}
}
}

La zone de texte multi-ligne

Langage Delphi : zone de texte multi-ligne - classe TMemo


Une unit pour afficher un texte dans un TMemo, construction dynamique du TMemoà partir
d'une fiche Form1 :
unit Umemo ;

interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls ;

type
TForm1 = class (TForm)
procedure FormCreate( Sender: TObject) ;
private
Memo1 : TMemo ;
public
{ Déclarations publiques }
end;

var
Form1 : TForm1 ;

implementation
{$R *.dfm}

Les bases de l’informatique - programmation - ( rév. 04.01.2005 ) page 998


procedure TForm1.FormCreate( Sender: TObject) ;
begin
Memo1 := TEdit.Create( self ) ;
Memo1.Parent :=self ;
Memo1.SetBounds(30,32,177,85) ;
Memo1.Color := clSkyBlue ;
Memo1.ScrollBars :=ssBoth;
Memo1.Lines.Add('Bonjour') ;
Memo1.Lines.Add('texte multi-ligne') ;
Memo1.Lines.Add('Fin.') ;
end;

end.

Langage Java : zone de texte multi-ligne - classe JTextArea

Rappelons que la classe swing JTextArea délègue la gestion des barres de défilement à un objet conteneur dont
c'est la fonction le JScrollpane, ceci a lieu lorsque le JTextArea est ajouté au JScrollpane.
// les déclarations :
JScrollPane jScrollPane1 = new JScrollPane( );
JTextArea jTextArea1 = new JTextArea( );

// dans le constructeur de la fenêtre JFrame :


this.getContentPane( ).add(jScrollPane1, null);
jScrollPane.getViewport( ).add(jTextArea1, null);

ou bien en utilisant une autre surcharge du constructeur de JScrollPane :

// les déclarations :
JTextArea jTextArea1 = new JTextArea( );
JScrollPane jScrollPane1 = new JScrollPane( jTextArea1 );

// dans le constructeur de la fenêtre JFrame :


this.getContentPane( ).add(jScrollPane1, null);

Deux classes minimales en Java-swing pour afficher le JTextArea dans une fiche :
import java.awt. * ;
import javax.swing. * ;

public class ApplicationMemo


{
public static void main ( String [] args )

Les bases de l’informatique - programmation - ( rév. 04.01.2005 ) page 999


{
Cadre1 Fiche = new Cadre1 ( );
Fiche.setVisible ( true );
}
}

class Cadre1 extends JFrame


{
private JPanel contentPane ;
private JScrollPane jScrollPane1 = new JScrollPane ( );
private JTextArea jTextArea1 = new JTextArea ( );

public Cadre1 ( )
{
this .setSize (new Dimension ( 271, 165 ));
this .setTitle ("Titre du cadre");
this .setDefaultCloseOperation ( EXIT_ON_CLOSE );
contentPane = ( JPanel ) this .getContentPane ( );
contentPane.setBackground ( SystemColor.info );
jScrollPane1.setBounds ( 30, 32, 177, 85 );
jTextArea1.setBackground ( Color.cyan );
jTextArea1.append ("Bonjour\n");
jTextArea1.append ("texte multi-ligne\n");
jTextArea1.append ("....\n");
jTextArea1.append ("....\n");
jTextArea1.append ("....\n");
jTextArea1.append ("Fin.\n");
contentPane.setLayout (null);
this .getContentPane ( ) .add ( jScrollPane1, null);
jScrollPane1.getViewport ( ) .add ( jTextArea1, null);
}
}

Langage C# : zone de texte multi-ligne - classe TextBox

Deux classes minimales en C# pour afficher le TextBox en mode multi-ligne dans une fiche :
using System ;
using System .Drawing ;
using System .Windows.Forms ;

namespace ProgTest
{
class WinForm : System .Windows.Forms.Form
{
private System .Windows.Forms.TextBox textBox1 ;
public WinForm ( ) {

Les bases de l’informatique - programmation - ( rév. 04.01.2005 ) page 1000


this .textBox1 = new System .Windows.Forms.TextBox ( );
this .SuspendLayout ( );
// textBox1:
this .textBox1.BackColor = System .Drawing.Color.SkyBlue ;
this .textBox1.Location = new System .Drawing.Point ( 32, 48);
this .textBox1.Name = "textBox1";
this .textBox1.Size = new System .Drawing.Size ( 208, 100 );
this .textBox1.Multiline = true;
this. textBox1.ScrollBars = System.Windows.Forms.ScrollBars.Both;
// au choix (action équivalentes) :
this .textBox1.AppendText ("Bonjour\r\n" );
this .textBox1.AppendText ( "texte multi-ligne\r\n" );
this .textBox1.AppendText ( "Fin.\r\n" );

this .textBox1.Text = "Bonjour\r\ntexte multi-ligne\r\nFin.";

// WinForm:
this .Text = "WinForm";
this .Controls.Add (this .textBox1 );
this .ResumeLayout ( false );
}

protected override void Dispose ( bool disposing ) {


base.Dispose ( disposing );
}
}

class Application1
{
static void Main ( string[ ] args ) {
WinForm F = new WinForm ( );
F.BackColor = System .Drawing.Color.Bisque ;
Application.Run ( F );
}
}
}

La liste de chaînes

Langage Delphi : liste de chaînes - classe TListBox

Une unit pour visualiser un TListBox déposé sur une fiche Form1, le TListBox contient des
chaînes et il est construit dynamiquement sur la fiche :

Les bases de l’informatique - programmation - ( rév. 04.01.2005 ) page 1001


unit Ulistbox ;

interface

uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, ComCtrls, StdCtrls ;

type
TForm1 = class (TForm)
procedure FormCreate( Sender: TObject) ;
private
{ Déclarations privées }
ListBox1 : TListBox ;
public
{ Déclarations publiques }
end;

var
Form1 : TForm1 ;

implementation

{$R *.dfm}

procedure TForm1.FormCreate( Sender: TObject) ;


begin
ListBox1 := TListBox.Create( self ) ;
ListBox1.Parent :=self ;
ListBox1.SetBounds(50,30,100,90) ;
ListBox1.Items.Append( 'avion' ) ;
ListBox1.Items.Append( 'voiture' ) ;
ListBox1.Items.Append( 'bateau' ) ;
ListBox1.Items.Append( 'fusée' ) ;
ListBox1.Items.Append( 'tricycle' ) ;
ListBox1.Items.Append( 'sous-marin' ) ;
end;

end.

Langage Java : liste de chaînes - classe JList

Rappelons que la classe swing JList est une classe d'affichage d'élément de type object, le stockage effectif est
délégué à un objet modele de type DefaultListModel :

// les déclarations :
DefaultListModel modele = new DefaultListModel ( );
JList jList1 = new JList ( );

Les bases de l’informatique - programmation - ( rév. 04.01.2005 ) page 1002


// dans le constructeur de la fenêtre JFrame :
modele.addElement( "avion" );
...
jList1.setModel ( modele );

Sans autre possibilité car le constructeur de DefaultListModel n'a pas de surcharge.

Gestion de la barre de défilement verticale :

Rappelons que la classe swing JList délègue la gestion de la barre de défilement verticale à un objet conteneur
dont c'est la fonction le JScrollpane, ceci a lieu lorsque le JList est ajouté au JScrollpane. Le mécanisme est le
même que celui qui est décrit dans le fonctionnement du JTextArea avec ses barres de défilement, par exemple
en ajoutant le JList au JScrollpane:

// les déclarations :
JScrollPane scrollPane = new JScrollPane( );
JList jList1 = new JList ( );

// dans le constructeur de la fenêtre JFrame :


this.getContentPane( ).add( scrollPane );
scrollPane.getViewport( ).add(jList1 );

Deux classes minimales en Java-swing pour visualiser un JList :


import java.awt. * ;
import javax.swing. * ;

public class ApplicationListe


{
public static void main ( String [] args ) {
Fiche Fen = new Fiche ( );
Fen.setVisible ( true );
}
}

class Fiche extends JFrame


{
private Container contentPane ;
private DefaultListModel modele = new DefaultListModel ( );
private JList jList1 = new JList ( );

public Fiche ( )
{
contentPane = ( Container ) this.getContentPane ( );
contentPane.setBackground ( SystemColor.info );

Les bases de l’informatique - programmation - ( rév. 04.01.2005 ) page 1003


contentPane.setLayout (null);

modele.addElement ("avion");
modele.addElement ("voiture");
modele.addElement ("bateau");
modele.addElement ("fusée");
modele.addElement ("tricycle");
modele.addElement ("sous-marin");
jList1.setModel ( modele );
jList1.setBackground ( Color.pink );
JScrollPane scrollPane = new JScrollPane ( );
scrollPane.setBounds ( 64,32,112,70 );
scrollPane.getViewport ( ).add ( jList1 );

this.setBounds ( 100,100, 271, 165 );


this.setTitle ("Titre du cadre");
this.setDefaultCloseOperation ( EXIT_ON_CLOSE );
contentPane.add ( scrollPane );
}
}

Langage C# : liste de chaînes - classe ListBox


Deux classes minimales en C# pour visualiser un System.Windows.Forms.ListBox :
using System ;
using System.Windows.Forms ;

namespace ProgTest
{
public class WinForm : System.Windows.Forms.Form
{
private System.Windows.Forms.ListBox listBox1 ;

public WinForm ( ) {
// listBox1
this .listBox1 = new ListBox ( );
this .listBox1.Items.AddRange (new object [ ] {
"avion" ,
"voiture" ,
"bateau" ,
"fusée" ,
"tricycle" ,
"sous-marin"
}
);
this .listBox1.SetBounds ( 64,32,112,82 );

// WinForm
this .BackColor = System .Drawing.Color.Moccasin ;
this .Controls.Add (this .listBox1 );
this .Text = "WinForm";
this .SetBounds ( 100,80,270,165 );
}

protected override void Dispose ( bool disposing ) {


base .Dispose ( disposing );

Les bases de l’informatique - programmation - ( rév. 04.01.2005 ) page 1004


}
}

class Application1
{
static void Main ( string [ ] args ) {
WinForm F = new WinForm ( );
F.BackColor = System .Drawing.Color.Bisque ;
Application.Run ( F );
}
}
}

La liste d'affichage arborescente

Langage Delphi : liste arborescente - classe TTreeView

Une unit pour visualiser un TTreeView déposé sur une fiche Form1 construit
dynamiquement sur la fiche :

unit Utreeview ;

interface

uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, ComCtrls ;

type
TForm1 = class (TForm)
procedure FormCreate( Sender: TObject) ;
private
{ Déclarations privées }
TreeView1 : TTreeView ;
public
{ Déclarations publiques }
end;

var
Form1 : TForm1 ;

implementation

{$R *.dfm}

Les bases de l’informatique - programmation - ( rév. 04.01.2005 ) page 1005


procedure TForm1.FormCreate( Sender: TObject) ;
var noeud : TTreeNode ;
begin
TreeView1 := TTreeView.Create( self ) ;
TreeView1.Parent :=self ;
TreeView1.SetBounds(50,10,150,120) ;
noeud := TreeView1.Items.Add( nil , 'un' ) ;
noeud := TreeView1.Items.Add(noeud, 'deux' ) ;
noeud := TreeView1.Items.Add(noeud, 'trois' ) ;
noeud := TreeView1.Items.Add(noeud, 'quatre' ) ;
TreeView1.Items.AddChild(TreeView1.Items[0], 'un1' ) ;
TreeView1.Items.AddChild(TreeView1.Items[2], 'deux1' ) ;
TreeView1.Items.AddChild(TreeView1.Items[3], 'deux11' ) ;
TreeView1.Items.AddChild(TreeView1.Items[2], 'deux2' ) ;
TreeView1.Items.AddChild(TreeView1.Items[6], 'trois1' ) ;
end;

end.

Langage Java : liste arborescente - classe JTree

La classe swing JTree est un affichage arborescent donc chaque noeud est lui-même un objet
de type DefaultMutableTreeNode qui se construisent comme des arbres classiques.

Gestion de la barre de défilement verticale :

La classe swing JTree délègue la gestion de la barre de défilement verticale à un objet conteneur dont c'est la
fonction le JScrollpane, comme pour le JList et le JTextArea par ajout au JScrollpane.

Deux classes minimales en Java-swing pour visualiser un JTree rattaché à un objet de gestion
de barres JScrollPane nommé treeView :

import java.awt.* ;
import javax.swing.* ;
import javax.swing.tree.* ;

public class ApplicationTree


{
public static void main ( String [] args ) {
Fiche Fen = new Fiche ( );

Les bases de l’informatique - programmation - ( rév. 04.01.2005 ) page 1006


Fen.setVisible ( true );
}
}

class Fiche extends JFrame


{
private Container contentPane ;
private DefaultMutableTreeNode racine = new DefaultMutableTreeNode (null);
private JTree tree ;
private JScrollPane treeView ;

public Fiche ( ) {
contentPane = ( Container ) this .getContentPane ( );
contentPane.setBackground ( SystemColor.info );
contentPane.setLayout (null);

DefaultMutableTreeNode noeud = new DefaultMutableTreeNode ("un");


DefaultMutableTreeNode noeud1 = new DefaultMutableTreeNode ("un1");
racine.add ( noeud );
noeud.add ( noeud1 );
noeud = new DefaultMutableTreeNode ("deux");
noeud1 = new DefaultMutableTreeNode ("deux1");
racine.add ( noeud );
noeud.add ( noeud1 );
noeud1.add (new DefaultMutableTreeNode ("deux11"));
noeud.add (new DefaultMutableTreeNode ("deux2"));
noeud = new DefaultMutableTreeNode ("trois");
racine.add ( noeud );
noeud1 = new DefaultMutableTreeNode ("trois1");
noeud.add ( noeud1 );
noeud = new DefaultMutableTreeNode ("quatre");
racine.add ( noeud );

tree = new JTree ( racine );


treeView = new JScrollPane ( tree );
treeView.setBounds ( 20,20, 150, 100 );

this .setBounds ( 100,100, 271, 165 );


this .setTitle ("Titre du cadre");
this .setDefaultCloseOperation ( EXIT_ON_CLOSE );
contentPane.add ( treeView );
}
}

Langage C# : liste arborescente - classe TreeView


Les bases de l’informatique - programmation - ( rév. 04.01.2005 ) page 1007
Un TreeView est une collection arborescente donc chaque noeud est lui-même un objet TreeNode,
la propriété Nodes permet d'accéder à la collection des noeuds , elle contient un indexeur.

Deux classes minimales en C# pour visualiser un System.Windows.Forms.TreeView :

using System ;
using System .Windows.Forms ;

namespace ProgTest
{
public class WinForm : System .Windows.Forms.Form
{
private System .Windows.Forms.TreeView treeView1 ;

public WinForm ( ) {
// treeView1
this .treeView1 = new System .Windows.Forms.TreeView ();
this .treeView1.SetBounds ( 50,10,150,120 );
this .treeView1.Nodes.Add ("un");
this .treeView1.Nodes.Add ("deux");
this .treeView1.Nodes.Add ("trois");
this .treeView1.Nodes.Add ("quatre");
this .treeView1.Nodes[0].Nodes.Add ("un1");
this .treeView1.Nodes[1].Nodes.Add ("deux1");
this .treeView1.Nodes[1].Nodes[0].Nodes.Add ("deux11");
this .treeView1.Nodes[1].Nodes.Add ("deux2");
this .treeView1.Nodes[2].Nodes.Add ("trois1");

// WinForm
this .BackColor = System .Drawing.Color.Moccasin ;
this .Controls.Add (this .treeView1 );
this .Text = "WinForm";
this .SetBounds ( 100,80,270,165 );
}

protected override void Dispose ( bool disposing ) {


base .Dispose ( disposing );
}
}

class Application1
{
static void Main ( string [ ] args ) {
WinForm F = new WinForm ( );
F.BackColor = System .Drawing.Color.Bisque ;

Les bases de l’informatique - programmation - ( rév. 04.01.2005 ) page 1008


Application.Run ( F );
}
}
}

Un conteneur de composants : le panneau

Langage Delphi : panneau conteneur - classe TPanel

Une unit pour visualiser un TPanel déposé sur une fiche Form1, le TPanel contient un
TButton et un TEdit, ces trois contrôles sont construits dynamiquement sur la fiche :

unit Upanel ;

interface

uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, ExtCtrls, StdCtrls ;

type
TForm1 = class (TForm)
procedure FormCreate( Sender: TObject) ;
private
Panel1 : TPanel ;
Button1 : TButton ;
Edit1 : TEdit ;
public
{ Déclarations publiques }
end;

var
Form1 : TForm1 ;

implementation

{$R *.dfm}

procedure TForm1.FormCreate( Sender: TObject) ;


begin
Panel1 := TPanel.Create( self ) ;
Panel1.Parent :=self ;
Panel1.SetBounds(20,10,200,100) ;
Panel1.Color := clSilver ;
Panel1.Caption := 'Panneau';
Button1 := TButton.Create( self ) ;
Button1.Parent := Panel1 ;

Les bases de l’informatique - programmation - ( rév. 04.01.2005 ) page 1009


Button1.Caption := 'Ok';
Button1.SetBounds(15,70,60,25) ;
Edit1 := TEdit.Create( self ) ;
Edit1.Parent := Panel1 ;
Edit1.SetBounds(15,13,100,20) ;
Edit1.Text := 'Salut'
end;

end.

Langage Java : panneau conteneur - classe JPanel

La classe swing JPanel est une classe conteneur d'autres composants swing ou bien Awt.

Deux classes minimales en Java-swing pour visualiser un JPanel déposé sur une fiche
nommée Panel héritant des JFrame, le JPanel contient un JButton et un JTextField, ces trois
contrôles sont construits dynamiquement sur la fiche Panel :

import java.awt. * ;
import java.awt.event. * ;
import javax.swing. * ;

class Fiche extends JFrame


{
private JPanel jPanel = new JPanel ( ) ;
private JButton jButton = new JButton ( ) ;
private JTextField jTextField = new JTextField () ;
private Container contentPane ;

public Fiche ( ) {
this .setBounds ( 100,80,270,165 );
this .setDefaultCloseOperation ( EXIT_ON_CLOSE );
this .setTitle ("Fiche JFrame swing");
contentPane = ( Container ) this .getContentPane ( );
contentPane.setBackground ( SystemColor.info );
contentPane.setLayout (null);

//le jPanel
jPanel.setBackground ( Color.lightGray );
jPanel.setBounds ( 20, 10,200, 100 );
jPanel.setLayout (null);

//le jButton
jButton.setBounds ( 15, 70,60, 25 );

Les bases de l’informatique - programmation - ( rév. 04.01.2005 ) page 1010


jButton.setText ("Ok");

//le jTextField
jTextField.setBounds ( 15, 13,100, 20 );
jTextField.setText ("Salut");

//les liaisons de parent au niveau conteneurl


contentPane.add ( jPanel );
jPanel.add ( jButton );
jPanel.add ( jTextField );
this .show ( );
}
}

public class AppliPanel {


public static void main ( String [ ] arg ) {
new Fiche ( );
}
}

Langage C# : panneau conteneur - classe Panel


Deux classes minimales en C# pour visualiser un System.Windows.Forms.Panel contenant un
System.Windows.Forms.TextBox en mode mono-ligne et un System.Windows.Forms.Button :
using System ;
using System .Drawing ;
using System .Collections ;
using System .ComponentModel ;
using System .Windows.Forms ;
using System .Data ;

namespace ProgTest
{
public class WinForm : System .Windows.Forms.Form
{
private System .Windows.Forms.Panel panel1 ;
private System .Windows.Forms.TextBox textBox1 ;
private System .Windows.Forms.Button button1 ;

public WinForm ( )
{
this .panel1 = new System .Windows.Forms.Panel ( );
this .textBox1 = new System .Windows.Forms.TextBox ( );
this .button1 = new System .Windows.Forms.Button ( );

// panel1
this .panel1.BackColor = System .Drawing.Color.Silver ;
this .panel1.Controls.Add (this .button1 );

Les bases de l’informatique - programmation - ( rév. 04.01.2005 ) page 1011


this .panel1.Controls.Add (this .textBox1 );
this .panel1.SetBounds ( 20, 10,200, 100 );
this .panel1.TabIndex = 0 ;

// textBox1
this .textBox1.SetBounds ( 15, 13,100, 20 ) ;
this .textBox1.TabIndex = 0 ;
this .textBox1.Text = "Salut";

// button1
this .button1.SetBounds ( 15, 70,60, 25 );
this .button1.TabIndex = 1 ;
this .button1.Text = "Ok";

// WinForm
this .BackColor = System .Drawing.Color.Moccasin ;
this .Controls.Add (this .panel1 );
this .Text = "WinForm";
this .SetBounds ( 100,80,270,165 );
}

protected override void Dispose ( bool disposing ) {


base .Dispose ( disposing );
}
}

class Application1
{
static void Main ( string[ ] args ) {
WinForm F = new WinForm ( );
F.BackColor = System .Drawing.Color.Bisque ;
Application.Run ( F );
}
}
}

Les bases de l’informatique - programmation - ( rév. 04.01.2005 ) page 1012

Vous aimerez peut-être aussi