• Save
Beginning Java for .NET developers
Upcoming SlideShare
Loading in...5
×
 

Beginning Java for .NET developers

on

  • 4,267 views

A (not so) brief comparison of the Java and .NET platform from the point of view of the .NET developer

A (not so) brief comparison of the Java and .NET platform from the point of view of the .NET developer

Statistics

Views

Total Views
4,267
Views on SlideShare
323
Embed Views
3,944

Actions

Likes
1
Downloads
0
Comments
0

11 Embeds 3,944

http://blog.andrei.rinea.ro 2335
http://www.codeproject.com 1576
http://feeds.feedburner.com 12
http://cloud.feedly.com 6
http://translate.googleusercontent.com 5
http://www.ranksit.com 3
http://www.feedspot.com 3
http://newsblur.com 1
http://www.newsblur.com 1
https://www.google.co.il 1
http://dev.newsblur.com 1
More...

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Beginning Java for .NET developers Beginning Java for .NET developers Presentation Transcript

    • Beginning Java for .NET developers
    • Why learn Java? • Complement your developer skills • Be able to develop Android apps • Target Linux OS
    • Where do I get Java? • Oracle (official vendor, acquirer of Sun) • IBM (no Windows support – at least in Nov.2013) • OpenJDK (Ubuntu) • many others
    • IDEs • • • • Eclipse Netbeans (Oracle) IntelliJ IDEA (JetBrains, makers of ReSharper) many others
    • Common features • • • • • • • • Object-oriented Compiled, not interpreted Statically typed Type safe Runtime (JVM) – based (available on many platforms) Garbage collected Allows native interoperability Runs on mobile devices (smartphones, tablets, even feature-phones) • JLS / CLS – multiple languages on the same platform
    • Similar projects and technologies • • • • • • • Hibernate – NHibernate log4j – log4net Play – ASP.NET MVC JUnit – NUnit JavaFX – WPF Swing/AWT – Winforms JSP/JSF – ASP.NET (Webforms)
    • Subtle and not-so-subtle differences • Language differences (calls, conventions, execution, syntactic sugar, code organization, syntax) • Platform differences (architecture, classsystem, execution, operations, data types and others)
    • Language - Calling methods • • • • No out or ref parameter modifiers No optional parameters No named parameters params written as “…” public void doSomething(Object… args) { … } • No extension methods
    • Language - Coding conventions • Methods are camelCased and not PascalCased • The opening brace is to be put on the same line : public void doSomething() { } • Interfaces are not prefixed with a capital I : Throwable, Runnable etc. • Enum values are all-uppercase • Abbreviation words in compound names can be all-caps : URLParser (as opposed to .NET’s UrlParser)
    • Language - Code execution • Switch allows fall-through by design • Convenient multicatch statement : try { … } catch(IOException | NetworkException e) { … } • Override return in finally • No #Ifdef • Try-with-resources as using equivalent : try(IOStream s = new IOStream()) { … }
    • Language – Convenience features • No as feature. Test with instanceOf and then cast • No lambdas yet. Promised in Java 8. Use anonymous inner classes • Static method import. Like extensions methods but the other way around. import static com.something.Otherclass.someMethod; … someMethod(..); • No explicit interface implementation
    • Language – Organization • No nested packages in a single file. namespace Outer { namespace Inner { … } } • Only one public class in a .java file • The public class name must match case-wise the filename • No partial classes • No partial methods
    • Language – Syntax • protected means ‘protected internal’ • implements or extends instead of colon (‘:’) • No var facility • foreach syntax : for(Type variable : collection){…} • instanceOf instead of is • SomeClass.class instead of typeof(SomeClass) • Annotations are prefixed with @ and not ‘[‘, ‘]’ • .. can also be applied to assignment statements
    • Language – Syntax (cont’d) • No indexers public int this[int index] { get { … } } • No #regions • Binary numeric literals : int n217 = 0b11011001; • Underscore allowed (and ignored) in numeric literals : int cardNo = 1234_5678_9012_3456; • The base class is called superclass, the derived class is called subclass • Calling the superclass constructor is done within the constructor not outside, it is optional, but if done, must be the first statement of the constructor
    • Language – data types • Default access modifier (i.e. not specifying one) means package (kind of internal), for methods or fields. • String must be written with capital S. Seems irrelevant but it will be the most common typo. • Interfaces can have static final fields (“constants”) – before enums this was a way to simulate enums. • No operator overloading • No implicit or explicit conversions can be defined on types
    • Language – Enums • • • • • • • • • • Reference type – like classes Enums can have fields and constructor (though it must be private) You can override methods. Typically toString() Lazily created. Each enum value is instantiated at its first use. Abstract methods, overridable in specific values Allows inheritance. Although it has the semantic value of a superset, not subset. valueOf(String name) instead of Enum.Parse values() for enumerating all values name() – gets the enum value name; typically toString() does the same but the latter can get overriden ordinal() – gets the order index of the value
    • Platform – Architecture • @Override annotation is optional. Overload instead • • • • of override can occur. Cloning is awkard, non-intuitive. Cloneable marker interface and protected clone(). No static classes. Make it final, create a private constructor and throw an exception inside the constructor Return type covariance : Override a method and return a subclass of the original method’s return type class. Typical use : overriding clone(). You can alter a collection while iterating it without getting an exception, but only if done through the current iterator.
    • Platform – Classes • A method is virtual by default – not like in .NET where it’s sealed (final) by default. This is how Hibernate strived and NHibernate struggles. • Generics are implemented using type erasure. No List<primitive> and no arrays of generic types. • No (known) way to create a generic type, by reflection, at runtime. • Inner classes have outer class reference by default. Except static inner classes. • No method generators. i.e. yield • Type inference by ‘diamond’ style constructors. List<Integer> = new ArrayList<>();
    • Platform – Execution • Checked exceptions. Each method must declare what exceptions it can throw or catch them. • RuntimeExceptions are exempt • Errors are not catchable
    • Platform – Convenience features • No properties • No events • Three ways to simulate events : – Nested anonymous classes – Implementing interfaces and passing this – Lambdas (promised in Java 8)
    • Platform – Operations • Primitives have reference-types peers (wrappers) • Do not confuse them to their primitive counterparts. == operator will compare instances instead of values • Strings also should not be compared with == operator. Although there is string interning this will usually fail you • No checked mode. Numeric wrap-around always.
    • Platform – Data types • • • • No unsigned numeric data types No multi-dimensional arrays No structs or other user-defined value-types No dynamic infrastructure. Only in non-Java languages compiled to bytecode. • The primitives are not part of the type hierarchy. Only their wrappers are.
    • Platform – others • Upon deployment desktop apps don’t have an EXE or other prepared entry point, executable file • The Garbage Collector does not have a (separate) Large Object Heap, nor its associated issues (fragmentation)
    • Further reading • Enums : http://docs.oracle.com/javase/tutorial/java/javaOO/enum.html • JLS : http://docs.oracle.com/javase/specs/ • Java 8 Release date : http://openjdk.java.net/projects/jdk8/