Contents - Cultural View

Comparison of Java and C Sharp 75
Numeric applications
To adequately support applications in the field of mathematic and financial computation, several language features
exist. [13] In this category, Java provides the strictfp keyword, which enables strict floating-point calculations for a
region of code. This will ensure that calculations return the exact same result on all platforms. C# provides no
equivalent, but does provide the built-in decimal type, for accurate decimal floating-point calculations. This forgoes
the problems that exist with binary floating-point representations (float, double). Such binary representations are not
suited to accurately represent decimal numbers and hence introduce rounding errors. For financial applications, an
accurate decimal type is essential.
The BigDecimal class also provides such characteristics for Java. BigDecimal and BigInteger are types provided
with Java that allow arbitrary-precision representation of numbers. As of 2010 the current stable release of the .NET
framework (4.0) includes classes for manipulating arbitrary-precision integers and complex numbers (with operators
overloaded for easy use so that BigInteger objects can be used just like any other primitive data type) but still .NET
Framework lacks classes to deal with arbitrary-precision floating point numbers (see Arbitrary-precision arithmetic).
In Java there is no way to provide the same level of integration for library-defined types such as BigDecimal or
complex numbers as there is for the primitive types. For this purpose, C# provides the following:
• Operator overloading and indexers providing convenient syntax (see below).
• Implicit and explicit conversions; allow conversions such as exist for the built-in int type that can implicitly
convert to long.
• Valuetypes and generics based on valuetypes; in Java every custom type must be allocated on the heap, which is
detrimental for performance of both custom types and collections.
In addition to this, C# can help mathematic applications with the checked and unchecked operators that allow to
enable or disable run-time checking for arithmetic overflow for a region of code. It also offers rectangular arrays,
that have advantages over regular nested arrays for certain applications. [13]
Methods
Methods in C# are non-virtual by default, and have to be declared virtual explicitly if desired. In Java, all non-static
non-private methods are virtual. Virtuality guarantees that the most recent override for the method will always be
called, but incurs a certain runtime cost on invocation as these invocations cannot be normally inlined, and require an
indirect call via the virtual method table. However, some JVM implementations, including the Sun reference
implementation, implement inlining of the most commonly called virtual methods.
Java methods are virtual by default (although they can be "sealed" by using the final modifier to disallow
overriding). There is no way to let derived classes define a new, unrelated method with the same name.
This means that by default in C#, and only when explicitly asked in Java, you can define new methods in a derived
class with the same name and signature than the one in its base class. Which implies that when you call that method
on such an object, depending on the current knowledge of the caller (if it knows its exact subclass or not), the result
will be different.
In Java (by default), the subclass's method will be called, but you will be able to call the base class' own method if
needed. In C# (by default), the base class' method will be called, and you won't be able to intercept the call.
In very specific cases, when a base class is designed by a different person, and a new version introduces a method
with the same name and signature as some method already present in the derived class, problems can happen.
In Java, this will mean that the method in the derived class will implicitly override the method in the base class, even
though that may not be the intent of the designers of either class.
To prevent this versioning problem, C# requires that if a method should be overridden, the override keyword must be
specified. Otherwise, the method will "hide" the inherited method. A compiler warning to this effect is issued, which
can be silenced by specifying the new keyword. This avoids the problem which can arise from a base class being