C# versus Java

C# versus Java
Régis Clouard
1. Introduction
Cet article se propose de vous faire connaître C# à travers un ensemble de caractéristiques
communes ou différentes de Java. L'auteur de l'article original est Dare Obasanjo, traduit
par Alain Vizzini et adapté par mes soins.
2. C# n'est qu'un clone de Java
De manière explicite, les développeurs du langage C# expliquent qu'ils ont
essentiellement développé leur nouveau langage sur le langage Java, en apportant
quelques modifications et ajouts pour combler ce qu'ils considèrent comme des
déficiences. Il existe donc beaucoup de ressemblance entre les deux langages notamment
sur les concepts de base qui fait qu'il est facile d'apprendre un langage si l'on connaît
l'autre.
2.1 Nous sommes tous des objets !
Comme Java, C# possède une super classe, mère de tous les objets : System.Object. La
classe Java équivalent s'appelle java.lang.object. Les méthodes présentent dans ces
deux classes sont très similaires (p. ex: toString()) excepté wait(), notify() et les autres
méthodes liées à la synchronisation.
NOTE : En C#, une classe de type objet peut soit être écrite sous la forme "object" en
minuscule ou "Object". En fait, à la compilation ces deux types sont remplacés par
System.Object.
2.2 À propos des machines virtuelles
De la même manière que Java est compilé en byte-code et s'exécute dans un
environnement d'exécution managé (Machine Virtuelle JVM), C# est compilé en MSIL
s'exécutant dans la CRL (Common Langage Runtime). Les deux plate-formes supportent
la compilation Just In Time (JIT). Toutefois, il existe une légère différence entre les deux
plate-formes, les compilateurs Java permettent de désactiver totalement le JIT en
fonctionnant uniquement en mode interprété alors que les compilateurs .NET en général
intègre nativement le JIT. Enfin, il existe des deux cotés la possibilité de pré-compiler en
code natif le source.
2.3 Gestion de la mémoire (ramasse-miettes)
Tous les objets Java sont créés sur le tas en utilisant le mot-clé new. Il en va de même pour
la plupart des objets C# n'étant pas des types de valeurs (ValueType). La libération de la
mémoire n'est pas explicite elle intervient quand le ramasse-miettes le juge utile et
récupère les objets qui ne sont plus utilisés.
École Nationale Supérieure d'Ingénieurs 6, Boulevard Maréchal Juin, F-14050 CAEN cedex
& Groupe de Laboratoires, C.N.R.S. http://www.greyc.fr

2 ■ C# versus Java
2.4 Synthèse des mots-clés
Il y a énormément de similitudes entre les deux langages La table ci-dessous dresse la
correspondance entre les mots-clés.
mot-clé
C#
mot-clé
Java
mot-clé
C#
mot-clé
Java
mot-clé
C#
mot-clé
Java
mot-clé
C#
mot-clé
Java
abstract abstract explicit N/A object N/A this this
as N/A extern native operator N/A throw throw
base super finally finally out N/A true true
bool boolean fixed N/A override N/A try try
break break float float params N/A typeof N/A
byte N/A for for private private uint N/A
case case foreach for protected N/A ulong N/A
catch catch get N/A public public unchecked N/A
char char goto goto1 readonly const unsafe N/A
checked N/A if if ref N/A ushort N/A
class class implicit N/A return return using import
const const1 in N/A sbyte byte value N/A
continue continue int int sealed final virtual N/A
decimal N/A interface interface set N/A void void
default default internal protected short short while while
delegate N/A is instanceof sizeof N/A : extends
do do lock synchronized stackalloc N/A : implements
double double long long static static N/A strictfp
else else namespace package string N/A N/A throws
enum enum new new struct N/A N/A transient
event N/A null null switch switch volatile volatile
2.5 Pas de méthodes globales
Comme en Java et contrairement à C++, les méthodes en C# doivent être intégrées dans
une classe.
2.6 Les Interfaces, Oui. L'héritage multiple, Non
C#, comme Java, supporte le concept d'interface qui est assimilé à une classe abstraite
pure. De la même façon, C# et Java autorisent l'héritage multiple d'interface et simple
d'implémentation.
2.7 Les chaînes de caractères ne peuvent être modifiées
C# possède une classe System.String qui est équivalente à java.lang.String. Les deux
classes sont "immuables", c’est-à-dire qu'une fois les objets créés, il n'est pas possible de
modifier leur valeur. Ceci dans le but de protéger le mécanisme d'encapsulation ô
combien fondamental.
Code Java
String jString = "Grapes";
/* Does not modify string, instead returns lower case copy of string */
jString.toLowerCase();
Code C#
string csString = "Apple Jack";
ENSICAEN - Spécialité Informatique

C# versus Java ■ 3
/* Does not modify string, instead returns lower case copy of string */
csString.ToLower();
Pour créer une chaîne de caractères autorisant la modification avec la même référence, il
est conseillé d'utiliser les classes System.Text.StringBuilder pour C# et
java.lang.StringBuffer pour Java.
NOTE: En C#, la classe chaîne peut-être écrite sous la forme string ou String.
2.8 Les classes non extensibles
Les deux langages proposent des mécanismes consistant à interdire toute extension d'une
classe ; soit par souci d'optimisation, soit par souci de sécurité. Ainsi, il est interdit de les
dériver pour redéfinir des méthodes ou simplement réutiliser l'implémentation. En C#,
vous utilisez le mot-clé sealed et en Java le mot-clé final.
Code Java
final class Student {
String fname;
String lname;
int uid;
void attendClass() {}
}
Code C#
sealed class Student {
string fname;
string lname;
int uid;
void attendClass() {}
}
2.9 Levée et capture d'Exceptions
Les exceptions en C# et Java partagent énormément de caractéristiques. Les deux
langages supportent l'utilisation de l'ordre try pour indiquer qu'un bloc est susceptible de
lever une exception et catch pour capturer l'exception en question. De plus, finally est
implémenté de la même manière pour spécifier qu'une région de code doit, dans tous les
cas être exécutée (exception ou pas). Cela permet de libérer des ressources proprement.
Les deux langages proposent une hiérarchie de classes d'Exceptions dérivant d'une super
classe : System.Exception pour C# et java.lang.Exception pour Java. Aussi, il est
possible de chaîner la levée ou la capture d'exception (throw dans un catch) de part et
d'autre. Cela permet, lors de la levée d'une exception, de retourner à l'appelant un type
d'exception correspondant à son contexte et à sa couche d'architecture. Par exemple, une
ligne non trouvée dans une table se traduira par une SQLException que le développeur
prendra soin de renvoyer à l'interface graphique sous la forme d'un
ObjectNotFoundException.
NOTE : Cependant, il existe une différence fondamentale entre C# et Java. Comme en
Python, le mot-clé throws n'existe pas en C# car vous n'êtes pas contraint de spécifier
dans la signature d'une méthode le fait qu'elle est susceptible de lever une exception. Il n'y
a, contrairement à Java, aucune vérification de faite à l'exécution.
Code Java
class MyException extends Exception{
public MyException(String message){ super(message); }
public MyException(String message, Exception innerException){
super(message, innerException); }
ENSICAEN - Spécialité Informatique

4 ■ C# versus Java
}
public class ExceptionTest {
static void doStuff(){
throw new ArithmeticException();
}
public static void main(String[] args) throws Exception{
try{
try{
doStuff();
return; //won't get to execute
} catch(RuntimeException e) { /* parent of ArithmeticException
*/
throw new MyException("MyException occured", e);
/* rethrow new exception with cause specified */
}
} finally {
System.out.println("***Finally block executes even though
MyException not caught***");
}
}//main(string[])
} // ExceptionTest
Code C#
class MyException: Exception {
public MyException(string message): base(message){ }
public MyException(string message, Exception innerException):
base(message, innerException){ }
}
public class ExceptionTest {
static void DoStuff() {
throw new FileNotFoundException();
}
public static int Main() {
try {
try {
DoStuff();
return 0; //won't get to execute
} catch(IOException ioe) { /* parent of FileNotFoundException */
throw new MyException("MyException occured", ioe);
/* rethrow new exception with inner exception specified */
}
} finally {
Console.WriteLine("***Finally block executes even though
MyException not caught***");
}
}//Main(string[])
} // ExceptionTest
2.10 Initialisation de membres et constructeurs statiques
Les variables d'instance et les variables statiques peuvent être initialisées dès leur
déclaration, et ce, dans les deux langages. Si la variable membre est une variable
d'instance, alors l'initialisation sera effectuée juste avant l'appel du constructeur. Les
membres statiques, eux, sont initialisés dès le chargement de la classe par le Runtime.
Cela intervient en règle générale avant l'appel du constructeur. Il est aussi possible de
définir des blocs statiques qui seront exécutés au chargement. Ils sont appelés plus
ENSICAEN - Spécialité Informatique

C# versus Java ■ 5
communément constructeurs statiques.
Code Java
class StaticInitTest {
String instMember = initInstance();
String staMember = initStatic();
StaticInitTest() {
System.out.println("In instance constructor");
}
static {
System.out.println("In static constructor");
}
static String initInstance() {
System.out.println("Initializing instance variable");
return "instance";
}
static String initStatic() {
System.out.println("Initializing static variable");
return "static";
}
static void doStuff() {
System.out.println("Invoking static DoStuff() method");
}
public static void main(String[] args) {
System.out.println("Beginning main()");
StaticInitTest.doStuff();
StaticInitTest sti = new StaticInitTest();
System.out.println("Completed main()");
}
}
Code C#
using System;
class StaticInitTest {
string instMember = InitInstance();
string staMember = InitStatic();
StaticInitTest() {
Console.WriteLine("In instance constructor");
}
static StaticInitTest() {
Console.WriteLine("In static constructor");
}
static String InitInstance() {
Console.WriteLine("Initializing instance variable");
return "instance";
}
static String InitStatic() {
Console.WriteLine("Initializing static variable");
return "static";
}
static void DoStuff() {
Console.WriteLine("Invoking static DoStuff() method");
}
public static void Main(string[] args) {
Console.WriteLine("Beginning main()");
StaticInitTest.DoStuff();
StaticInitTest sti = new StaticInitTest();
ENSICAEN - Spécialité Informatique