C# versus Java

Différences en Java et C#
Apprendre le C# à partir de Java
Contenu
1. Introduction..........................................................................................................................1
2. C# n'est qu'un clone de Java...............................................................................................1
3. La même chose mais en différent.......................................................................................7
4. Comme un air de "Déjà Vu"..............................................................................................20
5. Maintenant, des choses totalement différentes..............................................................37
6. Concepts avancés...............................................................................................................50
7. Conclusion..........................................................................................................................53
1. Introduction
Cet article se propose de vous faire connaître C# à travers un ensemble de
caractéristiques communes ou divergentes 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 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 dans la classe Object.
Remarque : En C#, la classe de base peut être écrite soit en minuscule "object" soit en
capital "Object". En fait, à la compilation ces deux types sont remplacés par System.Object.
2.2 Nommage
C# se distingue de Java par le nom des méthodes qui commencent conventionnellement
par une majuscule. Par exemple, la méthode main de Java se nomme main() et Main() en
C#. Le reste des noms utilisent la même convention.
2.3 À 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
É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.ensicaen.fr

2 ■ Différences en Java et C#
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.4 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 primitifs (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.
2.5 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 uncheckedN/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 synchronize
dstackalloc N/A : implements
double double long long static static N/A strictfp
else else namespac
epackage 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.6 Pas de fonctions globales
Comme en Java et contrairement à C++, les méthodes en C# doivent être intégrées dans
une classe.
ENSICAEN - Spécialité Informatique

Différences en Java et C# ■ 3
2.7 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.8 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.
Code Java
String jString = "Grapes";
// Ne modifie pas la chaîne, mais retourne une copie
jString.toLowerCase();
Code C#
string csString = "Apple Jack";
// Ne modifie pas la chaîne, mais retourne une copie
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 StringBuffer pour Java et StringBuilder pour C#.
Remarque : En C#, la classe chaîne peut-être écrite sous la forme string ou String.
2.9 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#,
on utilise le mot-clé sealed (scellée en français) 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() {}
}
ENSICAEN - Spécialité Informatique

4 ■ Différences en Java et C#
2.10 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.
Remarque : 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); }
}
public class ExceptionTest {
static void doStuff(){
throw new ArithmeticException();
}
public static void main(String[] args) throws Exception{
try{
try{
doStuff();
return; // Ne sera pas exécuté
} catch(RuntimeException e) { // parent de ArithmeticException
throw new MyException("MyException levée", e);
}
} finally {
System.out.println("***Block executé même si MyException est
lévée");
}
}
}
Code C#
class MyException: Exception {
public MyException(string message): base(message){ }
public MyException(string message, Exception innerException):
base(message, innerException){ }
}
public class ExceptionTest {
ENSICAEN - Spécialité Informatique

Différences en Java et C# ■ 5
static void DoStuff() {
throw new FileNotFoundException();
}
public static int Main() {
try {
try {
DoStuff();
return 0; // Ne sera pas exécuté
} catch(IOException ioe) { // parent de FileNotFoundException
throw new MyException("MyException levée", ioe);
}
} finally {
Console.WriteLine("***Block executé même si MyException est lévée");
}
}
}
2.11 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 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("Main() exécuté");
}
}
ENSICAEN - Spécialité Informatique