Question

I just want to clarify one thing. This is not a question on which one is better, that part I leave to someone else to discuss. I don’t care about it. I’ve been asked this question on my job interview and I thought it might be useful to learn a bit more.

These are the ones I could come up with:

• Java is ‘platform independent’. Well nowadays you could say there is the Mono project so C# could be considered too but I believe it is a bit exaggerating. Why? Well, when a new release of Java is done it is simultaneously available on all platforms it supports, on the other hand how many features of C# 3.0 are still missing in the Mono implementation? Or is it really CLR vs. JRE that we should compare here?
• Java doesn’t support events and delegates. As far as I know.
• In Java all methods are virtual
• Development tools: I believe there isn’t such a tool yet as Visual Studio. Especially if you’ve worked with team editions you’ll know what I mean.

Please add others you think are relevant.

Update: Just popped up my mind, Java doesn’t have something like custom attributes on classes, methods etc. Or does it?

Answer 1

Comparing Java 7 and C# 3

(Some features of Java 7 aren’t mentioned here, but the using statement advantage of all versions of C# over Java 1-6 has been removed.)

Not all of your summary is correct:

• In Java methods are virtual by default but you can make them final. (In C# they’re sealed by default, but you can make them virtual.)
• There are plenty of IDEs for Java, both free (e.g. Eclipse, Netbeans) and commercial (e.g. IntelliJ IDEA)

Beyond that (and what’s in your summary already):

• Generics are completely different between the two; Java generics are just a compile-time ‘trick’ (but a useful one at that). In C# and .NET generics are maintained at execution time too, and work for value types as well as reference types, keeping the appropriate efficiency (e.g. a List<byte> as a byte[] backing it, rather than an array of boxed bytes.)
• C# doesn’t have checked exceptions
• Java doesn’t allow the creation of user-defined value types
• Java doesn’t have operator and conversion overloading
• Java doesn’t have iterator blocks for simple implemetation of iterators
• Java doesn’t have anything like LINQ
• Partly due to not having delegates, Java doesn’t have anything quite like anonymous methods and lambda expressions. Anonymous inner classes usually fill these roles, but clunkily.
• Java doesn’t have expression trees
• C# doesn’t have anonymous inner classes
• C# doesn’t have Java’s inner classes at all, in fact – all nested classes in C# are like Java’s static nested classes
• Java doesn’t have static classes (which don’t have any instance constructors, and can’t be used for variables, parameters etc)
• Java doesn’t have any equivalent to the C# 3.0 anonymous types
• Java doesn’t have implicitly typed local variables
• Java doesn’t have extension methods
• Java doesn’t have object and collection initializer expressions
• The access modifiers are somewhat different – in Java there’s (currently) no direct equivalent of an assembly, so no idea of ‘internal’ visibility; in C# there’s no equivalent to the ‘default’ visibility in Java which takes account of namespace (and inheritance)
• The order of initialization in Java and C# is subtly different (C# executes variable initializers before the chained call to the base type’s constructor)
• Java doesn’t have properties as part of the language; they’re a convention of get/set/is methods
• Java doesn’t have the equivalent of ‘unsafe’ code
• Interop is easier in C# (and .NET in general) than Java’s JNI
• Java and C# have somewhat different ideas of enums. Java’s are much more object-oriented.
• Java has no preprocessor directives (#define, #if etc in C#).
• Java has no equivalent of C#’s ref and out for passing parameters by reference
• Java has no equivalent of partial types
• C# interfaces cannot declare fields
• Java has no unsigned integer types
• Java has no language support for a decimal type. (java.math.BigDecimal provides something like System.Decimal – with differences – but there’s no language support)
• Java has no equivalent of nullable value types
• Boxing in Java uses predefined (but ‘normal’) reference types with particular operations on them. Boxing in C# and .NET is a more transparent affair, with a reference type being created for boxing by the CLR for any value type.

This is not exhaustive, but it covers everything I can think of off-hand.