1 / 24

Beginning Java for .NET developers

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.

dimaia
Download Presentation

Beginning Java for .NET developers

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Beginning Java for .NET developers

  2. Why learn Java? • Complement your developer skills • Be able to develop Android apps • Target Linux OS

  3. Where do I get Java? • Oracle (official vendor, acquirer of Sun) • IBM (no Windows support – at least in Nov.2013) • OpenJDK (Ubuntu) • many others

  4. IDEs • Eclipse • Netbeans (Oracle) • IntelliJ IDEA (JetBrains, makers of ReSharper) • many others

  5. 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

  6. Similar projects and technologies • Hibernate – NHibernate • log4j – log4net • Play – ASP.NET MVC • JUnit – NUnit • JavaFX – WPF • Swing/AWT – Winforms • JSP/JSF – ASP.NET (Webforms)

  7. Subtle and not-so-subtle differences • Language differences (calls, conventions, execution, syntactic sugar, code organization, syntax) • Platform differences (architecture, class-system, execution, operations, data types and others)

  8. 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

  9. 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)

  10. 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()) { … }

  11. Language – Convenience features • No asfeature. 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

  12. 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

  13. Language – Syntax • protectedmeans ‘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

  14. Language – Syntax (cont’d) • No indexerspublic int this[int index] { get { … } } • No #regions • Binary numeric literals :int n217 = 0b11011001; • Underscore allowed (and ignored) in numeric literals :intcardNo = 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

  15. 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

  16. 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

  17. 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.

  18. 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<>();

  19. Platform – Execution • Checked exceptions. Each method must declare what exceptions it can throw or catch them. • RuntimeExceptions are exempt • Errors are not catchable

  20. 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)

  21. 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.

  22. 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.

  23. 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)

  24. 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/

More Related