C # developers learning Java, what are the biggest differences you can ignore?

Question

For C # developers looking to learn Java, are there any significant differences between the two languages ​​that need to be specified?

Perhaps some people may consider things the same, but are there some import aspects that cannot be ignored? (or you can really mess up!)

Perhaps, from the point of view of OOP designs, the way GC works, deployment related links, etc.

Answer 1

A few heads from the head:

• Java has no user-defined value types (structs), so don't worry about them.
• Java enumerations are very different from the C # number name approach; they are more OO. They can be used to great effect if you are careful.
• byte Java signed (unfortunately)
• In C #, instance variable initializers are run before the base class constructor; in Java, they run after it is executed (that is, immediately before the constructor body in the "this" class)
• In C #, methods are closed by default. In Java, they are virtual by default.
• The default access modifier in C # is always "the most restrictive access available in the current context"; in Java, this is batch access. (This is worth reading on specific access modifiers in Java.)
• Nested types in Java and C # work a little differently; in particular, they have different access restrictions, and if you do not declare a nested static type, it will have an implicit reference to an instance of the containing class.

Answer 2

here is a very complete comparison of two languages:

http://www.25hoursaday.com/CsharpVsJava.html

Added: http://en.wikipedia.org/wiki/Comparison_of_Java_and_C_Sharp

Answer 3

I am surprised that no one mentioned properties, something completely fundamental in C #, but missing from Java. C # 3 and above also automatically implemented properties. In Java, you should use methods like GetX / SetX.

Another obvious difference is LINQ and lambda expressions in C # 3, which are missing in Java.

There are several other simple but useful things missing from Java, such as verbatim (@ ") strings, operator overloading, and iterators using output and preprocessors are also missing in Java.

One of my personal favorites in C # is that namespace names should not follow the structure of a physical directory. I really like this flexibility.

Answer 4

There are many differences, but they come to my mind:

• No operator overloading in Java. View your copy. Equalizer (instance2) compared to instance == instance2 (especially with strings).
• Used for interfaces that do not have a prefix with I. Often you see namespaces or classes, suffixes with Impl instead.
• Double locking check does not work due to Java memory model.
• You can import static methods without their prefix with the class name, which is very useful in some cases (DSL).
• Switch statements in Java do not require a default, and you cannot use strings as case labels (IIRC).
• Java generators will annoy you. Java generators do not exist at run time (at least in 1.5), this is a compiler trick that causes problems if you want to reflect common types.

Answer 5

.NET has updated generics; Java erases generics.

The difference is this: if you have an ArrayList<String> object, in .NET you can indicate (at runtime) that the object is of type ArrayList<String> , whereas in Java, at runtime, the object is of type ArrayList ; the String part is lost. If you put String objects in an ArrayList , the system cannot provide this, and you will only know about it after you try to retrieve this element from the list and the execution fails.

Answer 6

One thing I miss in C # with Java is forcing checked exceptions to work. In C #, it is very common that no one knows about the exceptions that a method may throw, and you are at the mercy of documentation or testing to detect them. Not so in Java with checked exceptions.

Answer 7

There are no delegates or events - you need to use interfaces. Fortunately, you can create classes and implementations of the interface internally, so this is not so important.

Answer 8

Java has autoboxing for primitives, not value types, therefore, although System.Int32[] is an array of values ​​in C #, Integer[] is an array of references to Integer objects and, as such, is not suitable for higher performance calculations.

Answer 9

The built-in date / calendar function in Java is terrible compared to System.DateTime. Here is a lot of information about this: What happened to the Java Date and Time API?

Some of them can be fixed for the C # developer:

• The Java Date class has been modified, which could result in date return and transfer dates being dangerous.
• Most java.util.Date constructors are deprecated. Just instantiating the date is pretty verbose.
• I never got a java.util.Date class to interact well with web services. In most cases, dates on both sides wildly transformed into other dates and times.

---

In addition, Java does not have all the same functions as the GAC and the strongly named assemblies. Jar Hell is a term that may be mistaken when linking / referencing external libraries.

Regarding packaging / deployment:

• it can be difficult to pack web applications in EAR / WAR format, which are actually installed and run on multiple application servers (Glassfish, Websphere, etc.).
• Deploying your Java application as a Windows service requires much more effort than in C #. Most of the recommendations I received for this included a proprietary third-party library. Application configuration
• is not as simple as including the app.config file in your project. There is a java.util.Properties class, but it is not so reliable, and finding the right place to delete your .properties file can be confusing.

Answer 10

There are no delegates in Java. Therefore, in addition to all the benefits that delegates bring to the table, events also work in different ways. Instead of just attaching a method, you need to implement an interface and attach it.

Answer 11

One thing that jumps out of b / c on my interview list is that in Java there is no “new” analogue of keywords to hide the method, and therefore there is no compiler warning “you should put new here”. The random method hiding when you wanted to override leads to errors.

(for example, edit) Example: B comes from A (using C # syntax, Java behaves the same as the last, I checked, but did not give a warning about the compiler). Is foo or B foo called? (A gets the call, probably surprising the developer who implemented B).

 class A { public void foo() {code} } class B:A { public void foo() {code} } void SomeMethod() { A a = new B(); // variable type is declared as A, but assigned to an object of B. a.foo(); } 

Answer 12

Java does not have LINQ, and the documentation is hell. Java user interfaces are a pain to develop, you lose all the good things Microsoft has given us (WPF, WCF, etc.), but you got hard-to-reach, barely documented "APIs".

Answer 13

The only problem that I have encountered so far when working with Java coming from C # is exceptions and errors.

For example, you cannot catch an error from memory using catch (Exception e).

See below for more details:

why-is-java-lang-outofmemoryerror-java-heap-space-not-caught

Answer 14

It was as long ago as I was in Java, but the things that I immediately noticed from the point of view of application development are the C # event model, drag and drop using C #, and using layout managers in Swing (if you do App dev) and handling exceptions with Java, making sure you catch the exception, and C # is not required.

Answer 15

The most annoying difference for me when I switch to java is a line declaration.

in C # string (most of the time) in Java string

It's pretty simple, but believe me, it makes you lose so much time when you have the habit of s not s !

Answer 16

In response to your very direct question in your title:

"C # developers learning Java, what are the biggest differences you can ignore?"

A: the fact that Java is much slower on Windows.