
version 0.20
Cette page est consultable pour des raisons historiques : elle n'est maheureusement plus maintenue faute de temps.
Copyright ©2003-2004 Jean Michel DOUDOUX - All Rights Reserved.
Déclaration et initialisation de variables
| V.B. 6 | Delphi | Java | C# | V.B. .Net | |
| Obligation de déclarer les variables | Oui avec Option Explicit | Oui | Oui | Oui | Oui avec Option Explicit | 
| Affectation | variable = 0 | variable := 0; | variable = 0; | variable = 0; | |
| Déclaration d’une variable | Dim var ` var de type variant Dim var As Integer Public var as Integer Private var as Integer ` private equivalent de Dim  | 
                    var i : integer;  | 
                    int i = 0; | int i = 0; | Dim i as Integer = 0 | 
| Définir un entier sur 1 octet non signé (0 à 255) | Byte | Byte | byte (System.Byte du framework.Net) | Byte | |
| Définir un entier sur 1 octet signé (-128 à 127) | ShortInt | byte | sbyte (System.SByte du framework.Net) | ||
| Définir un entier sur 2 octets non signé (-32768 à 32767) | Integer | SmallInt | ushort (System.UInt16 du framework.Net) | ||
| Définir un entier sur 2 octets signé (0 à 65535) | Word | short | short (System.Int16 du framework.Net) | Short (System.Int16 du framework.Net) | |
| Définir un entier sur 4 octets signé (-2147483648 et 2147483647) | Long | Integer | integer | int (System.Int32 du framework.Net) | Integer (System.Int32 du framework.Net) | 
| Définir un entier sur 4 octets non signé (0 et 4294967295) | Cardinal, LongWord | uint (System.UInt32 du framework.Net) | |||
| Définir un entier sur 8 octets non signé | ulong (System.UInt64 du framework.Net) | ||||
| Définir un entier sur 8 octets signé | long | long (System.Int64 du framework.Net) | Long (System.Int64 du framework.Net) | ||
| Définir un booléen | Boolean | Boolean, ByteBool, WordBool, LongBool | boolean | bool (System.Boolean du framework.Net) | Boolean (System.Boolean du framework.Net) | 
| Définir un réel sur 4 octets | Single | float | float (System.Single du framework.Net) | Single (System.Single du framework.Net) | |
| Définir un réel sur 8 octets | Double | double | double (System.Double du framework.Net) | Double (System.Double du framework.Net) | |
| Définir un éel sur 12 octets | Decimal | ||||
| Définir un réel sur 16 octets | decimal | Decimal (System.decimal du framework .Net) | |||
| Définir un caractère sur un octets | Char, AnsiChar | ||||
| Définir un caractère sur 2 octets | WideChar | char | char (System.Char) | Char | |
| Déclarer plusieurs variables d'un même type | var i,j : integer;  | 
                    int i=0, j=0; | int i,j; | Dim i, j As Integer | |
| Déclarer une date | Date | TDateTime | java.lang.Date | Date (System.DateTime du framework .Net) | |
| Déclaration de constantes | Const constante = 10 Const constante as Integer = 10 Const c1 = 1, c2 = 2  | 
                    const valeur : Integer = 10; const Chiffres: array[0..9] of Char = ('0', '1', '2', '3', '4', '5', '6', '7', '8', '9');  | 
                    static final int i = 10; | const int i = 10; | Const constante = 10 Const constante as Integer = 10  | 
                  
| Indice de départ d’un tableau | 0 par défaut 1 avec l'instruction Option Base 1  | 
                    selon l'index précisé dans la déclaration | 0 | 0 | |
| Déclaration d’un tableau | Dim tableau(20) As Integer | tableau : Array[0..19] of integer; | int[] tableau1 = new int[10]; int tableau2[] = new int[10];  | 
                    int[] tableau1 = new int[10]; | Dim tableau1(10) as Integer | 
| Déclaration d’un tableau avec indice de début particulier  | 
                    Dim tableau(10 To 20) As Integer | tableau : Array[10..20] of integer; | |||
| Déclaration d’un tableau à deux dimensions | Dim tableau(1 To 5, 1 To 3) as Double | tableau : Array[1..3,1..2] of integer; | int [][] tableau = new int[3][2]; | int [][] tableau = new int[3, 2]; | Dim tableau(3,2) As Integer | 
| Déclaration d’un tableau avec initialisation | Dim noms  | 
                    int[] tableau = new int[] {1, 2, 3}; int[][] tableau = new int[][] {{0, 1, 2},{3, 4, 5}};  | 
                    tableau = new int[] {1, 2, 3}; int[] tableau = {1, 2, 3}; int [,] tableau = {{0, 1, 2}, {3, 4, 5}};  | 
                    Dim tableau() As Integer = { 1, 2, 3 } | 
                  |
| Déclaration d’un tableau dynamique | Dim tableau() as Integer ... ReDim tableau(20) ReDIm Preserve tableau(30)  | 
                    ||||
| Définir un type de données | Type personne ... End Type Dim moi As personne  | 
                    type TPoint = record x, y: Integer; end;  | 
                    |||
| Définir une énumération | Enum typeDonnee Type1 Type2 Type3 Type4 TypeAutre = 99 End Enum ' chaque élément possède une valeur incrémentée de 1 en 1 à partir de 0 sauf si la valeur est précisée  | 
                    
Les procédures et les fonctions
| V.B. 6 | Delphi | Java | C# | V.B. .Net | |
| Définir une procédure ou méthode sans valeur de retour | [Public|Private][Static]Sub traitement([arguments]) ... End Sub  | 
                    procedure traitement(); var ... begin ... end;  | 
                    void traitement() { ... }  | 
                    void traitement() { ... }  | 
                    Sub traitement() ... End Sub  | 
                  
| Définir une fonction ou methode avec une valeur de retour | [Public|Private][Static]Function traitement([arguments]) As Type_renvoye ... End Function  | 
                    function traitement([arguments]) : Type_renvoye; begin result := valeur_retournee; end;  | 
                    String traitement() { return "bonjour"; }  | 
                    String traitement() { ... return "bonjour" }  | 
                    Function traitement() as String ... Return "bonjour" End Function  | 
                  
| Passer un paramètre par valeur | ByVal | // Passage des paramètres par défaut procedure traitement(num : Integer); begin num := 0; end;  | 
                    // Passage  des paramètres par défaut int i = 0; maMethode(i); ... void maMethode(int entier) { entier = 2; }  | 
                    // Passage  des paramètres par défaut int i = 0; maMethode(i); ... void maMethode(int entier) { entier = 2; }  | 
                    |
| Passer un paramètre par référence | ' Passage  des paramètres par défaut ByRef  | 
                    procedure traitement(var num : Integer); begin num := 0; end;  | 
                    int i = 0; maMethode(ref i); ... static void maMethode(ref int entier) { entier = 2; }  | 
                    ||
| Renvoyer un paramètre par référence sans fournir de valeur initiale | ...  string chaine, res1, res2; traitement("boNJOur",out res1, out res2); ... static void traitement(string chaine1, out string chainemin, out string chainemaj) { chainemin = chaine1.ToLower(); chainemaj = chaine1.ToUpper(); }  | 
                    ||||
| Passer un nombre quelconque de paramètres d'un même type | // A PARTIR DU JDK 1.5  public static int additionner(int ... valeurs) { int total = 0; for (int val : valeurs) { total += val; } return total; }  | 
                    ... string chaine = concatener("Bonjour"," tout ","le monde"); ... static private string concatener(params string[] chaines) { StringBuilder res = new StringBuilder(""); foreach(string s in chaines) { res.Append(s); } return res.ToString(); }  | 
                    |||
| Appel d'une procedure | Call traitement(var1, var2) traitement var1, var2  | 
                    traitement;  | 
                    
Les commentaires
| V.B. 6 | Delphi | Java | C# | V.B. .Net | |
| Commentaires sur une ligne | ' mon commentaire Rem mon commentaire  | 
                    {mon commentaire} | // mon commentaire | // mon commentaire | ' mon commentaire | 
| Commentaire de fin de ligne | // mon commentaire | // mon commentaire | // mon commentaire | ||
| Commentaire sur plusieurs lignes | ' mon commentaire 1 ' mon commentaire 2  | 
                    //* mon commentaire 1 mon commentaire 2 *//  | 
                    /* mon commentaire 1 mon commentaire 2 */  | 
                    /* mon commentaire 1 mon commentaire 2 */  | 
                    ' mon commentaire 1 ' mon commentaire 2  | 
                  
Les opérateurs arithmétiques
| V.B. 6 | Delphi | Java | C# | V.B. .Net | |
| addition, soustraction, multiplication, division | + - * / | + - * / | + - * / | + - * / | + - * / | 
| Division entière | \ | div | |||
| Puissance | ^ | ^ | |||
| Modulo | Mod | mod | % | ||
| Valeur absolue | Abs | Abs | |||
| Partie entière | Fix | ||||
| Valeur aléatoire | Randomize ` initialisation du générateur Rnd  | 
                    Randomize; Random  | 
                    
Les opérateurs de comparaison
| V.B. 6 | Delphi | Java | C# | V.B. .Net | |
| inférieur, inférieur ou égal, supérieur, supérieur ou égal | < <= > >= | < <= > >= | < <= > >= | < <= > >= | |
| égalité | = | = | == | == | |
| inégalité | <> | <> | != | != | 
Les opérateurs logiques
| V.B. 6 | Delphi | Java | C# | V.B. .Net | |
| non (vrai si faux) | Not | not | ! | ! | |
| et (vrai si les deux sont vraies) | And | and | && | && | |
| ou inclusif (vrai si une au moins est vraie) | Or | or | || | || | |
| ou exclusif (vrai si une seule est vraie) | Xor | 
Les instructions
| V.B. 6 | Delphi | Java | C# | V.B. .Net | |
Fin d'instruction  | 
                    ;  | 
                    ;  | 
                    ;  | 
                    ||
Bloc de code  | 
                    begin  | 
                    { ... }  | 
                    { ... }  | 
                    ||
| Boucle de type pour chaque | For compteur = 0 To 5 Step 1 ... Next  | 
                    For i := 0 to 5 do begin ... end;  | 
                    for(int i=0; i < 10; i++) for (;;)  | 
                    for(int i=0; i < 10; i++) for (;;)  | 
                    For I = 0 To 9 ... Next  | 
                  
| Boucle de type tant que | i = 0 Do While i < 9 i = i + 1 Loop  | 
                    i := 0; While ( i < 9 ) do begin inc(i); end;  | 
                    while (true) { ... } int i = 0; while ( i < 9) { i++; }  | 
                    int i = 0; while ( i < 9) { i++; }  | 
                    While True ... End While i = 0 Do While i < 9 i += 1 Loop  | 
                  
| Boucle de type jusqu'à ce que | i = 0 Do Until i >= 9 i = i + 1 Loop  | 
                    i := 0; Repeat inc(i); Until ( i > 9 );  | 
                    int i = 0; do { i++; } while (i < 9);  | 
                    int i = 0; do { i++; } while( i < 9)  | 
                    |
| Incrémentation | i = i + 1 | inc(i) ; | i++ ; | i++ ; | i = i + 1  | 
                  
| Test | If ... Then ... Else ... End if If ... Then ... ElseIf ... Then Else ... End if  | 
                    if ... then begin ... end else begin ... end;  | 
                    if (i == 0) {  | 
                    if (i == 0) { ... } else { ... }  | 
                    If (i = 0)  ... End If  | 
                  
| Parcours d'une collection | int[] tableau = new int[] {1,2,3}; foreach (int i in tableau){}  | 
                    For Each i In tableau ... Next | |||
| Test par cas multiple | Select Case valeur Case 0 ... Case 1 ... Case 2,3 ... Case Else ... End Select  | 
                    Case valeur of  0 : begin ... end; 1 : begin ... end; else begin ... end; end;  | 
                    switch (valeur) { case 0 : ... break; case 1 : ... break; case 2 : case 3 : ... break; default : ... break; }  | 
                     switch (valeur) { case 0 : ... break; case 1 : ... break; case 2 : case 3 : ... break; default: ... break; } // utilisation possible de chaines switch (prenom) { case "Pierre" : ... break; case "Paul" : ... break; case "Michel" : ... break; default : ... break; }  | 
                    Select Case valeur  | 
                  
| Civilite = IIf(sexe="M", " Monsieur ", " Madame ") | Civilite = (sexe == 'M') ? "Monsieur" : "Madame"; | ||||
| Factoriser un objet | With label1  | 
                    
Les chaînes de caractères
| V.B. 6 | Delphi | Java | C# | V.B. .Net | |
| Déclarer une chaîne de caractères | Dim chaine as String | String, AnsiString, WideString | String chaine = "ma chaine"; | String chaine = "ma chaine"; | Dim chaine as String = "ma chaine " | 
| Déclarer une chaîne de caracrtères de taille fixe | Dim chaine As String * 20 | ShortString (0 à 255 caractères) | |||
| Longueur d'une chaîne de caractères | t = Len(chaine1) | t := Length(chaine1); | int longueur = chaine.length(); | int longueur = chaine.length ; | |
| Concaténer deux chaînes | chaine = chaine1 & chaine2 | chaine := chaine1 + chaine2; | chaine = chaine1 + chaine2; | chaine = chaine1 + chaine2; | |
| Convertir en minuscule | chaine2 = LCase(chaine1) | chaine2 := LowerCase(chaine1); | chaine2 = chaine1.toUpperCase(); | chaine2 = chaine1.ToUpper(); | |
| Convertir en majuscule | chaine2 = UCase(chaine1) | chaine2 := UpperCase(chaine1); | chaine2 = chaine1.toLowerCase(); | chaine2 = chaine1.ToLower(); | |
| Rechercher la position d'une sous chaîne | p = Instr("bonjour","j") | p := pos(chaine2, chaine1); | int p = chaine1.indexOf(chaine2); | int p = chaine1.IndexOf(chaine2); | |
| Renvoyer une sous chaîne | chaine2 = Mid(chaine1,0,5) | chaine2 := copy(chaine1,0,5); | chaine2 = chaine1.substring(0,5); | chaine2 = chaine1.Substring(0, 5); | |
| Conversion en chaîne de caractères | chaine2 = cstr(valeur) | chaine = objet.toString() ; | chaine = objet.ToString() ; | ||
| Construction de chaîne avec un buffer | StringBuffer chaine = new StringBuffer(""); chaine.append("hello"); chaine.append(" world");  | 
                    StringBuilder chaine = new StringBuilder(); chaine.Append("hello"); chaine.Append(" world"); | Dim chaine As New StringBuilder() chaine.Append("hello") chaine.Append(" world") | ||
| Suppression des blancs au début et à la fin | chaine1 = Trim(chaine2) | chaine1 := Trim(chaine2); | chaine1 = chaine2.trim(); | chaine1 = chaine2.Trim(); | |
| Extraire les éléments d’une chaine avec un séparateur | Dim res res = Split("1;2;3;4",";") 'renvoie un variant contenant un tableau  | 
                    String token; StringTokenizer st = new StringTokenizer("1,2,3,4", ","); while ( st.hasMoreTokens() ) { token = st.nextToken(); System.out.println("jeton : " + token); }  | 
                    string chaine = "1,2,3,4"; string[] tokens = chaine.Split(new Char[] {','});  | 
                    ||
| Remplacement | chaine1 = Replace(chaine2, "remplace","remplacant") | chaine1 := AnsiStringReplace(chaine2, "remplace","remplacant"); | 
Les convertions
| V.B. 6 | Delphi | Java | C# | V.B. .Net | |
| Convertir une chaîne en entier | CInt CLng  | 
                    p := StrToInt(chaine1); | i = new Integer(chaine).intValue(); |  i = int.Parse(chaine);  // ou i = Convert.ToInt32(chaine);  | 
                    i = Integer.Parse(chaine) | 
| Savoir si une variable est numeric | isNumeric("123,5") | ||||
| Convertir une chaine en double | valeur = CDbl(chaine) | valeur = Convert.ToDouble(chaine); | |||
| Convertir une chaine en date | valeur = CDate(chaine) | ||||
| Convertir un entier en chaîne | CStr | chaine1 := IntToStr(p); | chaine1 = "" + p; | chaine1 = "" + p; | 
Dates et heures
| V.B. 6 | Delphi | Java | C# | V.B. .Net | |
| Date Système | Now | Now | // avec l'heure DateTime.Now // sans l'heure DateTime.Today  | 
                    ||
| Déclarer une variable de type date avec initialisation | DateTime datenoel = New DateTime(2004,12,31); | Dim datenoel = #2004-12-31# | |||
| Heure | hh = Hour(now) | HourOf | hh = DateTime.Now.Hour; | ||
| Minute | mm = Minute(now) | MinuteOf | mm = DateTime.Now.Minute; | ||
| Seconde | ss = Second(now) | SecondOf | ss = DateTime.Now.Second; | ||
| Jour | jour = Day(now) | DayOf | jour = DateTime.Now.Day; | ||
| Mois | mois = Month(now) | MonthOf | mois = DateTime.Now.Month; | ||
| Année | annee = Year(now) | YearOf | annee = DateTime.Now.Year; | 
Les objets
| V.B. 6 | Delphi | Java | C# | V.B. .Net | |
| Objet racine | TObject | java.lang.Object | objet (System.Object du framework.net) | ||
| Déclarer et créer un objet | ' objet COM Dim obj As Object Set obj = CreateObject("excel.application")  | 
                    var objet : TObject; begin objet := TObject.create();  | 
                    Object obj = new Object(); | Object obj = new Object(); | Dim obj As New Object() | 
| Détruire un objet | objet.free; | Fait par le ramasse miette | Fait par le ramasse miette | ||
| Classe ne pouvant être héritée | final class MaClasse{} | sealed class MaClasse{} | |||
| Héritage | type TClasseFille = class(TClasseMere); ... end;  | 
                    class ClasseFille extends ClasseMere {} | class ClasseFille : ClasseMere{} |  Public Class ClasseFille Inherits ClasseMere ... End Class  | 
                  |
| Implémentation d’une interface | Type MaCLasse = Class (IMonInterface) ... end;  | 
                    class MaClasse implements MonInterface{} | class MaClasse, MonInterface{} | ||
| Vérifier si un objet est une instance d’une classe | if (monObjet is MaClasse) | if(monObjet instanceof MaClasse) | if (monObjet is MaClasse) | ||
| Transtyper un objet | MaClasse classe = (MaClasse) unObjet ; | MaClasse classe = (MaClasse) unObjet ; | |||
| Constructeur | Constructor create(); | MaClass(){} | MaClass(){} | ||
| Destructeur | Destructor destroy(); | public void finalize() {} | ~MaClass(){} | ||
| Modificateur d'accès | private | private | private | ||
| public | public | public | |||
| protected | protected | internal | |||
| protected | |||||
| internal protected | |||||
| Référence à l'instance courante | self | this | this | ||
| Définition d'une interface | type IMonInterface = interface; ... end;  | 
                    public interface MonInterface { }  | 
                    public interface IMonInterface{ }  | 
                    ||
| Définir une propriété | 
La gestion des erreurs
| V.B. 6 | Delphi | Java | C# | V.B. .Net | |
| Objet encapsulant une erreur | Err | Exception | Exception | Exception | Exception | 
| Protection d'un bloc de code | On Error Goto erreur  | 
                    Try ... Except On e: Exception Do ... End;  | 
                    try { ... } catch (Exception e) { ... }  | 
                    try { ... } catch (Exception e) { ... }  | 
                    Try ... Catch e As Exception ... End Try  | 
                  
| Assurer un traitement à la fin d’un bloc de code | Try ... Finally ... End;  | 
                    try { ... } finally { ... }  | 
                    try { ... } finally { ... }  | 
                    Try  ... Finally ... End Try  | 
                  |
| Lever une nouvelle Exception |  Err.Clear Err.Raise 2002, "MonEntité", "Mon exception"  | 
                    raise Exception.Create() raise Exception.Create('mon exception')  | 
                    throw new MonException(); // ne pas oublier d'ajouter l'exception dans la clause throws de la méthode  | 
                    throw new MonException(); | Throw New MonException() | 
| Repropager une exception capturer | Try ... Except On e: Exception raise; End;  | 
                    try { ... } catch (Exception e) { ... throw e; }  | 
                    |||
| Définir sa propre exception | type EMonException = class(Exception) ... end;  | 
                    public class MonException extends Exception { }  | 
                    public class MonExcpetion : ApplicationException { public MonException(string message) : base(message); }  | 
                     Class MonException Inherits Exception  ... End Class  | 
                  |
Les entrées/sorties standards
| V.B. 6 | Delphi | Java | C# | V.B. .Net | |
| Afficher un message sur la console | System.out.println(" mon message ") ; | System.Console.Out.WriteLine(" mon message ") ; | System.Console.Out.WriteLine(" mon message ") | 
Divers
| V.B. 6 | Delphi | Java | C# | V.B. .Net | |
| Point d'entrée d'une application | public static void main(String[] args){} | public static void Main(String[] args){} |  Public Shared Sub Main(args As String())... End Sub  | 
                  ||
| Afficher un message dans une boîte de dialogue | MsgBox | ShowMessage() MessageDlg()  | 
                    |||
| Saisir des données dans une boîte de dialogue | InputBox | InputBox | |||
| Caractère retour chariot | vbcrlf | chr(13); | '\n' | 
Espace de nom
| V.B. 6 | Delphi | Java | C# | V.B. .Net | |
| Importation | uses StrUtils; // utilisation de fichier .dcu  | 
                    imports java.utils.*; | Using System; | Imports System | |
| Déclaration d’un espace de nom | unit MonProgramme; // déclare le nom de l'unité  | 
                    package monprogramme; | namespace MonProgramme{ ... }  | 
                    Namespace MonProgramme End Namespace  | 
                  
Copyright ©2003-2004 Jean Michel DOUDOUX - All Rights Reserved.
