View source for Comparison of C Sharp and Java

{{Short description|none}}
{{Correct title|title=Comparison of C# and Java|reason=hash}}
{{Multiple issues|
{{how-to|date=January 2016}}
{{Technical|date=January 2016}}
{{Original research|date=December 2015}}
{{Weasel|date=March 2011}}
}}
{{Use dmy dates|date=August 2019}}

{{ProgLangCompare}}

This article compares two [[programming language]]s: [[C Sharp (programming language)|C#]] with [[Java (programming language)|Java]]. While the focus of this article is mainly the languages and their features, such a comparison will necessarily also consider some features of [[Computing platform|platforms]] and [[Library (computing)|libraries]].

C# and Java are similar languages that are [[Type system|typed]] statically, [[Strong typing|strongly]], and [[manifest typing|manifestly]]. Both are [[Object-oriented programming|object-oriented]], and designed with semi-[[Interpreter (computing)|interpretation]] or runtime [[just-in-time compilation]], and both are [[Curly bracket programming language|curly brace languages]], like [[C (programming language)|C]] and [[C++]].

== Types ==
{| class="wikitable"
|-
! [[#Data types|Data types]]!! Java !! C#
|-
| [[#Advanced numeric types|Arbitrary-size decimals]] || {{yes|Reference type; no operators}}<ref>{{cite web |url=http://docs.oracle.com/javase/1.5.0/docs/api/java/math/BigDecimal.html |title=BigDecimal (Java 2 Platform SE 5.0) |publisher=Docs.oracle.com |access-date=24 February 2015}}</ref> || {{no|Third-party library|style=background: #8CF;}}<ref>{{cite web |url=https://wezeku.github.io/Mpir.NET/ |title=Mpir.NET |access-date=17 July 2015}}</ref>
|-
| [[#Advanced numeric types|Arbitrary-size integers]] || {{yes|Reference type; no operators}} || {{yes}}<ref name="microsoft1">{{cite web |url=https://learn.microsoft.com/en-us/dotnet/api/system.numerics.biginteger?view=net-7.0 |title=BigInteger Struct (System.Numerics) |publisher=learn.microsoft.com |access-date=14 April 2023}}</ref>
|-
| [[#Arrays and collections|Arrays]] || {{yes}}<ref>{{cite web |url=http://docs.oracle.com/javase/1.5.0/docs/api/java/util/Collection.html |title=Collection (Java 2 Platform SE 5.0) |publisher=Docs.oracle.com |access-date=20 May 2015}}</ref> || {{yes}}
|-
| [[Boolean type]] || {{yes}} || {{yes}}
|-
| [[Primitive data type#Characters and strings|Character]] || {{yes}}<ref>{{cite web |url=http://docs.oracle.com/javase/1.5.0/docs/api/java/lang/String.html |title=String (Java 2 Platform SE 5.0) |publisher=Docs.oracle.com |access-date=20 May 2015}}</ref> || {{yes}}
|-
| [[#Advanced numeric types|Complex numbers]] || {{no|Third-party library|style=background: #8CF;}}<ref>{{cite web |url=https://commons.apache.org/proper/commons-math/userguide/complex.html |title=Math &ndash; The Commons Math User Guide – Complex Numbers |access-date=17 July 2015}}</ref> || {{yes}}
|-
| Date/time || {{yes}}; reference type<ref>{{cite web |url=http://docs.oracle.com/javase/1.5.0/docs/api/java/util/Date.html |title=Date (Java 2 Platform SE 5.0) |publisher=Docs.oracle.com |access-date=20 May 2015}}</ref> || {{yes}}; value type
|-
| [[#Enumerations|Enumerated types]] || {{yes}}; reference type || {{yes}}; scalar
|-
| High-precision decimal number || {{no|style=background: #8CF;}}; but see 'Arbitrary-size decimals' above || {{yes|[[128-bit computing|128-bit]] (28 digits) decimal type<ref>{{cite web |title=decimal (C# Reference) |url=https://msdn.microsoft.com/en-us/library/364x0z75.aspx |publisher=Microsoft |access-date=30 November 2015}}</ref>}}
|-
| IEEE 754 [[binary32]] floating point number || {{yes}} || {{yes}}
|-
| IEEE 754 [[binary64]] floating point number || {{yes}} || {{yes}}
|-
| [[#Lifted (nullable) types|Lifted (nullable) types]] || {{no|style=background: #8CF;}}; but wrapper types || {{yes}}
|-
| [[#Pointers|Pointers]] || {{no|style=background: #8CF;}};<ref name="oracle.com">{{cite web |url=http://www.oracle.com/technetwork/java/simple-142616.html#4107 |title=The Java Language Environment |publisher=Oracle.com |access-date=18 August 2013}}</ref> only method references<ref name="oracle1">{{cite web |url=http://docs.oracle.com/javase/tutorial/java/javaOO/methodreferences.html |title=Method References (The Java Tutorials > Learning the Java Language > Classes and Objects) |publisher=Docs.oracle.com |date=28 February 2012 |access-date=24 February 2015}}</ref> || {{yes}}<ref>Only available in ''unsafe mode'' or through ''IntPtr'' managed type</ref>
|-
| [[#Reference types|Reference types]] || {{yes}} || {{yes}}
|-
| [[Signedness|Signed integers]] || {{yes}}; [[8-bit computing|8]], [[16-bit computing|16]], [[32-bit computing|32]], [[64-bit computing|64 bits]] || {{yes}}; 8, 16, 32, 64 bits
|-
| [[Primitive data type#Characters and strings|Strings]] || {{yes|Immutable reference type, [[Unicode]]}} || {{yes|Immutable reference type, [[Unicode]]}}
|-
| Type annotations || {{yes}} || {{yes}}
|-
| [[Type system#Unified type system|Single-root (unified) type system]] || {{no|style=background: #8CF;}}; but wrapper types || {{yes}}<ref>The type system is unified by default, unless the compiler is switched into ''unsafe mode'' where raw pointers are available as a datatype. Pointers are not derived from object nor does it have implicit conversions to/from the object data type</ref>
|-
| [[Tuples]] || {{no|style=background: #8CF;}}; limited third-party available<ref>{{cite web |url=http://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/tuple/package-summary.html |title=org.apache.commons.lang3.tuple (Apache Commons Lang 3.4-SNAPSHOT API) |publisher=Commons.apache.org |date=15 January 2014 |access-date=24 February 2015}}</ref> || {{yes}}<ref name="C# Tuple class">{{cite web |title=Tuple Class (System) |url=https://learn.microsoft.com/en-us/dotnet/api/system.tuple |website=learn.microsoft.com |publisher=Microsoft Corporation |access-date=20 April 2023}}</ref><ref name="C# value tuples">{{Cite web |url=https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/value-tuples |title=Tuple types (C# reference) |website=learn.microsoft.com |publisher=Microsoft Corporation |access-date=20 April 2023}}</ref>
|-
| [[Unsigned integers]] || {{no|style=background: #8CF;}}; but some method support<ref>{{cite web |url=https://blogs.oracle.com/darcy/entry/unsigned_api |title=Unsigned Integer Arithmetic API now in JDK 8 (Joseph D. Darcy's Oracle Weblog) |publisher=Blogs.oracle.com |access-date=24 February 2015 |archive-date=25 February 2017 |archive-url=https://web.archive.org/web/20170225213350/https://blogs.oracle.com/darcy/entry/unsigned_api |url-status=dead}}</ref> || {{yes}}; 8, 16, 32, 64 bits
|-
| [[#User-defined value type (struct)|Value types]] || {{no|style=background: #8CF;}}; only primitive types || {{yes}}
|}

=== Unified type system ===
Both languages are statically typed with class-based object orientation. In Java the [[primitive types]] are special in that they are not [[object-oriented]] and they could not have been defined using the language itself. They also do not share a common ancestor with reference types. The Java [[reference type]]s all derive from a common root type. C# has a unified [[type system]] in which all types (besides unsafe pointers<ref name="unsafe pointers">{{cite web |url=https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/unsafe-code#pointer-types |title=Unsafe code, pointer types, and function pointers |publisher=learn.microsoft.com |date=29 May 2022 |access-date=14 April 2023}}</ref>) ultimately derive from a common root type. Consequently, all types implement the methods of this root type, and extension methods defined for the {{mono|object}} type apply to all types, even primitive {{mono|int}} literals and [[Delegate (CLI)|delegates]]. This allows C#, unlike Java, to support objects with encapsulation that are not reference types.

In Java, compound types are synonymous with reference types; methods cannot be defined for a type unless it is also a ''class'' reference type. In C# the concepts of encapsulation and methods have been decoupled from the reference requirement so that a type can support methods and encapsulation without being a reference type. Only reference types support [[virtual method]]s and specialization, however.

Both languages support many [[built-in type]]s that are copied and passed by value rather than by reference. Java calls these types [[primitive type]]s, while they are called ''simple types'' in C#. The primitive/simple types typically have native support from the underlying processor architecture.

The C# simple types implement several [[Interface (object-oriented programming)|interfaces]] and consequently offer many methods directly on instances of the types, even on the literals. The C# type names are also merely ''aliases'' for [[Common Language Runtime]] (CLR) types. The C# {{code|System.Int64}} type is exactly the same type as the {{mono|long}} type; the only difference is that the former is the canonical [[.NET]] name, while the latter is a C# alias for it.

Java does not offer methods directly on primitive types. Instead, methods that operate on primitive values are offered through companion [[primitive wrapper class]]es. A fixed set of such wrapper classes exist, each of which wraps one of the fixed set of primitive types. As an example, the Java {{mono|Long}} type is a [[reference type]] that wraps the primitive {{mono|long}} type. They are ''not'' the same type, however.

=== Data types ===
==== Numeric types ====
===== Signed integers =====
Both Java and C# support [[signedness|signed]] integers with bit widths of 8, 16, 32 and 64 bits. They use the same name/aliases for the types, except for the 8-bit integer that is called a {{mono|byte}} in Java and a {{mono|sbyte}} (signed byte) in C#.

===== Unsigned integers =====
C# supports [[signedness|unsigned]] in addition to the [[signedness|signed]] integer types. The unsigned types are {{mono|byte}}, {{mono|ushort}}, {{mono|uint}} and {{mono|ulong}} for 8, 16, 32 and 64 bit widths, respectively. Unsigned arithmetic operating on the types are supported as well. For example, adding two unsigned integers ({{mono|uint}}s) still yields a {{mono|uint}} as a result; not a long or signed integer.

Java does not feature unsigned integer types. In particular, Java lacks a primitive type for an unsigned [[byte]]. Instead, Java's {{mono|byte}} type is [[sign extension|sign extended]], which is a common source of bugs and confusion.<ref>{{cite book |title=Java puzzlers : traps, pitfalls, and corner cases|year=2005 |publisher=Addison-Wesley|location=Upper Saddle River, NJ [u.a.]|isbn=978-0-321-33678-1|author=Joshua Bloch; Neal Gafter|edition=5. print.|page=36|quote=The lesson for language designers is that sign extension of byte values is a common source of bugs and confusion. The masking that is required to suppress sign extension clutters programs, making them less readable. Therefore, the byte type should be unsigned.}}<!-- |access-date=6 October 2012--></ref>

Unsigned integers were left out of Java deliberately because [[James Gosling]] believed that programmers would not understand how unsigned arithmetic works.<blockquote>In programming language design, one of the standard problems is that the language grows so complex that nobody can understand it. One of the little experiments I tried was asking people about the rules for unsigned arithmetic in C. It turns out nobody understands how unsigned arithmetic in C works. There are a few obvious things that people understand, but many people don't understand it.<ref name="oracle.com"/><ref>{{cite web |url=http://www.artima.com/intv/gosling3P.html |title=James Gosling on Java, May 2001 |publisher=Artima.com |date=10 May 2001 |access-date=24 February 2015}}</ref></blockquote>

Java versions 8 and 9 added some limited built-in unsigned integer operations, but they are only exposed as static methods on the primitive wrapper classes; they operate on signed primitive integer types, treating them as if they were unsigned.<ref>{{cite web |url=https://docs.oracle.com/javase/8/docs/api/java/lang/Integer.html |title=Integer (Java Platform SE 8) |publisher=Docs.oracle.com |access-date=20 Apr 2023}}</ref>

===== High-precision decimal numbers =====
C# has a type and literal notation for high-precision (28 decimal digits) decimal arithmetic that is appropriate for financial and monetary calculations.<ref>{{cite web |title=decimal |url=http://msdn.microsoft.com/en-us/library/364x0z75(v=vs.110).aspx | work=C# Reference |date=19 August 2012 |publisher=Microsoft}}</ref><ref name="thedecimaltype"/><ref>{{cite book | last=Mok | first=Heng Ngee |title=From Java to C? : a developer's guide |year=2003 |publisher=Addison-Wesley|location=Harlow, England | isbn=978-0-321-13622-0 | chapter=9.5. The decimal type}}</ref> Contrary to the {{mono|float}} and {{mono|double}} data types, decimal fractional numbers such as 0.1 can be represented exactly in the decimal representation. In the float and double representations, such numbers often have non-terminating binary expansions, making those representations more prone to round-off errors.<ref name=thedecimaltype>{{cite book | last=Sestoft | first=Jon Jagger, Nigel Perry, Peter |title=C? annotated standard |year=2007 |publisher=Elsevier/Morgan Kaufmann Publishers | location=Amsterdam | isbn=978-0-12-372511-0 | chapter=11.1.7 The decimal type}}</ref>

While Java lacks such a built-in type, the Java library does feature an ''arbitrary precision'' decimal type. This is not considered a language type and it does not support the usual arithmetic operators; rather it is a reference type that must be manipulated using the type methods. See more about arbitrary-size/precision numbers [[#Advanced numeric types|below]].

==== Advanced numeric types ====
Both languages offer library-defined [[arbitrary-precision arithmetic]] types for arbitrary-size integers and decimal point calculations.

Only Java has a data type for arbitrary precision decimal point calculations. Only C# has a type for working with [[complex number]]s.

In both languages, the number of operations that can be performed on the advanced numeric types is limited compared to the built-in [[IEEE 754]] floating point types. For instance, none of the arbitrary-size types support [[square root]] or [[logarithm]]s.

C# allows library-defined types to be integrated with existing types and operators by using custom implicit/explicit conversions and operator overloading. See example in section ''[[#Integration of library-defined types|Integration of library-defined types]]''

==== Characters ====
Both languages feature a native {{mono|char}} (character) datatype as a simple type. Although the {{mono|char}} type can be used with bit-wise operators, this is performed by promoting the {{mono|char}} value to an integer value before the operation. Thus, the result of a bitwise operation is a numeric type, not a character, in both languages.

==== Built-in compound data types ====
Both languages treat [[String (computer science)|strings]] as ([[immutable object|immutable]]) objects of reference type. In both languages, the type contains several methods to manipulate strings, parse, format, etc. In both languages [[regular expression]]s are considered an external feature and are implemented in separate classes.

Both languages' libraries define classes for working with dates, times, [[time zone]]s, and [[calendar]]s in different cultures. Java provides {{code|java.util.Date}}, a mutable reference type with millisecond precision, and (since Java 8) the {{code|java.time}} package (including classes such as {{mono|LocalDate}}, {{mono|LocalTime}}, and {{mono|LocalDateTime}} for date-only, time-only, and date-and-time values), a set of immutable reference types with [[nanosecond]] precision.<ref>{{cite web |url=https://docs.oracle.com/javase/8/docs/api/java/time/package-summary.html |title=Package java.time (Java Platform SE 8) |publisher=docs.oracle.com |access-date=20 April 2023}}</ref> In contrast, the C# {{code|System.DateTime}} is an immutable struct value type for date-and-time information with 100-nanosecond precision; the .NET 6 API also added {{code|System.DateOnly}} and {{code|System.TimeOnly}}, similar structures for date-only or time-only operations.<ref>{{cite web |url=https://learn.microsoft.com/en-us/dotnet/standard/datetime/how-to-use-dateonly-timeonly |title=How to use the DateOnly and TimeOnly structures |date=12 January 2023 |publisher=learn.microsoft.com |access-date=20 April 2023}}</ref> C# additionally defines a {{code|System.TimeSpan}} type for working with time periods; Java 8 provides the {{code|java.time.Duration}} class for the same purpose. Both languages support date and time arithmetic according to different cultures and time zones.

=== User-defined value type (struct) ===
C# allows the programmer to create user-defined [[value type]]s, using the {{mono|struct}} keyword. Unlike classes and like the standard primitives, such value types are passed and assigned by value rather than by reference. They can also be part of an object (either as a field or [[Boxed type|boxed]]), or stored in an array without the memory indirection that normally exists for class types.

Because value types have no notion of a {{mono|null}} value and can be used in arrays without initialization, they always come with an implicit [[default constructor]] that essentially fills the struct memory space with zeroes. The programmer can only define additional constructors with one or more arguments. Value types do not have [[virtual method table]]s, and because of that (and the fixed [[memory footprint]]), they are implicitly sealed. However, value types ''can'' (and frequently do) implement [[Interface (object-oriented programming)|interfaces]]. For example, the built-in integer types implement several [[Interface (object-oriented programming)|interfaces]].

Apart from the built-in primitive types, Java does not include the concept of value types.

=== {{anchor|Enumerated types}}Enumerations ===
Both languages define enumerations, but they are implemented in fundamentally different ways. As such, enumerations are one area where tools designed to automatically translate code between the two languages (such as Java to C# converters) fail.

C# has implemented enumerations in a manner similar to C, that is as wrappers around the bit-flags implemented in primitive integral types (int, byte, short, etc.). This has performance benefits and improves interaction with C/C++ compiled code, but provides fewer features and can lead to bugs if low-level value types are directly cast to an enumeration type, as is allowed in the C# language. Therefore, it is seen as [[syntactic sugar]].<ref>{{cite web |url=https://www.dotnetperls.com/enum |title=Enum. |publisher=.NET Perls |location=Internet |language=en |access-date=14 November 2016 |quote='''Performance.''' Enums are fast. They are almost never a performance concern. They are just syntactic sugar on a type like int, which is also fast. […] '''Type.''' An enum has an underlying type. Each time we use the enum, we are using the underlying type. The enum has syntactic sugar on top.}}</ref> In contrast, Java implements enumerations as full featured collection of instances, requiring more memory and not aiding interaction with C/C++ code, but providing additional features in [[Reflective programming|reflection]] and intrinsic behavior. The implementation in each language is described in the table below.

{| class=wikitable
!
! Java
! C#
|-
| Definition
| In Java, the enumeration type is a [[Class (computer programming)|class]], and its values are [[Object (computer science)|objects]] (instances) of that class. The only valid values are the ones listed in the enumeration. The enumeration type may declare [[Member variable|fields]], allowing each individual enumerated value to reference additional data associated uniquely with that specific value. The enumeration type may also declare or override [[Method (computer programming)|methods]], or implement [[Protocol (object-oriented programming)|interfaces]].<ref name="enum">{{cite web |url=http://www.25hoursaday.com/CsharpVsJava.html#switch |title=A Comparison of Microsoft's C# Programming Language to Sun Microsystems' Java Programming Language |author=Dare Obasanjo |year=2007 |publisher=Dare Obasanjo | quote = In Java, enumerated types are a full-fledged class that means they are typesafe and can be extended by adding methods, fields or even implementing interfaces. Whereas in C#, an enumerated type is simply syntactic sugar around an integral type (typically an int) meaning they cannot be extended and are not typesafe. |access-date=6 September 2012 |url-status=live |df=dmy-all |archive-url=https://web.archive.org/web/20011217071122/http://www.25hoursaday.com:80/CsharpVsJava.html |archive-date=17 December 2001}}</ref>
| [[Enumeration]]s in C# are implicitly derived from the {{mono|Enum}} type that again is a value type derivative. The value set of a C# enumeration is defined by the ''underlying type'' that can be a signed or unsigned integer type of 8, 16, 32 or 64 bits. The enumeration definition defines names for the selected integer values.<ref name="enum"/><ref>{{cite web |url=http://www.cstruter.com/ |title=Java 5: Taming the Tiger: Syntactic Sugar | last1 = Prof. Dr. Gruntz | first1 = Dominik |date=8 April 2005 | language = de |publisher=Fachhochschule Aargau, Nordwestschweiz |archive-url=https://web.archive.org/web/20120708065042/http://cstruter.com/ |archive-date=8 July 2012 |quote=Enumerationen sind die heimlichen Sieger von Java 1.5. Nach vielen Beteuerungen durch Sun, Enums seien in Java überflüssig und können einfach nachgebildet werden, wurden sie nun doch eingeführt. Die einfachste Möglichkeit einer Enumeration der Jahreszeiten sieht wie folgt aus … Das Schlüsselwort enum steht für eine spezielle Art von Klasse, die eine Enumeration definiert. … ''Im Gegensatz zu anderen Programmiersprachen wie C/C++ und C# kann man ihnen per Gleichheitszeichen keine ganzen Zahlen zuordnen.'' |access-date=10 September 2012 |url-status=dead |df=dmy-all}}</ref> By default the first name is assigned the value 0 (zero) and the following names are assigned in increments of 1. Any value of the underlying primitive type is a valid value of the enumeration type, though an explicit cast may be needed to assign it.
|-
| Combining
| Java enumeration set and map collections provide functionality to combine multiple enumeration values to a combined value. These special collections allow compiler optimization to minimize the overhead incurred by using collections as the combination mechanism.
| C# supports bit-mapped enumerations where an actual value may be a combination of enumerated values bitwise or'ed together. The formatting and parsing methods implicitly defined by the type will attempt to use these values.
|}

In both C# and Java, programmers can use enumerations in a [[switch statement]] without conversion to a string or primitive integer type. However, C# disallows implicit fall-through unless the case statement does not contain any code, as it is a common cause of hard-to-find bugs.<ref>{{cite web |url=http://www.25hoursaday.com/ |title=A Comparison of Microsoft's C# Programming Language to Sun Microsystems' Java Programming Language: C. An Ever So Slight Feeling of Dèjà Vu: 4. Switch Statement |author=Dare Obasanjo |year=2007 |publisher=Dare Obasanjo |archive-url=https://web.archive.org/web/20120919093308/http://25hoursaday.com/ |archive-date=19 September 2012 |access-date=10 September 2012 |url-status=dead |df=dmy-all}}</ref> Fall-through must be explicitly declared using a [[goto]] statement.<ref>{{cite web |url=http://msdn.microsoft.com/en-us/library/13940fs2%28v=vs.110%29.aspx |title=goto (C#) |publisher=Msdn.microsoft.com |access-date=18 August 2013}}</ref>

=== Delegates, method references ===
C# implements object-oriented method pointers in the form of [[Delegate (CLI)|delegates]]. A delegate is a special type that can capture a reference to a method. This reference can then be stored in a delegate-type variable or passed to a method through a delegate parameter for later invocation. C# delegates support [[Covariance and contravariance (computer science)|covariance and contravariance]], and can hold a reference to any signature-compatible static method, instance method, anonymous method or [[Anonymous function|lambda expression]].

Delegates should not be confused with closures and inline functions. The concepts are related because a reference to a closure/inline function must be captured in a delegate reference to be useful at all. But a delegate does not always reference an inline function; it can also reference existing static or instance methods. Delegates form the basis of C# [[#Event|events]], but should not be confused with those either.

Delegates were deliberately left out of Java because they were considered unnecessary and detrimental to the language, and because of potential performance issues.<ref name="JavaDelegates">{{cite web|url=http://java.sun.com/docs/white/delegates.html |title=Oracle Technology Network for Java Developers &#124; Oracle Technology Network &#124; Oracle |publisher=Java.sun.com |access-date=24 February 2015 |url-status=dead |archive-url=https://web.archive.org/web/20120627043929/http://java.sun.com/docs/white/delegates.html |archive-date=27 June 2012 }}</ref> Instead, alternative mechanisms are used. The [[wrapper pattern]], which resembles the delegates of C# in that it allows the client to access one or more client-defined methods through a known [[Interface (object-oriented programming)|interface]], is one such mechanism.{{citation needed |date=March 2012}} Another is the use of [[Adapter pattern|adapter]] objects using inner classes, which the designers of Java argued are a better solution than bound method references.<ref name="JavaDelegates"/>

See also example [[#C# delegates and equivalent Java constructs|C# delegates and equivalent Java constructs]].

=== {{anchor|Nullable types}}Lifted (nullable) types ===
C# allows value/primitive/simple types to be "lifted" to allow the special {{mono|null}} value in addition to the type's native values. A type is lifted by adding a {{code|?}} suffix to the type name; this is equivalent to using the {{code|Nullable<T>}} [[Generic programming|generic]] type, where {{mono|T}} is the type to be lifted. Conversions are implicitly defined to convert between values of the base and the lifted type. The lifted type can be compared against {{mono|null}} or it can be tested for {{mono|HasValue}}. Also, lifted operators are implicitly and automatically defined based on their non-lifted base, where – with the exception of some Boolean operators – a null argument will propagate to the result.

Java does not support type lifting as a concept, but all of the built-in primitive types have corresponding wrapper types, which do support the {{mono|null}} value by virtue of being reference types (classes).

According to the Java spec, any attempt to dereference the {{mono|null}} reference must result in an exception being thrown at run-time, specifically a {{mono|NullPointerException}}. (It would not make sense to dereference it otherwise, because, by definition, it points to no object in memory.) This also applies when attempting to [[Auto-unboxing|unbox]] a variable of a wrapper type, which evaluates to {{mono|null}}: the program will throw an exception, because there is no object to be unboxed – and thus no boxed value to take part in the subsequent computation.

The following example illustrates the different behavior. In C#, the lifted*operator propagates the {{mono|null}} value of the operand; in Java, unboxing the null reference throws an exception.

Not all C# lifted operators have been defined to propagate {{mono|null}} unconditionally, if one of the operands is {{mono|null}}. Specifically, the [[Boolean operator (computer programming)|Boolean operator]]s have been lifted to support [[ternary logic]] thus keeping impedance with [[SQL]].

The Java Boolean operators do not support ternary logic, nor is it implemented in the base class library.

=== Late-bound (dynamic) type ===
C# features a [[Name binding|late bound]] dynamic type that supports no-reflection dynamic invocation, interoperability with dynamic languages, and ad-hoc binding to (for example) document object models. The {{mono|dynamic}} type resolves member access dynamically at runtime as opposed to statically/virtual at compile time. The member lookup mechanism is extensible with traditional [[Reflective programming|reflection]] as a fall-back mechanism.

There are several use cases for the {{mono|dynamic}} type in C#:
* Less verbose use of reflection: By casting an instance to the {{mono|dynamic}} type, members such as properties, methods, events etc. can be directly invoked on the instance without using the reflection API directly.
* Interoperability with dynamic languages: The dynamic type comes with a [[hub-and-spoke]] support for implementing dynamically typed objects and common runtime infrastructure for efficient member lookup.
* Creating dynamic abstractions on the fly: For instance, a dynamic object could provide simpler access to document object models such as [[XML]] or [[XHTML]] documents.

Java does not support a late-bound type. The use cases for C# dynamic type have different corresponding constructs in Java:
* For dynamic late-bound ''by-name'' invocation of preexisting types, reflection should be used.
* For interoperability with dynamic languages, some form of interoperability API specific to that language must be used. The [[Java virtual machine]] platform does have multiple dynamic languages implemented on it, but there is no common standard for how to pass objects between languages. Usually this involves some form of reflection or reflection-like API. As an example of how to use JavaFX objects from Java.<ref>[http://blogs.sun.com/javafx/entry/how_to_use_javafx_in How to Use JavaFX in Your Swing Application] {{webarchive|url=https://web.archive.org/web/20090304204652/http://blogs.sun.com/javafx/entry/how_to_use_javafx_in|date=4 March 2009}}</ref>
* For creating and interacting with objects entirely at runtime, e.g., interaction with a document object model abstraction, a specific abstraction API must be used.

See also example [[#Interoperability with dynamic languages]].

=== Pointers ===
Java precludes pointers and pointer-arithmetic within the Java runtime environment. The Java language designers reasoned that pointers are one of the main features that enable programmers to put bugs in their code and chose not to support them.<ref name="oracle.com"/> Java does not allow for directly passing and receiving objects/structures to/from the underlying operating system and thus does not need to model objects/structures to such a specific memory layout, layouts that frequently would involve pointers. Java's communication with the underlying operating system is instead based upon [[Java Native Interface]] (JNI) where communication with/adaptation to an underlying operating system is handled through an external ''glue'' layer.

While C# does allow use of [[Pointer (computer programming)|pointers]] and corresponding pointer arithmetic, the C# language designers had the same concerns that pointers could potentially be used to bypass the strict rules for object access. Thus, C# by default also precludes pointers.<ref>{{cite web |title=Unsafe Code and Pointers (C# Programming Guide) |url=http://msdn.microsoft.com/en-us/library/t2yzs44b(v=vs.80).aspx |publisher=Microsoft |access-date=11 March 2013}}</ref> However, because pointers are needed when calling many native functions, pointers are allowed in an explicit ''unsafe'' mode. Code blocks or methods that use the pointers must be marked with the {{mono|unsafe}} keyword to be able to use pointers, and the compiler requires the {{code|/unsafe}} switch to allow compiling such code. Assemblies that are compiled using the {{code|/unsafe}} switch are marked as such and may only execute if explicitly trusted. This allows using pointers and pointer arithmetic to directly pass and receive objects to/from the operating system or other native APIs using the native memory layout for those objects while also isolating such potentially unsafe code in specifically trusted assemblies.

=== Reference types ===
In both languages [[Reference (computer science)|references]] are a central concept. All instances of classes are ''by reference''.

While not directly evident in the language [[Syntax (programming languages)|syntax]] ''per se'', both languages support the concept of [[weak reference|''weak'' references]]. An instance that is only referenced by weak references is eligible for garbage collection just as if there were no references at all. In both languages this feature is exposed through the associated libraries, even though it is really a core runtime feature.

Along with weak references, Java has ''[[soft reference]]s''. They are much like weak references, but the [[Java virtual machine]] (JVM) will not deallocate softly-referenced objects until the memory is needed.

{| class="wikitable" style="width:80%;"
|-
! style="width:40%;"| Reference types !! style="width:30%;"|Java !! style="width:30%;"|C#
|-
| [[Garbage collection (computer science)|Garbage collection]] || {{yes}} || {{yes}}
|-
| [[Weak reference]]s || {{yes}} || {{yes}}
|-
| Reference queue (interaction with garbage collection) || {{yes}} || {{yes}}
|-
| [[Soft reference]]s || {{yes}} || {{no}}
|-
| [[Phantom reference]]s || {{yes}} || {{no}}
|-
| [[Proxy pattern|Proxy support]] || {{yes}}; proxy generation || {{yes}}; object contexts
|}

=== Arrays and collections ===
[[Array data structure|Arrays]] and [[Collection (abstract data type)|collections]] are concepts featured by both languages.
{| class="wikitable" style="width:80%;"
|-
! style="width:40%;"| [[Array data type|Arrays]] and [[Collection (abstract data type)|Collections]] !! style="width:30%;"|Java !! style="width:30%;"|C#
|-
| [[Abstract data type]]s || {{yes}} || {{yes}}
|-
| One-dimensional, zero-based index arrays || {{yes}} || {{yes}}
|-
| Multidimensional arrays, rectangular (single array)|| {{no}} || {{yes}}
|-
| Multidimensional arrays, jagged (arrays of arrays)|| {{yes}} || {{yes}}
|-
| Non-zero based arrays || {{no}} || {{some}}
|-
| Unified arrays and collections || {{no}} || {{yes}}
|-
| [[Associative array|Maps/dictionaries]] || {{yes}} || {{yes}}
|-
|Sorted dictionaries || {{yes}} || {{yes}}<ref>{{cite web |url=https://learn.microsoft.com/en-us/dotnet/api/system.collections.generic.sorteddictionary-2 |title=SortedDictionary<TKey,TValue> Class (System.Collections.Generic) |publisher=learn.microsoft.com |access-date=20 April 2023}}</ref>
|-
|Sets || {{yes}} || {{yes}}
|-
|Sorted sets || {{yes}} || {{yes}}<ref>{{cite web |url=https://learn.microsoft.com/en-us/dotnet/api/system.collections.generic.sortedset-1 |title=SortedSet<T> Class (System.Collections.Generic) |publisher=learn.microsoft.com |access-date=20 April 2023}}</ref>
|-
|Lists/vectors || {{yes}} || {{yes}}
|-
| [[Queue (data structure)|Queues/stacks]] || {{yes}} || {{yes}}
|-
| [[Priority queue]] || {{yes}} || {{yes}}<ref>{{cite web |url=https://learn.microsoft.com/en-us/dotnet/api/system.collections.generic.priorityqueue-2?view=net-8.0 |title=PriorityQueue<TElement,TPriority> Class (System.Collections.Generic) |publisher= learn.microsoft.com |access-date=20 April 2023}}</ref>
|-
|Bags/multisets || {{no|Third-party library|style=background: #8CF;}} || {{yes}}
|-
|Concurrency optimized collections || {{yes}} || {{yes}}<ref>{{cite web |title=System.Collections.Concurrent Namespace |url=https://learn.microsoft.com/en-us/dotnet/api/system.collections.concurrent |publisher=learn.microsoft.com |access-date=20 April 2023}}</ref>
|}

The syntax used to declare and access arrays is identical, except that C# has added syntax for declaring and manipulating multidimensional arrays.
{| class="wikitable" style="width:90%;"
|-
! style="width:50%;"| Java !! style="width:50%;"| C#
|-
| Arrays are implicitly direct specializations of {{mono|Object}}. They are not unified with collection types.
| Arrays in C# are implicit specializations of the {{code|System.Array}} class that implements several collection [[Interface (object-oriented programming)|interfaces]].
|-
| Arrays and collections are completely separate with no unification. Arrays cannot be passed where sequences or collections are expected (though they can be wrapped using {{code|Arrays.asList}}).
| Arrays can be passed where sequences ({{mono|IEnumerable}}s) or collections/list [[Interface (object-oriented programming)|interfaces]] are expected. However, the collection operations that alter the number of elements (insert/add/remove) will throw exceptions as these operations are unsupported by arrays.
|-
| The {{mono|for}} statement accepts either arrays or {{mono|Iterable}}s. All collections implement {{mono|Iterable}}. This means that the same short syntax can be used in for-loops.
| The {{mono|foreach}} statement iterates through a sequence using a specific implementation of the {{mono|GetEnumerator}} method, usually implemented through the {{mono|IEnumerable}} or {{code|IEnumerable<T>}} [[Interface (object-oriented programming)|interface]].<ref>{{cite web |url=https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/foreach-in |title=foreach, in (C# reference) |year=2018 |publisher=Microsoft |archive-url=https://web.archive.org/web/20190112220056/https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/foreach-in |archive-date=12 January 2019 |quote=The foreach statement executes a statement or a block of statements for each element in an instance of the type that implements the {{mono|System.Collections.IEnumerable}} or {{mono|System.Collections.Generic.IEnumerable<T>}} interface. |access-date=26 January 2019 |url-status=live}}</ref> Because arrays always implicitly implement these [[Interface (object-oriented programming)|interfaces]], the loop will iterate through arrays also.
|-
|colspan=2|In both languages arrays of reference types are covariant. This means that a {{code|String[]}} array is assignable to variables of {{code|Object[]}}, as {{mono|String}} is a specialization of (assignable to) {{mono|Object}}. In both languages, the arrays will perform a type check when inserting new values, because type safety would otherwise be compromised. This is in contrast to how generic collections have been implemented in both languages.
|-
| No [[Two-dimensional array|multidimensional arrays]] (rectangular arrays), but arrays of references to arrays ([[jagged array]]s).
| [[Two-dimensional array|Multidimensional arrays]] (rectangular arrays), and arrays of references to arrays ([[jagged array]]s).
|-
| Arrays cannot be resized (though use of the {{code|System.arraycopy()}} method can allow for multi-step array resizing)
| Arrays can be resized while preserving existing values using the {{code|Array.Resize()}} static array method (but this may return a new array).
|-
| Implemented as a [[retrofit]] for the {{code|java.util}} library having extra features, like data structures like sets and linked sets, and has several algorithms to manipulate elements of a collection, like finding the largest element based on some {{code|Comparator<T>}} object, finding the smallest element, finding sublists within a list, reverse the contents of a list, shuffle the contents of a list, create immutable versions of a collection, performs sorts, and make binary searches.<ref>{{cite web |url=http://www.25hoursaday.com/ |title=A Comparison of Microsoft's C# Programming Language to Sun Microsystems' Java Programming Language: C. An Ever So Slight Feeling of Dèjà Vu: 6. Collections |author=Dare Obasanjo |year=2007 |publisher=Dare Obasanjo |archive-url=https://web.archive.org/web/20120919093308/http://25hoursaday.com/ |archive-date=19 September 2012 |quote=The Java collections framework not only has methods that enable one to access unsafe collections in a thread safe manner, but contains thread-safe versions of most of the data structures as well. The Java collections framework has a number of algorithms for manipulating the elements within the data structures including algorithms that can do the following; find the largest element based on some Comparator, find the smallest element, find sublists within a list, reverse the contents of a list, shuffle the contents of a list, creates immutable versions of a collection, performs sorts, and binary searches. |access-date=10 September 2012 |url-status=dead |df=dmy-all}}</ref>
| The C# collections framework consists of classes from the {{code|System.Collections}} and the {{code|System.Collections.Generic}} namespaces with several useful [[Interface (object-oriented programming)|interfaces]], abstract classes, and data structures.<ref>{{cite web
 |url=http://www.25hoursaday.com/CsharpVsJava.html 
 |title=A Comparison of Microsoft's C# Programming Language to Sun Microsystems' Java Programming Language: C. An Ever So Slight Feeling of Dèjà Vu: 6. Collections 
 |author=Dare Obasanjo 
 |publisher=Dare Obasanjo 
 |archive-url=https://archive.today/20130102015335/http://www.25hoursaday.com/CsharpVsJava.html 
 |archive-date=2 January 2013 
 |date=March 2007 
 |quote=The C# collections framework consists of the classes in the System. Collections and the System.Collections.Generic namespaces. The {{mono|Systems.Collections}} namespace contains [[Interface (object-oriented programming)|interfaces]] and abstract classes that represent abstract data types such as {{mono|IList, IEnumerable, IDictionary, ICollection}}, and {{mono|CollectionBase}} that enable developers to manipulate data structures independently of how they are actually implemented as long as the data structures inherit from the abstract data types. The System.Collections namespace also contains some concrete implementations of data structures such as {{mono|ArrayList, Stack, Queue, HashTable}} and {{mono|SortedList}}. All four of the concrete data structure implementations enable one to obtain synchronized wrappers to the collection that allows for access in a thread-safe manner. The {{mono|System.Collections.Generic}} namespace has generic implementations of the key data structures in the System.Collections namespace including generic {{mono|List<T>}}, {{mono|Stack<T>}}, {{mono|Queue<T>}}, {{mono|Dictionary<K,T>}} and {{mono|SortedDictionary<K,T>}} classes. 
 |access-date=10 September 2012 
 |url-status=dead 
}}</ref> NET 3.5 added {{code|System.Linq}} namespace that contains various extension methods for querying collections, such as {{mono|Aggregate}}, {{mono|All}}, {{mono|Average}}, {{mono|Distinct}}, {{mono|Join}}, {{mono|Union}} and many others. Queries using these methods are called [[Language Integrated Query]] (LINQ).
|}

Multidimensional arrays can in some cases increase performance because of increased [[Memory locality|locality]] (as there is one pointer dereference instead of one for every dimension of the array, as it is the case for jagged arrays). However, since all array element access in a multidimensional array requires multiplication/shift between the two or more dimensions, this is an advantage only in very random access scenarios.

Another difference is that the entire multidimensional array can be allocated with a single application of operator {{mono|new}}, while jagged arrays require loops and allocations for every dimension. However, Java provides a syntactic construct for allocating a jagged array with regular lengths; the loops and multiple allocations are then performed by the virtual machine and need not be explicit at the source level.

Both languages feature an extensive set of collection types that includes various ordered and unordered types of lists, maps/dictionaries, sets, etc.

=== Tuples ===
C# provides two different methods for creating [[tuple]] types (also known as [[product type]]s). The first is via the {{code|System.Tuple}} classes, which are immutable reference types provided by the framework API (starting with .NET Framework 4.0) for creating generic tuple types.<ref name="C# Tuple class"/> This first method has since been effectively superseded by the second, the {{code|System.ValueTuple}} structs, which are mutable value types provided by the framework API (starting with .NET Framework 4.7).<ref name="C# value tuples"/>

While the two methods seem superficially similar, they have multiple notable differences. The {{mono|ValueTuple}} types are value types, so they have a more compact memory footprint; also, the {{mono|ValueTuple}} types expose their contents as mutable fields, compared to the immutable properties of the {{mono|Tuple}} classes. Finally, since C# version 7.0, the language has native syntactical support for the construction, deconstruction, and manipulation of tuples as {{mono|ValueTuple}} instances; this also provides for the arbitrary renaming of the tuples' constituent fields (as opposed to {{mono|Tuple}}, where the fields are always named {{mono|Item1}}, {{mono|Item2}}, etc.).

Java does not provide tuple types as part of its language or standard API; numerous third-party libraries exist which can provide tuple types,<ref>{{Cite web |url=https://www.javatuples.org/ |title=javatuples |access-date=20 April 2023}}</ref> but they all are necessarily similar to the C# {{code|System.Tuple}} classes. In comparison to C# {{mono|ValueTuple}} types and their associated syntax, they are more unwieldy to use (requiring the explicit use of constructors or static factory methods for creating them, requiring individual member access to deconstruct them, and having fixed names for their elements).

== Expressions and operators ==
{| class="wikitable" style="width:80%;"
|-
! style="width:40%;"| Expressions and operators !! style="width:30%;"|Java !! style="width:30%;"|C#
|-
|Arithmetic operators || {{yes}} || {{yes}}
|-
|Logical operators || {{yes}} || {{yes}}
|-
|Bitwise logic operators || {{yes}} || {{yes}}
|-
|Conditional || {{yes}} || {{yes}}
|-
|String concatenation || {{yes}} || {{yes}}
|-
|[[String interpolation]] || {{Yes | style=background: #8CF;}}; Since Java 21 ([[String interpolation#Java|details]]) || {{Yes}}<ref>{{Cite web |url=https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/tokens/interpolated |title=String interpolation using $ |date=8 April 2023 |publisher=learn.microsoft.com |access-date=20 April 2023}}</ref>
|-
|Verbatim (here-)strings || {{Yes}}<ref>{{cite web |url=https://openjdk.java.net/jeps/378 |title=JEP 378: Text Blocks |access-date=5 August 2020}}</ref> || {{yes}}<ref>{{cite web |url=http://www.25hoursaday.com/ |title=A Comparison of Microsoft's C# Programming Language to Sun Microsystems' Java Programming Language: D. Now for Something Completely Different: 13. Verbatim Strings |author=Dare Obasanjo |year=2007 |publisher=Dare Obasanjo |archive-url=https://web.archive.org/web/20120919093308/http://25hoursaday.com/ |archive-date=19 September 2012 |access-date=11 September 2012 |url-status=dead |df=dmy-all}}</ref>
|-
|Casts || {{yes}} || {{yes}}
|-
|[[Boxing (programming)|Boxing]] || {{yes}}; implicit || {{yes}}; implicit
|-
|[[Auto-unboxing|Unboxing]] || {{yes}}; implicit || {{yes}}; explicit
|-
|Lifted operators || {{no | style=background: #8CF;}}; See {{mono|java.util.Optional}} || {{yes}}
|-
|Overflow control || {{no}} || {{yes}}
|-
|Strict floating point evaluation || {{yes}}; opt-in/out || {{yes}}; opt-in<ref>{{cite web |url=https://msdn.microsoft.com/en-us/library/aa289157%28v=vs.71%29.aspx#floapoint_topic4 |title=Microsoft Visual C++ Floating-Point Optimization |author=Eric Fleegal |year=2004 |publisher=MSDN |access-date=1 January 2016
}}</ref>
|}

===Boxing and unboxing===
Both languages allow [[Autoboxing|automatic boxing]] and unboxing, i.e. they allow for implicit casting between any primitive types and the corresponding reference types.

In C#, the primitive types are subtypes of the Object type. In Java this is not true; any given primitive type and the corresponding wrapper type have no specific relationship with each other, except for autoboxing and unboxing, which act as [[syntactic sugar]] for interchanging between them. This was done intentionally, to maintain backward compatibility with prior versions of Java, in which no automatic casting was allowed, and the programmer worked with two separate sets of types: the primitive types, and the wrapper (reference) type hierarchy.<ref name="Jcp.org">{{cite web |url=http://www.jcp.org/en/jsr/detail?id=14 |title=The Java Community Process(SM) Program – JSRs: Java Specification Requests – detail JSR# 14 |publisher=Jcp.org |access-date=24 February 2015}}</ref>

This difference has the following consequences. First of all, in C#, primitive types can define methods, such as an override of Object's {{code|ToString()}} method. In Java, this task is accomplished by the [[primitive wrapper class]]es.

Secondly, in Java an extra cast is needed whenever one tries to directly [[Reference (computer science)|dereference]] a primitive value, as it will not be boxed automatically. The expression {{java|((Integer)42).toString()}} will convert an integer literal to string in Java while {{java|42.ToString()}} performs the same operation in C#. This is because the latter one is an instance call on the primitive value {{mono|42}}, while the former one is an instance call on an object of type {{Javadoc:SE|package=java.lang|java/lang|Integer}}.

Finally, another difference is that Java makes heavy use of boxed types in [[Generic programming|generics]] (see [[#Generics|below]]).

==Statements==
{| class="wikitable" style="width:80%;"
|-
! style="width:40%;"| Statements !! style="width:30%;"|Java !! style="width:30%;"|C#
|-
|[[Loop (computing)|Loops]] || {{yes}} || {{yes}}
|-
|[[Conditional (programming)|Conditionals]] || {{yes}} || {{yes}}
|-
|Flow control || {{yes}} || {{yes}}
|-
|[[Assignment (computer science)|Assignment]] || {{yes}} || {{yes}}
|-
|Exception control || {{yes}} || {{yes}}
|-
|Variable declaration || {{yes}} || {{yes}}
|-
|Variable type inference || {{yes}}<ref>{{cite web |url=http://openjdk.java.net/jeps/286 |title=JEP 286: Local-Variable Type Inference |access-date=25 April 2018}}</ref> || {{yes}}
|-
|Deterministic disposal (ARM-blocks) || {{yes}} || {{yes}}
|}

== Syntax ==
Both languages are considered "curly brace" languages in the C/C++ family. Overall the syntaxes of the languages are very similar. The syntax at the statement and expression level is almost identical with obvious inspiration from the C/C++ tradition. At type definition level (classes and [[Interface (object-oriented programming)|interfaces]]) some minor differences exist. Java is explicit about extending classes and implementing [[Interface (object-oriented programming)|interfaces]], while C# infers this from the kind of types a new class/[[Interface (object-oriented programming)|interface]] derives from.

C# supports more features than Java, which to some extent is also evident in the syntax that specifies more keywords and more grammar rules than Java.

=== Keywords and backward compatibility ===
As the languages evolved, the language designers for both languages have faced situations where they wanted to extend the languages with new keywords or syntax. New keywords in particular may break existing code at source level, i.e. older code may no longer compile, if presented to a compiler for a later version of the language. Language designers are keen to avoid such regressions. The designers of the two languages have been following different paths when addressing this problem.

Java language designers have avoided new keywords as much as possible, preferring instead to introduce new syntactic constructs that were not legal before or to reuse existing keywords in new contexts. This way they didn't jeopardize backward compatibility. An example of the former can be found in how the {{mono|for}} loop was extended to accept iterable types. An example of the latter can be found in how the {{mono|extends}} and (especially) the {{mono|super}} keywords were reused for specifying type bounds when generics were introduced in Java 1.5. At one time (Java 1.4) a new keyword {{mono|assert}} was introduced that was not reserved as a keyword before. This had the potential to render formerly valid code invalid, if for instance the code used {{mono|assert}} as an identifier. The designers chose to address this problem with a four-step solution: 1) Introducing a compiler switch that indicates if Java 1.4 or later should be used, 2) Only marking {{mono|assert}} as a keyword when compiling as Java 1.4 and later, 3) Defaulting to 1.3 to avoid rendering prior (non 1.4 aware code) invalid and 4) Issue warnings, if the keyword is used in Java 1.3 mode, to allow changes in the code.

C# language designers have introduced several new keywords since the first version. However, instead of defining these keywords as ''global'' keywords, they define them as ''context sensitive'' keywords. This means that even when they introduced (among others) the {{mono|partial}} and {{mono|yield}} keywords in C# 2.0, the use of those words as identifiers is still valid as there is no clash possible between the use as keyword and the use as identifier, given the context. Thus, the present C# syntax is fully backward compatible with source code written for any prior version without specifying the language version to be used.
{| class="wikitable"
|-
! keyword !! feature, example usage
|-
| {{mono|checked}}, {{mono|unchecked}} || In C#, {{mono|checked}} statement blocks or expressions can enable run-time checking for [[arithmetic overflow]].<ref>{{cite web |url=http://www.25hoursaday.com/CsharpVsJava.html |title=A Comparison of Microsoft's C# Programming Language to Sun Microsystems' Java Programming Language: D. Now for Something Completely Different: 14. Overflow Detection |author=Dare Obasanjo |year=2007 |archive-url=https://web.archive.org/web/20120922081727/http://www.25hoursaday.com/CsharpVsJava.html |archive-date=22 September 2012 |access-date=11 September 2012 |df=dmy-all}}</ref>
|-
| {{mono|get}}, {{mono|set}} || C# implements [[Property (programming)|properties]] as part of the language syntax with their optional corresponding {{mono|get}} and {{mono|set}} accessors, as an alternative for the [[accessor method]]s used in Java, which is not a language feature but a coding-pattern based on method name conventions.
|-
| {{mono|goto}} || C# supports the <code>[[goto]]</code> keyword. This can be useful on occasion, for example for implementing [[finite-state machine]]s or for [[Code generation (compiler)|generated code]], but use of a more structured method of [[control flow]] is usually recommended (see [[Goto#Criticism|criticism of the goto statement]]). Java does not support the {{mono|goto}} statement (but {{mono|goto}} is a reserved word). However, Java does support labeled {{mono|break}} and {{mono|continue}} statements, which in certain situations can be used when a {{mono|goto}} statement might otherwise be used.

<syntaxhighlight lang="csharp">
switch (color)
{
    case Color.Blue:
        Console.WriteLine("Color is blue");
        break;
    case Color.DarkBlue:
        Console.WriteLine("Color is dark");
        goto case Color.Blue;
    // ...
}
</syntaxhighlight>
|-
| {{mono|lock}} || In C#, the {{mono|lock}} keyword is a shorthand for synchronizing access to a block of code across threads (using a {{mono|Monitor}}), wrapped in a {{mono|try}} ... {{mono|finally}} block.
|-
| {{mono|out}}, {{mono|ref}} || C# has support for output and reference [[parameter (computer science)|parameters]]. These allow returning multiple output values from a method, or passing values by reference.
|-
| {{mono|strictfp}} || Java uses <code>[[strictfp]]</code> to guarantee the results of floating point operations remain the same across platforms.
|-
| {{mono|switch}} || In C#, the [[switch statement]] also operates on strings and longs. Fallthrough is allowed for empty statements and possible via 'goto case' for statements containing code. Java's switch statement operates on strings (since [[Java 7]]) but not the {{mono|long}} primitive type, and falls through for all statements (excluding those with '{{mono|break}}').<ref>{{cite web |url=http://www.25hoursaday.com/CsharpVsJava.html |title=A Comparison of Microsoft's C# Programming Language to Sun Microsystems' Java Programming Language: An Ever So Slight Feeling of Dèjà Vu: 4. {{sic|nolink=y|reason=spelling and capitalization errors in source|switch Stat|ment}} |author=Dare Obasanjo |year=2007 |archive-url=https://web.archive.org/web/20120922081727/http://www.25hoursaday.com/CsharpVsJava.html |archive-date=22 September 2012 |access-date=7 September 2012 |df=dmy-all}}</ref>
|-
| {{mono|synchronized}} || In Java, the {{mono|synchronized}} keyword is a shorthand for synchronizing access to a block of code across threads (using a {{mono|Monitor}}), wrapped in a {{mono|try}} ... {{mono|finally}} block.
|-
| {{mono|throws}} || Java requires every method to declare the checked exceptions or superclasses of the checked exceptions that it can throw. Any method can also optionally declare the unchecked exception that it throws. C# has no such syntax.
<syntaxhighlight lang=Java>
public int readItem() throws java.io.IOException {
    // ...
}
</syntaxhighlight>
|-
| {{mono|using}} || In C#, {{mono|using}} causes the {{mono|Dispose}} method (implemented via the {{mono|IDisposable}} [[Interface (object-oriented programming)|interface]]) of the object declared to be executed after the code block has run or when an exception is thrown within the code block.
<syntaxhighlight lang="csharp">
// Create a small file "test.txt", write a string,
// ... and close it (even if an exception occurs)
using (var file = new StreamWriter("test.txt"))
{
    file.Write("test");
}
</syntaxhighlight>
In Java SE 7 a similar construct has been added<ref>{{cite web |url=http://docs.oracle.com/javase/tutorial/essential/exceptions/tryResourceClose.html |title=The try-with-resources Statement (The Java Tutorials > Essential Classes > Exceptions) |publisher=Docs.oracle.com |date=28 February 2012 |access-date=24 February 2015}}</ref> called try-with-resources:
<syntaxhighlight lang=Java>
try (BufferedReader br = new BufferedReader(new FileReader(path))) {
    return br.readLine();
}
</syntaxhighlight>
|}

== Object-oriented programming ==
Both C# and Java are designed from the ground up as [[Object-oriented programming|object-oriented]] languages using [[dynamic dispatch]], with syntax similar to [[C++]] (C++ in turn [[Compatibility of C and C++|derives]] from [[C (programming language)|C]]). Neither language is a superset of C or C++, however.

{| class="wikitable" style="width:80%;"
|-
! style="width:40%;"| Object orientation!! style="width:30%;"|Java !! style="width:30%;"|C#
|-
|[[Class (computer programming)|Classes]] || {{yes|mandatory}} || {{yes|mandatory}}
|-
|[[Interface (object-oriented programming)|Interfaces]] || {{yes}} || {{yes}}
|-
|[[Class (computer programming)#Abstract and concrete|Abstract classes]] || {{yes}} || {{yes}}
|-
|Member accessibility levels || {{yes|public, package, protected, private}} || {{yes| public, internal, protected, private, protected internal}}
|-
|Class-level [[Class (computer programming)#Local and inner|inner classes]] || {{yes}} || {{yes}}
|-
|Instance-level inner classes || {{yes}} || {{no}}
|-
|Statement-level (local) [[Class (computer programming)#Unnamed|anonymous classes]] || {{yes}} || {{yes|Yes; but without methods| style=background: #8CF;}}
|-
|[[Partial class]]es || {{no | style=background: #8CF;}}; Third-party library<ref>[[AspectJ|Extension created for the Java programming language]]</ref> || {{yes}}
|-
|Implicit (inferred) anonymous classes || {{ No| style=background: #8CF;}}; Not needed|| {{yes}}<ref>{{cite web |url=https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/types/anonymous-types |title=Anonymous Types (C# Fundamentals) |publisher=learn.microsoft.com |access-date=14 April 2013}}</ref>
|-
|[[Deprecation]]/obsolescence || {{yes}} || {{yes}}
|-
|Overload versioning || {{some}} || {{yes}}
|-
| [[Enumerated type|Enums]] can implement [[Interface (object-oriented programming)|interfaces]] || {{yes}} || {{no}}
|-
|[[Property (programming)|Properties]] || {{no}} || {{yes}}
|-
|[[Event (computing)|Events]] || {{yes|Provided by standard libraries}} || {{yes|Built-in language feature}}
|-
|[[Operator overloading]] || {{no}} || {{yes}}
|-
|Indexers || {{no}} || {{yes}}
|-
|Implicit conversions || {{no | style=background: #8CF;}}; but see [https://docs.oracle.com/javase/tutorial/java/data/autoboxing.html autoboxing] || {{yes}}
|-
|Explicit conversions || {{yes}} || {{yes}}
|}

=== Partial class ===
C# allows a class definition to be split across several source files using a feature called ''partial classes''. Each part must be marked with the keyword {{mono|partial}}. All the parts must be presented to the compiler as part of a single compilation. Parts can reference members from other parts. Parts can implement interfaces and one part can define a base class. The feature is useful in code generation scenarios (such as [[user interface]] (UI) design), where a code generator can supply one part and the developer another part to be compiled together. The developer can thus edit their part without the risk of a code generator overwriting that code at some later time. Unlike the class extension mechanism, a partial class allows ''circular'' dependencies among its parts as they are guaranteed to be resolved at compile time. Java has no corresponding concept.

=== Inner and local classes ===
Both languages allow ''inner classes'', where a class is defined lexically inside another class. However, in each language these inner classes have rather different semantics.

In Java, unless the inner class is declared {{mono|static}}, a reference to an instance of an inner class carries a reference to the outer class with it. As a result, code in the inner class has access to both the static and non-static members of the outer class. To create an instance of a non-static inner class, the instance of the embracing outer class must be named.<ref name="inner instance creation">{{cite web |url=http://java.sun.com/docs/books/jls/third_edition/html/expressions.html#41147 |title=Java SE Specifications |publisher=Java.sun.com |access-date=24 February 2015}}</ref> This is done via a new {{mono|new}}-operator introduced in JDK 1.3: {{code|outerClassInstance.new Outer.InnerClass()}}. This can be done in any class that has a reference to an instance of the outer class.

In C#, an inner class is conceptually the same as a normal class. In a sense, the outer class only acts as a namespace. Thus, code in the inner class cannot access non-static members of the outer class unless it does so through an explicit reference to an instance of the outer class. Programmers can declare the inner class ''private'' to allow only the outer class to have any access to it.

Java provides another feature called ''local classes'' or ''anonymous classes'', which can be defined within a method body. These are generally used to implement an interface with only one or two methods, which are typically event handlers. However, they can also be used to override virtual methods of a superclass. The methods in those local classes have access to the outer method's local variables declared {{mono|final}}. C# satisfies the use-cases for these by providing anonymous [[Delegate (CLI)|delegates]]; see [[#Event|event handling]] for more about this.

C# also provides a feature called ''anonymous types/classes'', but it is rather different from Java's concept with the same name. It allows the programmer to instantiate a class by providing only a set of names for the properties the class should have, and an expression to initialize each. The types of the properties are inferred from the types of those expressions. These implicitly-declared classes are derived directly from ''object''.

=== Event ===
C# multicast-delegates are used with ''events''. Events provide support for [[event-driven programming]] and are an implementation of the [[observer pattern]]. To support this there is a specific syntax to define events in classes, and operators to register, unregister or combine event handlers.

See [[#Delegates, method references|here]] for information about how events are implemented in Java.

=== Operator overloading and conversions ===
[[Operator overloading]] and user-defined [[type conversion|casts]] are separate features that both aim to allow new types to become first-class citizens in the type system. By using these features in C#, types such as [[Complex numbers|{{mono|Complex}}]] and [[decimal128|{{mono|decimal}}]] have been integrated so that the usual operators like addition and multiplication work with the new types. Unlike C++, C# does restrict the use of operator overloading, prohibiting it for the operators {{mono|new}}, {{code|( )}}, {{code|{{!}}{{!}}}}, {{code|&&}}, {{code|{{=}}}}, and any variations of compound statements like {{code|+{{=}}}}. But compound operators will call overloaded simple operators, like {{code|-{{=}}}} calling {{code|-}} and {{code|{{=}}}}.<ref name="nested">{{cite web |url=http://www.25hoursaday.com/ |title=A Comparison of Microsoft's C# Programming Language to Sun Microsystems' Java Programming Language: Operator Overloading |author=Dare Obasanjo |year=2007 |publisher=Dare Obasanjo |archive-url=https://web.archive.org/web/20120919093308/http://25hoursaday.com/ |archive-date=19 September 2012 |quote=Note: Unlike C++, C# does not allow the overloading of the following operators; {{mono|1=new, ( ), &#124;&#124;, &&, =}}, or any variations of compound assignments such as {{mono|1=+=, -=}}, etc. However, compound assignment operators will call overloaded operators, for instance, {{mono|1=+=}} would call overloaded {{mono|1=+}}. |access-date=6 September 2012 |url-status=dead |df=dmy-all}}</ref>

Java does not include operator overloading, nor custom conversions to prevent abuse of the feature and to keep the language simple.<ref>{{cite web |url=http://www.cafeaulait.org/1998august.html |title=Java News from August, 1998 |publisher=Cafeaulait.org |access-date=24 February 2015}}</ref>

=== Indexer ===
C# also includes ''indexers'' that can be considered a special case of operator overloading (like the C++ {{code|operator[]}}), or parameterized {{mono|get}}/{{mono|set}} properties. An indexer is a property named {{code|this[]}} that uses one or more parameters (indexes); the indices can be objects of any type:

<syntaxhighlight lang="csharp">
myList[4] = 5;
string name = xmlNode.Attributes["name"];
orders = customerMap[theCustomer];
</syntaxhighlight>

Java does not include indexers. The common Java pattern involves writing explicit getters and setters where a C# programmer would use an indexer.

=== Fields and initialization ===
{| class="wikitable" style="width:80%;"
|-
! style="width:40%;"| Fields and initialization !! style="width:30%;"|Java !! style="width:30%;"|C#
|-
|[[Field (computer science)|Fields]] || {{yes}} || {{yes}}
|-
|[[Constant (programming)|Constants]] || {{yes}} || {{yes}}; but no support for constant passed parameters<ref name="final">{{cite web
 |url=http://csunwold.blogspot.co.at/2010/02/from-stackoverflow-im-looking-for-c.html 
 |title=C# Equivalent to Java's "final" 
 |last1=Sunwold 
 |first1=Corey 
 |date=25 February 2010 
 |publisher=Corey Sunwold 
 |archive-url=https://archive.today/20121129011204/http://csunwold.blogspot.co.at/2010/02/from-stackoverflow-im-looking-for-c.html 
 |url-status=live 
 |archive-date=29 November 2012 
 |quote=There is than one use of the final keyword that C# does not have an equivalent for. When you pass a parameter to a method in Java, and you don't want that parameter's value to change within the scope of that method you can set it as final like this: 
 |access-date=13 September 2016 
}}</ref>
|-
|Static (class) [[Constructor (object-oriented programming)|constructors]] || {{yes}} || {{yes}}
|-
|Instance constructors || {{yes}} || {{yes}}
|-
|[[Destructor (computer science)|Finalizers/destructors]] || {{yes}} || {{yes}}
|-
|Instance initializers || {{yes}} || {{no}}; can be simulated with instance constructor
|-
|Object [[Initialization (programming)|initialization]] || {{yes|Bottom-up <br/>(fields and constructors)}} || {{yes|Top-down (fields); bottom-up (constructors)}}
|-
|Object initializers || {{yes}} || {{yes}}
|-
|Collection initializers || {{yes|Static varargs methods}} || {{yes}}
|-
|Array initializers || {{yes}} || {{yes}}
|}

==== Object initialization ====
In both C# and Java, an object's fields can be initialized either by ''variable initializers'' (expressions that can be assigned to variables where they are defined) or by ''constructors'' (special subroutines that are executed when an object is being created). In addition, Java contains ''instance initializers'', which are anonymous blocks of code with no arguments that are run after the explicit (or implicit) call to a superclass's constructor but before the constructor is executed.

C# initializes object fields in the following order when creating an object:
# Derived static fields
# Derived static constructor
# Derived instance fields
# Base static fields
# Base static constructor
# Base instance fields
# Base instance constructor
# Derived instance constructor

Some of the above fields may not be applicable (e.g. if an object does not have ''static fields''). ''Derived fields'' are those that are defined in the object's direct class, while ''base field'' is a term for the fields that are defined in one of the object's superclasses. Note that an object representation in memory contains all fields defined in its class or any of its superclasses, even, if some fields in superclasses are defined as private.

It is guaranteed that any field initializers take effect before any constructors are called, since both the instance constructor of the object's class and its superclasses are called after field initializers are called. There is, however, a potential trap in object initialization when a virtual method is called from a base constructor. The overridden method in a subclass may reference a field that is defined in the subclass, but this field may not have been initialized because the constructor of the subclass that contains field initialization is called after the constructor of its base class.

In Java, the order of initialization is as follows:
# Invocation of another constructor (either of the object's class or of the object's superclass)
# Instance variable initializers and instance initializers (in the order they appear in the source code)
# The constructor body

Like in C#, a new object is created by calling a specific constructor. Within a constructor, the first statement may be an invocation of another constructor. If this is omitted, the call to the argumentless constructor of the superclass is added implicitly by the compiler. Otherwise, either another overloaded constructor of the object's class can be called explicitly, or a superclass constructor can be called. In the former case, the called constructor will again call another constructor (either of the object's class or its subclass) and the chain sooner or later ends up at the call to one of the constructors of the superclass.

After another constructor is called (that causes direct invocation of the superclass constructor, and so forth, down to the Object class), instance variables defined in the object's class are initialized. Even if there are no variable initializers explicitly defined for some variables, these variables are initialized to default values. Note that instance variables defined in superclasses are already initialized by this point, because they were initialized by a superclass constructor when it was called (either by the constructor's code or by variable initializers performed before the constructor's code or implicitly to default values). In Java, variable initializers are executed according to their textual order in the source file.

Finally, the constructor body is executed. This ensures proper order of initialization, i.e. the fields of a base class finish initialization before initialization of the fields of an object class begins.

There are two main potential traps in Java's object initialization. First, variable initializers are expressions that can contain method calls. Since methods can reference any variable defined in the class, the method called in a variable initializer can reference a variable that is defined below the variable being initialized. Since initialization order corresponds to textual order of variable definitions, such a variable would not be initialized to the value prescribed by its initializer and would contain the default value.
Another potential trap is when a method that is overridden in the derived class is called in the base class constructor, which can lead to behavior the programmer would not expect when an object of the derived class is created. According to the initialization order, the body of the base class constructor is executed before variable initializers are evaluated and before the body of the derived class constructor is executed. The overridden method called from the base class constructor can, however, reference variables defined in the derived class, but these are not yet initialized to the values specified by their initializers or set in the derived class constructor. The latter issue applies to C# as well, but in a less critical form since in C# methods are not overridable by default.

=== Resource disposal ===
Both languages mainly use [[garbage collection (computer science)|garbage collection]] as a means of reclaiming memory resources, rather than explicit deallocation of memory. In both cases, if an object holds resources of different kinds other than memory, such as file handles, graphical resources, etc., then it must be notified explicitly when the application no longer uses it. Both C# and Java offer interfaces for such deterministic [[dispose pattern|disposal]] and both C# and Java (since Java 7) feature automatic resource management statements that will automatically invoke the disposal/close methods on those interfaces.

=== Methods ===
{| class="wikitable" style="width:80%;"
|-
! style="width:40%;"| Methods and properties !! style="width:30%;"|Java !! style="width:30%;"|C#
|-
|Static imports || {{yes}} || {{yes}}<ref>{{cite web |url=https://learn.microsoft.com/en-us/archive/msdn-magazine/2014/may/csharp-a-csharp-6-0-language-preview |title=C# – A C# 6.0 Language Preview |date=July 2015 |publisher=learn.microsoft.com |access-date=14 April 2023}}</ref>
|-
|Virtual methods|| {{yes|Virtual by default}} || {{yes|Non-Virtual by default}}
|-
|[[Abstraction (computer science)|Abstract]] || {{yes}} || {{yes}}
|-
|Sealing || {{yes}} || {{yes}}
|-
|Explicit interface implementation || {{yes|Default methods}} || {{yes}}<ref name="interface">{{cite web |url=http://www.25hoursaday.com/CsharpVsJava.html#explicitinterface |title=A Comparison of Microsoft's C# Programming Language to Sun Microsystems' Java Programming Language: D. Now for Something Completely Different: 15. Explicit Interface Implementation |author=Dare Obasanjo |year=2007 |publisher=Dare Obasanjo |archive-url=https://web.archive.org/web/20120922081727/http://www.25hoursaday.com/CsharpVsJava.html#explicitinterface |archive-date=22 September 2012 |access-date=11 September 2012 |url-status=live |df=dmy-all}}</ref>
|-
|Value (input) parameters || {{yes}} || {{yes}}
|-
|Reference (input/output) parameters || {{no}} || {{yes}}
|-
|Output (output) parameters || {{no}} || {{yes}}
|-
|Constant (immutable) parameters || {{yes}}; [[#Constant/immutable parameters|final]] parameters || {{yes}}<ref>{{cite web |url=https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/in-parameter-modifier |title=in parameter modifier (C# Reference) |date=5 March 2018 |publisher=Microsoft |archive-url=https://archive.today/20190126124708/https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/in-parameter-modifier |url-status=live |archive-date=26 January 2019 |access-date=26 January 2019}}</ref>
|-
|[[Variadic function|Variadic methods]] || {{yes}} || {{yes}}
|-
|Optional arguments || {{no}};<ref>{{cite web | last1=Gosling|first1=James |title=The Java® Language Specification |url=http://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html#jls-8.4.1 |access-date=5 October 2014|location=Section 8.4.1. Formal Parameters}}</ref> Instead method overloading or varargs || {{yes}}
|-
|Named arguments || {{yes}}; with annotations || {{yes}}
|-
|[[Generator (computer programming)|Generator methods]] || {{no | style=background: #8CF;}}; but see [[Generator (computer programming)#Java|Stream Api]] || {{yes}}
|-
|Extension/default methods || {{yes}} || {{yes}}
|-
|Conditional methods || {{no}} || {{yes}}
|-
|Partial methods || {{no}} || {{yes}}
|}

==== Extension methods and default methods ====
Using a special ''this'' designator on the first parameter of a method, C# allows the method to act as if it were a member method of the type of the first parameter. This ''extension'' of the foreign class is purely syntactical. The extension method must be declared {{mono|static}} and defined within a purely static class. The method must obey any member access restriction like any other method external to the class; thus static methods cannot break object encapsulation.<ref>{{cite web
| url=http://www.hanselman.com/blog/HowDoExtensionMethodsWorkAndWhyWasANewCLRNotRequired.aspx
| title=How do Extension Methods work and why was a new CLR not required?
| first=Scott|last=Hanselman
| date=4 April 2008
| quote=''Extension methods are a really nice syntactic sugar. They're not really added to the class, as we can see, but the compiler makes it feel like they are''
| access-date=29 March 2014}}</ref><ref>{{cite web
| url=http://msdn.microsoft.com/en-us//library/bb383977.aspx
| title=Extension Methods (C# Programming Guide)
| publisher=[[Microsoft]]
| year=2013
| quote=''Extension methods are defined as static methods but are called by using instance method syntax''
| access-date=29 March 2014}}</ref> The "extension" is only active within scopes where the namespace of the static host class has been imported.

Since Java 8, Java has a similar feature called ''default methods'', which are methods with a body declared on interfaces. As opposed to C# extension methods, Java default methods are instance methods on the interface that declare them. Definition of default methods in classes that implement the interface is optional: If the class does not define the method, the default definition is used instead.

Both the C# extension methods and the Java default methods allow a class to override the default implementation of the extension/default method, respectively. In both languages this override is achieved by defining a method on the class that should use an alternate implementation of the method.

C# scope rules defines that if a matching method is found on a class, it takes precedence over a matching extension method. In Java any class declared to implement an interface with default method is assumed to have the default methods implementations, ''unless'' the class implements the method itself.

==== Partial methods ====
Related to ''partial classes'' C# allows partial methods to be specified within partial classes. A partial method is an intentional declaration of a method with several restrictions on the signature. The restrictions ensure that if a definition is not provided by any class part, then the method and every call to it can be safely erased.<ref>{{cite web |title=C# Language Specification Version 4.0 |url=http://www.microsoft.com/en-us/download/details.aspx?id=7029 |publisher=Microsoft |access-date=10 May 2012 |page=281 |quote=If no part of a partial type declaration contains an implementing declaration for a given partial method, any expression statement invoking it is simply removed from the combined type declaration. Thus the invocation expression, including any constituent expressions, has no effect at run-time. The partial method itself is also removed and will not be a member of the combined type declaration. If an implementing declaration exist for a given partial method, the invocations of the partial methods are retained. The partial method gives rise to a method declaration similar to the implementing partial method declaration except for the following: […]}}</ref> This feature allows code to provide a large number of interception points (like the [[Template method pattern|template method]] [[Design Patterns|GoF]] design pattern) without paying any runtime overhead if these extension points are not being used by another class part at compile time. Java has no corresponding concept.

==== Virtual methods ====
''Methods'' in C# are non-[[Virtual function|virtual]] by default, and must be declared virtual explicitly, if desired. In Java, all non-static non-private methods are virtual. Virtuality guarantees that the most recent [[Method overriding (programming)|override]] for the method will always be called, but incurs a certain runtime cost on invocation as these invocations cannot be normally [[Inline expansion|inlined]], and require an indirect call via the [[virtual method table]]. However, some JVM implementations, including the Oracle 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 {{mono|final}} modifier to disallow overriding). There is no way to let [[Subclass (computer science)|derived classes]] define a new, unrelated method with the same name.

This means that by default in Java, and only when explicitly enabled in C#, new methods may be defined in a derived class with the same name and signature as those in its base class. When the method is called on a superclass reference of such an object, the "deepest" overridden implementation of the [[base class]]' method will be called according to the specific subclass of the object being referenced.

In some cases, when a subclass introduces a method with the same name and signature as a method already present in the [[base class]], problems can occur. 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 mitigate this, C# requires that if a method is intended to override an inherited method, the {{mono|override}} keyword must be specified. Otherwise, the method will "hide" the inherited method. If the keyword is absent, compiler warning to this effect is issued, which can be silenced by specifying the {{mono|new}} keyword. This avoids the problem that can arise from a base class being extended with a non-private method (i.e. an inherited part of the namespace) whose signature is already in use by a derived class. Java has a similar compiler check in the form of the {{code|@Override}} method annotation, but it is not compulsory, and in its absence, most compilers will not provide comment (but the method will be overridden).

==== Constant/immutable parameters ====
In Java, it is possible to prevent reassignment of a local variable or method parameter by using the {{Java|final}} keyword. Applying [[final (Java)#Final variables|this keyword]] to a primitive type variable causes the variable to become immutable. However, applying {{Java|final}} to a reference type variable only prevents that another object is assigned to it. It will not prevent the data contained by the object from being mutated. As of {{not a typo|C#7}}, it is possible to prevent reassignment of a method parameter by using the {{mono|in}} keyword, however this keyword cannot be used on local variables. As with Java, applying {{mono|in}} to a parameter only prevents the parameter from being reassigned to a different value. It is still possible to mutate the data contained by the object.<ref name="in">{{cite web
 |url=https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/in-parameter-modifier 
 |title=in parameter modifier (C# Reference) 
 |date=5 March 2018 
 |publisher=Microsoft 
 |archive-url=https://archive.today/20190126124708/https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/in-parameter-modifier
 |url-status=live 
 |archive-date=26 January 2019 
 |quote=The in keyword causes arguments to be passed by reference. It is like the ref or out keywords, except that in arguments cannot be modified by the called method. 
 |access-date=26 January 2019
}}</ref>
{| class="wikitable"
|-
! Java !! C#
|-
| <syntaxhighlight lang="java">
public int addOne(final int x) {
    x++; // ERROR: a final variable cannot be reassigned
    return x;
}

public List addOne(final List<Integer> list) {
    list.add(1); // OK: it is still possible to modify a
                 // final (reference type) variable
    return list;
}</syntaxhighlight>
|| <syntaxhighlight lang="csharp">
public int AddOne(in int x) 
{
    x++; // ERROR: a readonly parameter cannot be reassigned
    return x;
}

public List<int> AddOne(in List<int> list) 
{
    list.Add(1); // OK: it is still possible to modify a
                 // readonly (reference type) parameter
    return list;
}
</syntaxhighlight>
|}

Both languages do not support essential feature of [[const-correctness]] that exists in [[C (programming language)|C]]/[[C++]], which makes a method constant.

Java defines the word "constant" arbitrarily as a {{Java|static final}} field. As a convention, these variable names are capital-only with words separated with an [[underscore]] but the Java language doesn't insist on this. A parameter that is only {{Java|final}} is not considered as a constant, although it may be so in the case of a [[primitive data type]] or an [[immutable class]], like a {{Java|String}}.

==== Generator methods ====
{{further|Generator (computer programming)}}
Any C# method declared as returning {{mono|IEnumerable}}, {{mono|IEnumerator}} or the generic versions of these interfaces can be implemented using {{mono|yield}} syntax. This is a form of limited, compiler-generated continuations and can drastically reduce the code needed to traverse or generate sequences, although that code is just generated by the compiler instead. The feature can also be used to implement infinite sequences, e.g., the sequence of [[Fibonacci numbers]].

Java does not have an equivalent feature. Instead, generators are typically defined by providing a specialized implementation of a well-known collection or iterable interface, which will compute each element on demand. For such a generator to be used in a ''for each'' statement, it must implement interface {{Javadoc:SE|package=java.lang|java/lang|Iterable}}.

See also example [[#Fibonacci sequence|Fibonacci sequence]] below.

==== Explicit interface implementation ====
C# also has ''explicit interface implementation'' that allows a class to specifically implement methods of an [[Interface (object-oriented programming)|interface]], separate to its own class methods, or to provide different implementations for two methods with the same name and signature inherited from two base interfaces.

In either language, if a method (or property in C#) is specified with the same name and signature in multiple interfaces, the members will clash when a class is designed that implements those interfaces. An implementation will by default implement a common method for all of the interfaces. If separate implementations are needed (because the methods serve separate purposes, or because return values differ between the interfaces) C#'s explicit interface implementation will solve the problem, though allowing different results for the same method, depending on the current cast of the object. In Java there is no way to solve this problem other than refactoring one or more of the interfaces to avoid name clashes.<ref name="interface" />

==== Reference (in/out) parameters ====
The arguments of primitive types (e.g. int, double) to a method are passed by value in Java whereas objects are passed by reference. This means that a method operates on copies of the primitives passed to it instead of on the actual variables. On the contrary, the actual objects in some cases can be changed. In the following example, object String is not changed. Object of class 'a' is changed.

In C#, it is possible to enforce a reference with the {{mono|ref}} keyword, similar to C++ and in a sense to C. This feature of C# is particularly useful when one wants to create a method that returns more than one object. In Java trying to return multiple values from a method is unsupported unless a wrapper is used, in this case named "Ref".<ref>{{cite web |url=http://www.25hoursaday.com/ |title=A Comparison of Microsoft's C# Programming Language to Sun Microsystems' Java Programming Language: D. Now for Something Completely Different: 12. Pass by Reference |author=Dare Obasanjo |year=2007 |publisher=Dare Obasanjo |archive-url=https://web.archive.org/web/20120919093308/http://25hoursaday.com/ |archive-date=19 September 2012 |quote=In Java the arguments to a method are passed by value meaning that a method operates on copies of the items passed to it instead of on the actual items. In C#, as in C++ and in a sense C, it is possible to specify that the arguments to a method actually be references to the items being passed to the method instead of copies. This feature is particularly useful when one wants to create a method that returns more than one object. In Java trying to return multiple values from a method is unsupported and leads to anomalies like: a method that swaps two numbers that have been the hallmark of freshman computer science classes for years, is impossible to do in Java without resorting to coding tricks. |access-date=10 September 2012 |url-status=dead |df=dmy-all}}</ref>

{| style="width:100%; border:none;" class="wikitable"
|-
!width=50%| Java !! style="width:50%;"| C#
|- valign=top
| <syntaxhighlight lang="java" style="font-size:95%">
class PassByRefTest {

    static class Ref<T> {
        T val;
        Ref(T val) { this.val = val; }
    }
    
    static void changeMe(Ref<String> s) {
        s.val = "Changed";
    }

    static void swap(Ref<Integer> x, Ref<Integer> y) {
        int temp = x.val;

        x.val = y.val;
        y.val = temp;
    }

    public static void main(String[] args) {
        var a = new Ref(5);
        var b = new Ref(10);
        var s = new Ref("still unchanged");
        
        swap(a, b);
        changeMe(s);

        System.out.println( "a = " + a.val + ", " +
                            "b = " + b.val + ", " +
                            "s = " + s.val );
    }
}
</syntaxhighlight> 
| <syntaxhighlight lang="csharp" style="font-size:95%">
class PassByRefTest 
{
    public static void ChangeMe(out string s) 
    {
        s = "Changed";
    }

    public static void Swap(ref int x, ref int y) 
    {
        int temp = x;

        x = y;
        y = temp;
    }

    public static void Main(string[] args) 
    {
        int a = 5;
        int b = 10;
        string s = "still unchanged";

        Swap(ref a, ref b);
        ChangeMe(out s);

        System.Console.WriteLine("a = " + a + ", " +
                                 "b = " + b + ", " +
                                 "s = " + s);
    }
}</syntaxhighlight>
|- valign=top
| {{code|1=a = 10, b = 5, s = Changed}} || {{code|1=a = 10, b = 5, s = Changed}}
|}

=== Exceptions ===
{| class="wikitable" style="width:80%;"
|-
! style="width:40%;"| Exceptions !! style="width:30%;"|Java !! style="width:30%;"|C#
|-
|Checked exceptions || {{yes}} || {{no}}
|-
|Try-catch-finally || {{yes}} || {{yes}}
|-
|Exception filters || {{no}} || {{yes}}<ref>{{cite web |url=https://www.pluralsight.com/guides/exceptional-exception-filtering |title=Exceptional Exception Filtering |publisher=Pluralsight® |access-date=24 June 2022}}</ref>
|}

====Checked exceptions====
Java supports [[checked exceptions]] (along with unchecked exceptions). C# only supports unchecked exceptions. Checked exceptions force the programmer to either declare the exception thrown in a method, or to catch the thrown exception using a {{tt|try-catch}} clause.

Checked exceptions can encourage good programming practice, ensuring that all errors are dealt with. However [[Anders Hejlsberg]], chief C# language architect, argues that they were to some extent an experiment in Java and that they have not been shown to be worthwhile except in small example programs.<ref>{{cite web |url=http://www.artima.com/intv/handcuffs.html |title=The Trouble with Checked Exceptions |publisher=Artima.com |access-date=24 February 2015}}</ref><ref>{{cite web |url=http://msdn2.microsoft.com/en-us/vcsharp/aa336812.aspx |title=Msdn forums – Visual C# Language |publisher=Msdn2.microsoft.com |access-date=24 February 2015 |archive-url=https://web.archive.org/web/20070320060200/http://msdn2.microsoft.com/en-us/vcsharp/aa336812.aspx |archive-date=20 March 2007 |url-status=dead}}</ref>

One criticism is that checked exceptions encourage programmers to use an empty catch block ({{java|catch (Exception e) {}|}}),<ref name=bruceeckel>{{cite web |last=Eckel |first=Bruce |url=http://www.mindview.net/Etc/Discussions/CheckedExceptions |title=Does Java need Checked Exceptions? |access-date=6 December 2012 |archive-url=https://web.archive.org/web/20020405175011/http://www.mindview.net/Etc/Discussions/CheckedExceptions |archive-date=5 April 2002 |url-status=dead }}</ref> which silently swallows exceptions, rather than letting the exceptions propagate to a higher-level exception-handling routine. In some cases, however, [[exception chaining]] can be applied instead, by re-throwing the exception in a wrapper exception. For example, if an object is changed to access a database instead of a file, an {{Javadoc:SE|java/sql|SQLException}} could be caught and re-thrown as an {{Javadoc:SE|java/io|IOException}}, since the caller may not need to know the inner workings of the object.

However, not all programmers agree with this stance. James Gosling and others maintain that checked exceptions are useful, and misusing them has caused the problems. Silently catching exceptions is possible, yes, but it must be stated explicitly what to do with the exception, versus unchecked exceptions that allow doing nothing by default. It can be ignored, but code must be written explicitly to ignore it.<ref>{{cite web |url=http://www.artima.com/intv/solid.html |title=Failure and Exceptions |publisher=Artima.com |date=22 September 2003 |access-date=18 August 2013}}</ref><ref>{{cite web |url=http://www.shaunabram.com/checked-exceptions-article/ |title=Checked Exceptions |publisher=Shaun Abram |access-date=18 August 2013}}</ref>

====Try-catch-finally====
There are also differences between the two languages in treating the {{code|try-finally}} statement. The {{mono|finally}} block is always executed, even if the {{mono|try}} block contains control-passing statements like {{mono|throw}} or {{mono|return}}. In Java, this may result in unexpected behavior, if the {{mono|try}} block is left by a {{mono|return}} statement with some value, and then the {{mono|finally}} block that is executed afterward is also left by a {{mono|return}} statement with a different value. C# resolves this problem by prohibiting any control-passing statements like {{mono|return}} or {{mono|break}} in the {{mono|finally}} block.

A common reason for using {{code|try-finally}} blocks is to guard resource managing code, thus guaranteeing the release of precious resources in the finally block. C# features the {{mono|using}} statement as a syntactic shorthand for this common scenario, in which the {{code|Dispose()}} method of the object of the {{mono|using}} is always called.

A rather subtle difference is the moment a [[stack trace]] is created when an exception is being thrown. In Java, the stack trace is created in the moment the exception is created.

<syntaxhighlight lang=Java>
class Foo {
    Exception up = new Exception();
    int foo() throws Exception {
        throw up;
    }
}
</syntaxhighlight>

The exception in the statement above will always contain the constructor's stack-trace – no matter how often foo is called.
In C# on the other hand, the stack-trace is created the moment "throw" is executed.

<syntaxhighlight lang="csharp">
class Foo
{
    Exception e = new Exception();

    int foo()
    {
        try
        {
            throw e;
        }
        catch (Exception e)
        {
            throw;
        }
    }
}
</syntaxhighlight>

In the code above, the exception will contain the stack-trace of the first throw-line. When catching an exception, there are two options in case the exception should be rethrown: {{mono|throw}} will just rethrow the original exception with the original stack, while {{code|throw e}} would have created a new stack trace.

==== Finally blocks ====
Java allows flow of control to leave the {{mono|finally}} block of a {{mono|try}} statement, regardless of the way it was entered. This can cause another control flow statement (such as {{mono|return}}) to be terminated mid-execution. For example:

<syntaxhighlight lang="java">
int foo() {
    try {
        return 0;
    } finally {
        return 1;
    }
}
</syntaxhighlight>

In the above code, the {{mono|return}} statement within the {{mono|try}} block causes control to leave it, and thus {{mono|finally}} block is executed before the actual return happens. However, the {{mono|finally}} block itself also performs a return. Thus, the original return that caused it to be entered is not executed, and the above method returns 1 rather than 0. Informally speaking, it ''tries'' to return 0 but ''finally'' returns 1.

C# does not allow any statements that allow control flow to leave the {{mono|finally}} block prematurely, except for {{mono|throw}}. In particular, {{mono|return}} is not allowed at all, {{mono|goto}} is not allowed if the target label is outside the {{mono|finally}} block, and {{mono|continue}} and {{mono|break}} are not allowed if the nearest enclosing loop is outside the {{mono|finally}} block.

== Generics ==
{{See also|Generic programming}}

In the field of [[generic programming|generics]] the two languages show a superficial syntactical similarity, but they have deep underlying differences.
{| class="wikitable" style="width:80%;"
|-
! style="width:40%;"| Generics !! style="width:30%;"|Java !! style="width:30%;"|C#
|-
|Implementation || {{yes|[[Type erasure]]}} || {{yes|[[Reification (computer science)|Reification]]}}
|-
|Runtime realization || {{no}} || {{yes}}
|-
|[[Covariance and contravariance (computer science)|Type variance]] || {{yes|[[Covariance and contravariance (computer science)#Use-site variance annotations (wildcards)|Use-site]]}} || {{yes|[[Covariance and contravariance (computer science)#Declaration-site variance annotations|Declaration-site]] (only on interfaces)}}
|-
|Reference type constraint || {{yes}}; implicit || {{yes}}
|-
|Value/primitive type constraint || {{no}} || {{yes}}
|-
|Constructor constraint || {{no}} || {{yes}}<br/>(only for parameterless constructor)
|-
|[[Bounded quantification|Subtype constraint]]|| {{yes}} || {{yes}}
|-
|[[Wildcard (Java)#Bounded Wildcards|Supertype constraint]] || {{yes}} || {{no}}
|-
|Migration compatibility || {{yes}} || {{no}}
|}

=== Type erasure versus reified generics ===
[[Generics in Java]] are a language-only construction; they are implemented only in the compiler. The generated classfiles include generic signatures only in form of metadata (allowing the compiler to compile new classes against them). The runtime has no knowledge of the generic type system; generics are not part of the [[Java virtual machine]] (JVM). Instead, generics classes and methods are transformed during compiling via a process termed [[type erasure]]. During this, the compiler replaces all generic types with their ''raw'' version and inserts casts/checks appropriately in client code where the type and its methods are used. The resulting byte code will contain no references to any generic types or parameters (See also [[Generics in Java]]).

The Java language specification intentionally prohibits certain uses of generics; this is necessary to allow for implementing generics through [[type erasure]], and to allow for migration compatibility.<ref>{{cite web |url=http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#113528 |title=Java SE Specifications |publisher=Java.sun.com |access-date=24 February 2015}}</ref> Research into adding reified generics to the Java platform is ongoing, as part of [[Project Valhalla (Java language)|Project Valhalla]].

C# builds on support for generics from the virtual execution system, i.e., it is not just a language feature. The language is merely a front-end for cross-language generics support in the [[Common Language Runtime|CLR]]. During compiling generics are verified for correctness, but code generation to ''implement'' the generics are deferred to class-load time. Client code (code invoking generic methods/properties) are fully compiled and can safely assume generics to be type-safe. This is called [[Reification (computer science)|reification]]. At runtime, when a unique set of type parameters for a generic class/method/delegate is encountered for the first time, the class loader/verifier will synthesize a concrete class descriptor and generate method implementations. During the generation of method implementations all reference types will be considered one type, as reference types can safely share the same implementations. This is merely for the purpose of ''implementing'' code. Different sets of reference types will still have unique type descriptors; their method tables will merely point to the same code.

The following list illustrates some differences between Java and C# when managing generics. It is not exhaustive:<ref>{{cite web |author=Angelika Langer |url=http://www.angelikalanger.com/GenericsFAQ/JavaGenericsFAQ.html |title=Java Generics FAQs – Frequently Asked Questions – Angelika Langer Training/Consulting |publisher=AngelikaLanger.com |access-date=24 February 2015}}</ref>

{| class="wikitable"
|-
! style="width:50%;"|Java !! style="width:50%;"|C#
|-
| Type checks and downcasts are injected into client code (the code ''referencing'' the generics). Compared to non-generic code with manual casts, these casts will be the same,<ref>{{cite web |author=Angelika Langer |url=http://www.angelikalanger.com/GenericsFAQ/FAQSections/TechnicalDetails.html#FAQ110 |title=Java Generics FAQs – Under The Hood of the Compiler – Angelika Langer Training/Consulting |publisher=AngelikaLanger.com |date=16 April 2013 |access-date=18 August 2013}}</ref> but compared to compile-time verified code that would not need runtime casts and checks, these operations represent a performance overhead.
| C#/.NET generics guarantee type-safety and are verified at compile time, making extra checks/casts are unnecessary at runtime. Hence, generic code will run ''faster'' than non-generic (or type-erased) code that require casts when handling non-generic or type-erased objects.
|-
| Cannot use primitive types as type parameters; instead, the developer must use the wrapper type corresponding to the primitive type. This incurs extra performance overhead by requiring boxing and unboxing conversions as well a memory and garbage collection pressure, as the wrappers will be heap-allocated as opposed to stack-allocated.
| Primitive and value types are allowed as type parameters in generic realizations. At runtime code will be synthesized and compiled for each unique combination of type parameters upon first use. Generics that are realized with primitive/value type do not require boxing/unboxing conversions.
|-
| Generic exceptions are not allowed<ref>{{cite web |author=Angelika Langer |url=http://www.angelikalanger.com/GenericsFAQ/FAQSections/TechnicalDetails.html#FAQ302 |title=Java Generics FAQs – Under The Hood of the Compiler – Angelika Langer Training/Consulting |publisher=AngelikaLanger.com |date=16 April 2013 |access-date=18 August 2013}}</ref> and a type parameter cannot be used in a catch clause<ref>{{cite web |author=Angelika Langer |url=http://www.angelikalanger.com/GenericsFAQ/FAQSections/TechnicalDetails.html#FAQ304 |title=Java Generics FAQs – Under The Hood of the Compiler – Angelika Langer Training/Consulting |publisher=AngelikaLanger.com |date=16 April 2013 |access-date=18 August 2013}}</ref>
| Can both define generic exceptions and use those in catch clauses
|-
| Static members are shared across all generic realizations<ref>{{cite web |author=Angelika Langer |url=http://www.angelikalanger.com/GenericsFAQ/FAQSections/TypeParameters.html |title=Java Generics FAQs – Type Parameters – Angelika Langer Training/Consulting |publisher=AngelikaLanger.com |date=13 February 2014 |access-date=24 February 2015}}</ref> (during type erasure all realizations are folded into a single class)
| Static members are separate for each generic realization. A generic realization is a unique class.
|-
| Type parameters cannot be used in declarations of static fields/methods or in definitions of static inner classes
| No restrictions on use of type parameters
|-
| Cannot create an array where the component type is a generic realization (concrete parameterized type)
<syntaxhighlight lang=Java>
Pair<String, String>[] tenPairs = new Pair[10]; //OK

</syntaxhighlight>
| A generic realization is a 1st class citizen and can be used as any other class; also an array component
<syntaxhighlight lang="csharp">
object tenPairs = new Pair<int, string>[10]; // OK
</syntaxhighlight>
|-
| Cannot create an array where the component type is a type parameter, but it is valid to create an <code>Object</code> array and perform a typecast on the new array to achieve the same effect.
<syntaxhighlight lang="java">
public class Lookup<K, V> {
    public V[] getEmptyValues(K key) {
        return (V[]) new Object[0]; // OK
    }
}
</syntaxhighlight>

When a generic type parameter is under inheritance constraints the constraint type may be used instead of <code>Object</code>
<syntaxhighlight lang=Java>
public class Lookup<K, V extends Comparable<V>> {
    public V[] getEmptyValues(K key) {
        return (V[]) new Comparable[0];
    }
}
</syntaxhighlight>

| Type parameters represent actual, discrete classes and can be used like any other type within the generic definition.
<syntaxhighlight lang="csharp">
public class Lookup<K, V>
{
    public V[] GetEmptyValues(K key)
    {
        return new V[0]; // OK
    }
}
</syntaxhighlight>
|-
| There is no class literal for a concrete realization of a generic type
| A generic realization is an actual class.
|-
| {{mono|instanceof}} is not allowed with type parameters or concrete generic realizations
| The {{mono|is}} and {{mono|as}} operators work the same for type parameters as for any other type.
|-
| Cannot create new instances using a type parameter as the type
| With a constructor constraint, generic methods or methods of generic classes can create instances of classes that have default constructors.
|-
| Type information is erased during compiling. Special extensions to reflection must be used to discover the original type.
| Type information about C# generic types is fully preserved at runtime, and allows full reflection support and instantiation of generic types.
|-
| Reflection cannot be used to construct new generic realizations. During compilation extra code (typecasts) are injected into the ''client'' code of generics. This precludes creating new realizations later.
| Reflection can be used to create new realizations for new combinations of type parameters.
|}

C# allows generics directly for primitive types. Java, instead, allows the use of boxed types as type parameters (e.g., {{java|List<Integer>}} instead of {{csharp|List<int>}}). This comes at a cost since all such values need to be boxed/unboxed when used, and they all need to be heap-allocated. However, a generic type can be specialized with an array type of a primitive type in Java, for example {{java|List<int[]>}} is allowed.<ref name="generics">{{cite web |url=http://www.artima.com/intv/genericsP.html |title=Generics in C#, Java, and C |publisher=Artima.com |access-date=24 February 2015}}</ref>
Several third-party libraries implemented the basic collections in Java with backing primitive arrays to preserve the runtime and memory optimization that primitive types provide.<ref name="trove4j">{{cite web |url=https://bitbucket.org/trove4j/trove |title=trove4j / Trove |access-date=30 June 2017}}</ref>

=== Migration compatibility ===
Java's type erasure design was motivated by a design requirement to achieve ''migration compatibility'' – not to be confused with [[backward compatibility]]. In particular, the original requirement was "''… there should be a clean, demonstrable migration path for the Collections APIs that were introduced in the Java 2 platform''".<ref name="Jcp.org"/> This was designed so that any new generic collections should be passable to methods that expected one of the pre-existing collection classes.<ref>{{cite web |author=Neal Gafter |url=http://gafter.blogspot.com/2004/09/puzzling-through-erasure-answer.html |title=Neal Gafter's blog: Puzzling Through Erasure: answer section |publisher=Gafter.blogspot.com |date=23 September 2004 |access-date=18 August 2013}}</ref>

C# generics were introduced into the language while preserving full backward compatibility, but did not preserve full ''migration compatibility'': Old code (pre C# 2.0) runs unchanged on the new generics-aware runtime without recompilation. As for ''migration compatibility'', new generic collection classes and interfaces were developed that supplemented the non-generic .NET 1.x collections rather than replacing them. In addition to generic collection interfaces, the new generic collection classes implement the non-generic collection interfaces where possible. This prevents the use of new generic collections with pre-existing (non-generic aware) methods, if those methods are coded to use the collection ''classes''.

=== Covariance and contravariance ===
{{Further|Covariance and contravariance (computer science)}}
Covariance and contravariance is supported by both languages. Java has use-site variance that allows a single generic class to declare members using both co- and contravariance. C# has define-site variance for generic interfaces and delegates. Variance is unsupported directly on classes but is supported through their implementation of variant interfaces. C# also has use-site covariance support for methods and delegates.

== Functional programming ==
{| class="wikitable" style="width:80%;"
|-
! style="width:40%;"| [[#Functional programming|Functional programming]] !! style="width:30%;"|Java !! style="width:30%;"|C#
|-
|Method references || {{yes}}<ref name="oracle1"/> || {{yes}}
|-
|[[Closure (computer science)|Closures]] || {{some|All lambdas do not introduce a new level of scope. All referenced variables must be effectively final}} || {{yes}}
|-
|[[Anonymous function|Lambda expressions]] || {{yes}}<ref>{{cite web |url=http://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html |title=Lambda Expressions (The Java Tutorials > Learning the Java Language > Classes and Objects) |publisher=Docs.oracle.com |date=28 February 2012 |access-date=24 February 2015}}</ref> || {{yes}}
|-
|[[Abstract syntax tree|Expression trees]] || {{no}} || {{yes}}
|-
|Generic query language/API || {{yes}}; Java Stream API [[Monad (functional programming)|(Monad)]]<ref>{{cite web |url=https://docs.oracle.com/javase/tutorial/collections/streams/index.html |title=Lesson: Aggregate Operations (The Java Tutorials > Collections) |publisher=Docs.oracle.com |date=28 February 2012 |access-date=24 February 2015}}</ref> || {{yes}}
|-
|Tail recursion compiler optimizations || {{no}}<ref>{{Cite web |url=https://blogs.oracle.com/javamagazine/post/curly-braces-java-recursion-tail-call-optimization |title=Curly Braces #6: Recursion and tail-call optimization |date=2022-11-07 |access-date=2024-07-17 |last=Bruno |first=Eric |archive-url=https://web.archive.org/web/20240717183057/https://blogs.oracle.com/javamagazine/post/curly-braces-java-recursion-tail-call-optimization |archive-date=2024-07-17 |url-status=live}}</ref> || {{some|Only on x64}}<ref>{{cite web |url=http://blogs.msdn.com/b/clrcodegeneration/archive/2009/05/11/tail-call-improvements-in-net-framework-4.aspx |title=Tail Call Improvements in .NET Framework 4 |author=Grant Richins |work=[[MSDN Blogs]] |date=11 May 2009}}</ref>
|}

=== Closures ===
A closure is an inline function that captures variables from its lexical scope.

C# supports closures as anonymous methods or [[Anonymous function#C#lambda expressions|lambda expressions]] with full-featured [[Closure (computer science)|closure]] semantics.<ref>{{cite web |url=http://msdn.microsoft.com/en-ca/magazine/cc301810.aspx | work = MSDN Magazine |title=An Introduction to Delegates |date=April 2001 |access-date =23 December 2008 | last = Richter | first = Jeffrey |author-link = Jeffrey Richter}}</ref><ref>{{cite web |url=http://diditwith.net/PermaLink,guid,235646ae-3476-4893-899d-105e4d48c25b.aspx | work = Did it with .NET |title=What's in a Closure? | last = Campbell | first = Dustin |date=9 February 2007 |access-date=23 December 2008 |archive-url=https://web.archive.org/web/20140815085318/http://diditwith.net/PermaLink,guid,235646ae-3476-4893-899d-105e4d48c25b.aspx |archive-date=15 August 2014 |url-status=dead |df=dmy-all}}</ref>

In Java, anonymous inner classes will remain the preferred way to emulate closures until Java 8 has become the new standard. This is a more verbose construction. This approach also has some differences compared to real closures, notably more controlled access to variables from the enclosing scopes: only final members can be referenced. Java 8, however introduces lambdas that fully inherit the current scope and, in fact, do not introduce a new scope.

When a reference to a method can be passed around for later execution, a problem arises about what to do when the method has references to variables/parameters in its lexical scope. C# closures can access any variable/parameter from its lexical scope. In Java's anonymous inner classes, only references to final members of the lexical scope are allowed, thus requiring the developer to mark which variables to make available, and in what state (possibly requiring boxing).

===Lambdas and expression trees===
C# and Java feature a special type of in-line [[Closure (computer science)|closures]] called [[Anonymous function|lambdas]]. These are anonymous methods: they have a signature and a body, but no name. They are mainly used to specify local function-valued arguments in calls to other methods, a technique mainly associated with [[functional programming]].

C#, unlike Java, allows the use of lambda functions as a way to define special data structures called expression trees. Whether they are seen as an executable function or as a data structure depends on compiler [[type inference]] and what type of variable or parameter they are assigned or cast to. Lambdas and expression trees play key roles in [[Language Integrated Query]] (LINQ).

==Metadata==
{| class="wikitable" style="width:80%;"
|-
! style="width:40%;"| [[Metadata]] !! style="width:30%;"|Java !! style="width:30%;"|C#
|-
|Metadata annotations/attributes || {{yes|Interface based}}; user-defined annotations can be created<ref>{{cite web |url=http://www.25hoursaday.com/ |title=A Comparison of Microsoft's C# Programming Language to Sun Microsystems' Java Programming Language: Metadata Annotations |author=Dare Obasanjo |year=2007 |publisher=Dare Obasanjo |archive-url=https://web.archive.org/web/20120919093308/http://25hoursaday.com/ |archive-date=19 September 2012 |quote=However a key difference between C# attributes and Java annotations is that one can create meta-annotations (i.e., annotations on annotations) in Java but can not do the same in C#. Developers can create their own custom annotations by creating an annotation type that is similar to an interface except that the keyword @interface is used to define it. |access-date=6 September 2012 |url-status=dead |df=dmy-all}}</ref> || {{yes|Class based}}
|-
|Positional arguments || {{no}}; unless a single argument || {{yes}}
|-
|Named arguments || {{yes}} || {{yes}}
|-
|Default values || {{yes|At definition}} || {{yes|Through initialization}}
|-
|Nested types || {{yes}} || {{yes}}
|-
|Specialization || {{no}} || {{yes}}
|-
|Conditional metadata || {{no}} || {{yes}}
|}

== Preprocessing, compilation and packaging ==
{| class="wikitable" style="width:80%;"
|-
! style="width:40%;"| [[Preprocessor|Preprocessing]], [[Compiler|compiling]] and [[Modular programming|packaging]] !! style="width:30%;"|Java !! style="width:30%;"|C#
|-
|[[Namespaces]] || {{yes|Packages}} || {{yes|Namespaces}}
|-
|File contents || {{no|Restricted}} || {{yes|Free}}
|-
|Packaging || {{yes|Package}} || {{yes|public/internal visibility on namespace members, which the build system translates to modules and assemblies at the CLR-level}}
|-
|Classes/assembly search path || {{partial|ClassPath}} || {{yes|Both compile-time and runtime}}<ref>{{cite web |url=http://msdn.microsoft.com/en-us/library/823z9h8w.aspx |title=Element |publisher=Msdn.microsoft.com |access-date=18 August 2013}}</ref><ref>{{cite web |url=http://www.vcskicks.com/csharp_assembly.php |title=C# Assembly – Custom Reference Path – Visual C# Kicks |publisher=Vcskicks.com |access-date=18 August 2013}}</ref>
|-
|Conditional compilation || {{no}}; but see Apache Ant<ref>{{cite web |url=https://weblogs.java.net/blog/schaefa/archive/2005/01/how_to_do_condi.html |title=How to do Conditional Compilation with Java |publisher=weblogs.java.net |access-date=11 August 2015 |archive-url=https://web.archive.org/web/20130105043626/http://weblogs.java.net/blog/schaefa/archive/2005/01/how_to_do_condi.html |archive-date=5 January 2013 |url-status=dead |df=dmy-all}}</ref> || {{yes}}
|-
|Custom errors/warnings || {{yes}}; AnnotationProcessor || {{yes}}
|-
|Explicit regions || {{no}} || {{yes}}
|}

=== Namespaces and file contents ===
In C#, [[namespace]]s are similar to those in [[C++]]. Unlike [[Java package|package]] names in Java, a namespace is not in any way tied to the location of the source file. While it is not strictly necessary for a Java source file location to mirror its package directory structure, it is the conventional organization.

Both languages allow importing of classes (e.g., {{code|import java.util.*|java}} in Java), allowing a class to be referenced using only its name. Sometimes classes with the same name exist in multiple namespaces or packages. Such classes can be referenced by using fully qualified names, or by importing only selected classes with different names. To do this, Java allows importing a single class (e.g., {{code|import java.util.List|java}}). C# allows importing classes under a new local name using the following syntax: {{code|1=using Console = System.Console|2=csharp}}. It also allows importing specializations of classes in the form of {{code|1=using IntList = System.Collections.Generic.List<int>|2=csharp}}.

Both languages have a [[static import]] syntax that allows using the short name of some or all of the static methods/fields in a class (e.g., allowing {{code|foo(bar)}} where {{code|foo()}} can be statically imported from another class). C# has a static class syntax (not to be confused with static inner classes in Java), which restricts a class to only contain static methods. C# 3.0 introduces [[extension method]]s to allow users to statically add a method to a type (e.g., allowing {{code|foo.bar()}} where {{code|bar()}} can be an imported extension method working on the type of {{mono|foo}}).

The [[Sun Microsystems]] Java compiler requires that a source file name must match the only public class inside it, while C# allows multiple public classes in the same file, and puts no restrictions on the file name. C# 2.0 and later allows splitting a class definition into several files by using the {{mono|partial}} keyword in the source code. In Java, a public class will always be in its own source file. In C#, source code files and logical units separation are not tightly related.

=== Conditional compilation ===
Unlike Java, C# implements [[conditional compilation]] using [[preprocessor directive]]s. It also provides a {{mono|Conditional}} [[Annotation|attribute]] to define methods that are only called when a given compilation constant is defined. This way, [[Assertion (computing)|assertions]] can be provided as a framework feature with the method {{code|Debug.Assert()}}, which is only evaluated when the {{mono|DEBUG}} constant is defined. Since version 1.4, Java provides a language feature for assertions, which are turned off at runtime by default but can be enabled using the {{code|-enableassertions}} or {{code|-ea}} switch when invoking the JVM.

== Threading and asynchronous features ==
Both languages include [[Thread (computing)|thread]] [[synchronization]] mechanisms as part of their language syntax.

{| class="wikitable" style="width:80%;"
|-
! style="width:40%;"| [[Thread (computer science)|Threading]] and [[Synchronization (computer science)|Synchronization]] !! style="width:30%;"|Java !! style="width:30%;"|C#
|-
|Threads || {{yes}} || {{yes}}
|-
|[[Thread pool pattern|Thread pool]] || {{yes}} || {{yes}}
|-
|Task-based parallelism || {{yes}}<ref>Fork-join framework included with Java version 7. {{cite web |url=http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/ForkJoinPool.html |title=ForkJoinPool (Java Platform SE 7 ) |publisher=Oracle |access-date=17 July 2015}}</ref> || {{yes}}<ref>{{cite web |url=http://msdn.microsoft.com/en-us/library/dd460717.aspx |title=Task Parallel Library (TPL) |publisher=Msdn.microsoft.com |date=18 February 2015 |access-date=24 February 2015}}</ref>
|-
|[[Semaphore (programming)|Semaphores]] || {{yes}} || {{yes}}
|-
|[[Monitor (synchronization)|Monitors]] || {{yes}} || {{yes}}
|-
|Thread-local variables || {{yes}} || {{yes}}; {{mono|ThreadStaticAttribute}} and {{code|ThreadLocal<T>}} class
|}

=== Task-based parallelism for C# ===
With .NET Framework 4.0, a new task-based programming model was introduced to replace the existing event-based asynchronous model. The API is based around the {{mono|Task}} and {{code|Task<T>}} classes. Tasks can be composed and chained.

By convention, every method that returns a {{mono|Task}} should have its name postfixed with ''Async''.

<syntaxhighlight lang="csharp">
public static class SomeAsyncCode
{
    public static Task<XDocument> GetContentAsync()
    {
        HttpClient httpClient = new HttpClient();
        return httpClient.GetStringAsync("www.contoso.com").ContinueWith((task) => {
            string responseBodyAsText = task.Result;
            return XDocument.Parse(responseBodyAsText);
        });
    }
}

var t = SomeAsyncCode.GetContentAsync().ContinueWith((task) => {
    var xmlDocument = task.Result;
});

t.Start();

</syntaxhighlight>

In C# 5 a set of language and compiler extensions was introduced to make it easier to work with the task model. These language extensions included the notion of {{mono|async}} methods and the {{mono|await}} statement that make the program flow appear synchronous.

<syntaxhighlight lang="csharp">
public static class SomeAsyncCode
{
    public static async Task<XDocument> GetContentAsync()
    {
        HttpClient httpClient = new HttpClient();
        string responseBodyAsText = await httpClient.GetStringAsync("www.contoso.com");
        return XDocument.Parse(responseBodyAsText);
    }
}

var xmlDocument = await SomeAsyncCode.GetContentAsync();

// The Task will be started on call with await.

</syntaxhighlight>

From this [[syntactic sugar]] the C# compiler generates a state-machine that handles the necessary continuations without developers having to think about it.

=== Task-based parallelism for Java ===
Java supports threads since JDK 1.0. Java offers a high versatility for running threads, often called tasks. This is done by implementing a functional interface (a {{Javadoc:SE|package=java.lang|java/lang|Runnable}} interface) defining a single void no-args method as demonstrated in the following example:
<syntaxhighlight lang="Java" line>
var myThread = new Thread(() -> {
    var threadName = Thread.currentThread().getName();
    System.out.println("Hello " + threadName);
});

myThread.start();
</syntaxhighlight>

Similar to C#, Java has a higher level mechanism for working with threads. {{mono|Executors}} can execute asynchronous tasks and also manage a group of subprocesses. All the threads of an {{mono|ExecutorServices}} instance are handled in a [[Pool (computer science)|pool]]. This {{mono|ExecutorService}} instance will be reused under the hood for revenant tasks, so it's possible runs as many concurrent tasks as the programmer wants throughout the life-cycle of the application using a single executor service instance.

This is how the first thread-example looks using executors:
<syntaxhighlight lang="Java" line>
ExecutorService executor = Executors.newSingleThreadExecutor();

executor.submit(() -> {
    var threadName = Thread.currentThread().getName();
    System.out.println("Hello " + threadName);
});
</syntaxhighlight>

The {{mono|ExecutorService}} instance also supports a {{mono|Callable}} interface, another single method interface like {{mono|Runnable}} but the signature of the contained method of {{mono|Callable}} returns a value. In this way, the lambda expression must also return a value, like the below example of calling a website asynchronously as the C# example.
<syntaxhighlight lang="Java" line>
ExecutorService executor = Executors.newSingleThreadExecutor();

Future<String> contentAsync = executor.submit(() -> {           
    HttpRequest httpReq = HttpRequest.newBuilder()
        .uri(new URI("www.graalvm.org"))
        .build();
            
    return HttpClient.newHttpClient()
        .send(httpReq, BodyHandlers.ofString())
        .body();
});
   
var webPageResult = contentAsync.get();
</syntaxhighlight>
Calling the method {{code|get()}} blocks the current thread and waits until the callable completes before returning the value (in the example, a web page content):

The following example, a method and a class are used. This wrap it's just to be similar to the C# example since Java does not have keywords like async for the method signature.
<syntaxhighlight lang="Java" line>
public static class SomeAsyncCode {

    static ExecutorService executor = Executors.newSingleThreadExecutor();

    public static Future<String> getContentAsync(){
        return executor.submit(() -> {           
            HttpRequest httpReq = HttpRequest.newBuilder()
                .uri(new URI("www.graalvm.org"))
                .build();
            return HttpClient.newHttpClient()
                .send(httpReq, BodyHandlers.ofString())
                .body();
        });
    }
}

var webPageResult = SomeAsyncCode.getContentAsync().get();
</syntaxhighlight>

==Additional features==
===Numeric applications===
To adequately support applications in the field of mathematical and financial computation, several language features exist.<ref name="computation">{{cite web |url=http://www.pds.ewi.tudelft.nl/pubs/papers/scicomp01.pdf |title=Java for Scientific Computation : Prospects and Problems |publisher=Pds.ewi.tudelft.nl |access-date=24 February 2015 |archive-url=https://web.archive.org/web/20070922004052/http://www.pds.ewi.tudelft.nl/pubs/papers/scicomp01.pdf |archive-date=22 September 2007 |url-status=dead |df=dmy-all}}</ref>

Java's [[strictfp]] keyword enables strict floating-point calculations for a region of code. Strict floating-point calculations require that even if a platform offers higher precision during calculations, intermediate results must be converted to single/double. This ensures that strict floating-point calculations return exactly the same result on all platforms. Without strict floating-point, a platform implementation is free to use higher precision for intermediate results during calculation. C# allows an implementation for a given hardware architecture to always use a higher precision for intermediate results if available, i.e. C# does not allow the programmer to optionally force intermediate results to use the potential lower precision of single/double.<ref>{{cite web |title=C# Language Specification Version 5.0 |url=http://www.microsoft.com/en-us/download/details.aspx?id=7029 |quote=Floating-point operations may be performed with higher precision than the result type of the operation. For example, some hardware architectures support an "extended" or "long double" floating-point type with greater range and precision than the double type, and implicitly perform all floating-point operations using this higher precision type. Only at excessive cost in performance can such hardware architectures be made to perform floating-point operations with ''less'' precision, and rather than require an implementation to forfeit both performance and precision, C# allows a higher precision type to be used for all floating-point operations. Other than delivering more precise results, this rarely has any measurable effects. However, in expressions of the form x*y/z, where the multiplication produces a result that is outside the double range, but the subsequent division brings the temporary result back into the double range, the fact that the expression is evaluated in a higher range format may cause a finite result to be produced instead of an infinity. |publisher=Microsoft |access-date=28 October 2013 |at=4.1.6 Floating point types}}</ref>

Although Java's floating-point arithmetic is largely based on IEEE 754 (Standard for Binary Floating-Point Arithmetic), certain features are unsupported even when using the strictfp modifier, such as Exception Flags and Directed Roundings, abilities mandated by IEEE Standard 754 (see [[Criticism of Java#Floating point arithmetic|Criticism of Java, Floating point arithmetic]]).

C# provides a built-in decimal type,<ref>{{cite web |title=decimal vs. 110 |url=http://msdn.microsoft.com/en-us/library/system.decimalv=vs.110.aspx |access-date=24 February 2015}}{{dead link |date=June 2016|bot=medic}}{{cbignore|bot=medic}}</ref> which has higher precision (but less range) than the Java/C# double. The decimal type is a 128-bit data type suitable for financial and monetary calculations. The decimal type can represent values ranging from 1.0 × 10<sup>−28</sup> to approximately 7.9 × 10<sup>28</sup> with 28–29 significant digits.<ref>{{cite web |title=C# Language Specification Version 5.0 |url=http://www.microsoft.com/en-us/download/details.aspx?id=7029 |publisher=Microsoft | at=4.1.7 The decimal type}}</ref> The structure uses C# operator overloading so that decimals can be manipulated using operators such as {{mono|+}}, {{mono|-}}, {{mono|*}} and {{mono|/}}, like other primitive data types.

The {{Javadoc:SE|java/math|BigDecimal}} and {{Javadoc:SE|java/math|BigInteger}} types provided with Java allow arbitrary-precision representation of decimal numbers and integer numbers, respectively. Java standard library does not have classes to deal with complex numbers.

The {{csharp|BigInteger}},<ref name="microsoft1"/> and {{csharp|Complex}}<ref>{{cite web |title=Complex |url=http://msdn.microsoft.com/en-us/library/system.numerics.complexv=vs.110.aspx |access-date=24 February 2015}}{{dead link |date=June 2016|bot=medic}}{{cbignore|bot=medic}}</ref> types provided with C# allow representation and manipulation of arbitrary-precision integers and complex numbers, respectively. The structures use C# operator overloading so that instances can be manipulated using operators such as {{mono|+}}, {{mono|-}}, {{mono|*}}, and {{mono|/}}, like other primitive data types. C# standard library does not have classes to deal with arbitrary-precision floating point numbers (see [[Arbitrary-precision arithmetic#Arbitrary-precision software|software for arbitrary-precision arithmetic]]).

C# can help mathematical applications with the {{csharp|checked}} and {{csharp|unchecked}} operators that allow the enabling or disabling of run-time checking for [[arithmetic overflow]] for a region of code.

=== Language integrated query (LINQ) ===
{{Further|Language Integrated Query}}
C#s [[Language Integrated Query]] (LINQ) is a set of features designed to work together to allow in-language querying abilities and is a distinguishing feature between C# and Java.

LINQ consists of these features:
* Extension methods allow existing interfaces or classes to be extended with new methods. Implementations can be shared or an interface can have a dedicated implementation.
* Lambdas allow for expression of criteria in a functional fashion.
* Expression trees allow a specific implementation to capture a lambda as an [[abstract syntax tree]] rather than an executable block. This can be utilized by implementations to represent criteria in a different language, e.g. in the form of an SQL where clause as is the case with e.g. [[Language Integrated Query|Linq, LINQ to SQL]].
* Anonymous types and type inference supports capturing and working with the result type of a query. A query may both join and project over query sources that may lead to a result type that cannot be named.
* Query expressions to support a syntax familiar to [[SQL]] users.
* Nullable (lifted) types to allow for a better match with query providers that support nullable types, like e.g. [[SQL]].

=== Native interoperability ===
{| class="wikitable" style="width:80%;"
|-
! style="width:40%;"| Native interoperability !! style="width:30%;"|Java !! style="width:30%;"|C#
|-
|[[Cross-language interoperability]] || {{yes}} (with [[GraalVM]], [[Nashorn (JavaScript engine)|Nashorn]], [[CORBA]], [[JNI]] or [[Java Native Access|JNA]])<ref name="cross-plattform" /> || {{yes}}; C# was designed for it<ref name="cross-plattform">{{cite web |url=http://www.25hoursaday.com/ |title=A Comparison of Microsoft's C# Programming Language to Sun Microsystems' Java Programming Language: C. An Ever So Slight Feeling of Dèjà Vu: 15. Cross Language Interoperability |author=Dare Obasanjo |year=2007 |publisher=Dare Obasanjo |archive-url=https://web.archive.org/web/20120919093308/http://25hoursaday.com/ |archive-date=19 September 2012 |quote=There are a number of ways cross language interoperability works in Java. First of all, there is the Java Native Interface (JNI) … Java also has the ability to interact with distributed objects that use the common object request broker architecture (CORBA) via Java IDL. … C# and the .NET runtime were created with seamless cross-language interoperability as a design goal. |access-date=10 September 2012 |url-status=dead |df=dmy-all}}</ref>
|-
|External/native methods || {{yes}} || {{yes}}
|-
|[[Marshalling (computer science)|Marshalling]] || {{no|External glue code needed}} || {{yes}}; metadata controlled
|-
|[[Pointer (computer programming)|Pointers]] and arithmetics || {{no}}; but see [http://mishadoff.com/blog/java-magic-part-4-sun-dot-misc-dot-unsafe/ sun.misc.Unsafe] || {{yes}}
|-
|Native types || {{yes}}<ref>{{cite web |url=https://docs.oracle.com/javase/8/docs/technotes/guides/jni/spec/types.html |title=JNI Types and Data Structures |publisher=Docs.oracle.com |access-date=9 April 2020}}</ref> || {{yes}}
|-
|Fixed-size buffers || {{no}} || {{yes}}
|-
|Explicit stack allocation || {{no}} || {{yes}}
|-
|Address-of || {{no}} || {{yes}}
|-
|[[Object pinning#Moving vs. non-moving|Object pinning (fix variable to address)]] || {{no}} || {{yes}}
|-
|Function pointers || {{no}} || {{yes}}<ref>{{cite web |url=https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-9#performance-and-interop |title=Function pointers in C# 9 |publisher=docs.microsoft.com |access-date=27 February 2021}}</ref>
|-
|Unions || {{no}} || {{yes}}<ref>{{cite web |url=https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/attributes/how-to-create-a-c-cpp-union-by-using-attributes |title=Creating C/C++ unions in C# |publisher=docs.microsoft.com |access-date=27 February 2021}}</ref>
|}

The [[Java Native Interface]] (JNI) feature allows Java programs to call non-Java code. However, JNI does require the code being called to follow several conventions and imposes restrictions on types and names used. This means that an extra adaption layer between legacy code and Java is often needed. This adaption code must be coded in a non-Java language, often C or C++. [[Java Native Access]] (JNA) allows easier calling of native code that only requires writing Java code, but comes at a performance cost.

In addition, third party [[Library (computing)|libraries]] provide Java-[[Component Object Model]] (COM) bridging, e.g., JACOB ([[Free software|free]]), and J-Integra for COM ([[Proprietary software|proprietary]]).

.NET Platform Invoke ([[Platform Invocation Services|P/Invoke]]) offers the same ability by allowing calls from C# to what Microsoft terms un[[managed code]]. Through metadata attributes the programmer can control exactly how the parameters and results are [[Marshalling (computer science)|marshalled]], thus avoiding the external glue code needed by the equivalent JNI in Java. P/Invoke allows almost complete access to procedural APIs (such as Win32 or POSIX), but limited access to C++ class libraries.

In addition, .NET Framework also provides a .NET-COM bridge, allowing access to COM components as, if they were first-class .NET objects.

C# also allows the programmer to disable the normal type-checking and other safety features of the [[Common Language Runtime|CLR]], which then enables the use of [[Pointer (computer programming)|pointer variables]]. When using this feature, the programmer must mark the code using the {{mono|unsafe}} keyword. JNI, P/Invoke, and "unsafe" code are equally risky features, exposing possible security holes and application instability. An advantage of unsafe, managed code over P/Invoke or JNI is that it allows the programmer to continue to work in the familiar C# environment to accomplish some tasks that otherwise would require calling out to unmanaged code. An assembly (program or library) using unsafe code must be compiled with a special switch and will be marked as such. This enables runtime environments to take special precautions before executing potentially harmful code.

=== Runtime environments ===
Java (the programming language) is designed to execute on the Java platform via the [[Java Runtime Environment]] (JRE). The Java platform includes the [[Java virtual machine]] (JVM) and a common set of libraries. The JRE was originally designed to support interpreted execution with final compiling as an option. Most JRE environments execute fully or at least partially compiled programs, possibly with [[adaptive optimization]]. The Java compiler produces [[Java bytecode]]. Upon execution the bytecode is loaded by the Java runtime and either interpreted directly or compiled to machine instructions and then executed. {{Further|Java Runtime Environment}}

C# is designed to execute on the [[Common Language Runtime]] (CLR). The CLR is designed to execute fully compiled code. The C# compiler produces [[Common Intermediate Language]] instructions. Upon execution the runtime loads this code and compiles to machine instructions on the target architecture. {{Further|Common Language Runtime}}

== Examples ==
=== Input/output ===
Example illustrating how to copy text one line at a time from one file to another, using both languages.
{| class="wikitable"
|-
! Java
! C#
|-
|valign=top|<syntaxhighlight lang="Java" style="font-size:90%">
import java.nio.file.*;

class FileIOTest {

    public static void main(String[] args) throws Exception {
        var lines = Files.readAllLines(Paths.get("input.txt"));
        Files.write(Paths.get("output.txt"), lines);
    }
}
</syntaxhighlight>
|valign=top|<syntaxhighlight lang="csharp" style="font-size:90%">
using System.IO;

class FileIOTest
{
    public static void Main(string[] args)
    {
        var lines = File.ReadLines("input.txt");
        File.WriteAllLines("output.txt", lines);
    }
}
</syntaxhighlight>
|-
|valign=top|Notes on the Java implementation:
* {{code|Files.readAllLines}} method returns a List of String, with the content of the text file, Files has also the method {{mono|readAllBytes}}, returns an array of {{mono|Strings}}.
* {{code|Files.write}} method writes byte array or into an output file, indicated by a Path object.
* {{code|Files.write}} method also takes care of buffering and closing the output stream.

|valign=top|Notes on the C# implementation:
* The {{mono|ReadLines}} method returns an enumerable object that upon enumeration will read the file one line at a time.
* The {{mono|WriteAllLines}} method takes an enumerable and retrieves a line at a time and writes it until the enumeration ends.
* The underlying reader will automatically allocate a buffer, thus there is no need to explicitly introduce a buffered stream.
* {{mono|WriteAllLines}} automatically closes the output stream, also in the case of an abnormal termination.
|}

=== Integration of library-defined types ===
C# allows library-defined types to be integrated with existing types and operators by using custom implicit/explicit conversions and operator overloading as illustrated by the following example:
{| style="width:100%;" class="wikitable"
|-
! style="width:50%;"|Java !! style="width:50%;"| C#
|-
|
<syntaxhighlight lang=Java style="font-size:90%">
var bigNumber =
    new BigInteger("123456789012345678901234567890");

var answer = bigNumber.multiply(BigInteger.valueOf(42));
var square = bigNumber.sqrt();
var sum = bigNumber.add(bigNumber);
</syntaxhighlight>
|
<syntaxhighlight lang="csharp" style="font-size:90%">
var bigNumber =
    BigInteger.Parse("123456789012345678901234567890");

var answer = bigNumber * 42;
var square = bigNumber * bigNumber;
var sum = bigNumber + bigNumber;
</syntaxhighlight>
|}

=== C# delegates and equivalent Java constructs ===
{| style="width:100%;" class="wikitable"
|-
! style="width:50%;"| Java !! style="width:50%;"| C#
|- valign="top"
|
<syntaxhighlight lang=Java style="font-size:90%">
// a target class
class Target {
    public boolean targetMethod(String arg) {
        // do something
        return true;
    }
}

// usage
void doSomething() {
    // construct a target with the target method
    var target = new Target();

    // capture the method reference
    Function<String, Boolean> ivk = target::targetMethod;

    // invokes the referenced method
    var result = ivk.apply("argumentstring");
}
</syntaxhighlight>
|<!-- This is Visual Studio Default Style. C# is generally GNU not Ritchie -->
<syntaxhighlight lang="csharp" style="font-size:90%">
    // a target class
    class Target
    {
        public bool TargetMethod(string arg)
        {
            // do something
            return true;
        }
    }

    // usage
    void DoSomething()
    {
        // construct a target with the target method
        var target = new Target();

        // capture the delegate for later invocation
        Func<string, bool> dlg = target.TargetMethod;

        // invoke the delegate
        bool result = dlg("argumentstring");
    }
</syntaxhighlight>
|}

=== Type lifting ===
{| style="width:100%;" class="wikitable"
|-
! style="width:50%;"| Java !! style="width:50%;"| C#
|- valign="top"
|
Java doesn't have this feature, although a similar effect is possible with the {{mono|Optional}} class
<syntaxhighlight lang="java">
var a = Optional.of(42);
var b = Optional.<Integer>empty();

var c = a.flatMap(aa -> b.map(bb -> aa * bb));
</syntaxhighlight>
|<!-- This is Visual Studio Default Style. C# is generally GNU not Ritchie -->
<syntaxhighlight lang="csharp">
int? a = 42;
int? b = null;

// c will receive the null value
// because*is lifted and one of the operands are null
int? c = a * b;
</syntaxhighlight>
|}

===Interoperability with dynamic languages===
This example illustrates how Java and C# can be used to create and invoke an instance of class that is implemented in another programming language. The "Deepthought" class is implemented using the [[Ruby (programming language)|Ruby programming language]] and represents a simple calculator that will multiply two input values ({{mono|a}} and {{mono|b}}) when the {{mono|Calculate}} method is invoked. In addition to the conventional way, Java has [[GraalVM]], a virtual machine capable to run any implemented programming language.
{| style="width:100%; border:none;" class="wikitable"
|-
!width=50%|Java
!width=50%|C#
|-
|valign=top|

====Using GraalVM====
<syntaxhighlight lang=Java style="font-size:90%">
Context polyglot = Context.newBuilder().allowAllAccess(true).build();

//Ruby
Value rubyArray = polyglot.eval("ruby", "[1,2,42,4]");
int rubyResult = rubyArray.getArrayElement(2).asInt();

//Python
Value pythonArray = polyglot.eval("python", "[1,2,42,4]");
int pythonResult = pythonArray.getArrayElement(2).asInt();

//JavaScript
Value jsArray = polyglot.eval("js", "[1,2,42,4]");
int jsResult = jsArray.getArrayElement(2).asInt();

//R
Value rArray = polyglot.eval("R", "c(1,2,42,4)");
int rResult = rArray.getArrayElement(2).asInt();

//LLVM (in this case C, but could be C++, Go, Basic, etc...)
Source source = Source.newBuilder("llvm", new File("C_Program.bc")).build();
Value cpart = polyglot.eval(source);
cpart.getMember("main").execute();
</syntaxhighlight>

====Traditional way====
<syntaxhighlight lang="java" style="font-size:90%">
// Initialize the engine
var invocable = new ScriptEngineManager().getEngineByName("jruby");
var rubyFile = new FileReader("Deepthought.rb");
engine.eval(fr);
</syntaxhighlight>

<syntaxhighlight lang="java" style="font-size:90%">
// create a new instance of "Deepthought" calculator
var calcClass = engine.eval("Deepthought");
var calc = invocable.invokeMethod(calcClass, "new");

// set calculator input values
invocable.invokeMethod(calc, "a=", 6);
invocable.invokeMethod(calc, "b=", 7);

// calculate the result
var answer = invocable.invokeMethod(calc, "Calculate");
</syntaxhighlight>

|valign=top|<syntaxhighlight lang="csharp" style="font-size:90%">
// Initialize the engine

var runtime = ScriptRuntime.CreateFromConfiguration();
dynamic globals = runtime.Globals;

runtime.ExecuteFile("Deepthought.rb");
</syntaxhighlight>

<syntaxhighlight lang="csharp" style="font-size:90%">
// create a new instance of "Deepthought" calculator
var calc = globals.Deepthought.@new();

// set calculator input values
calc.a = 6;
calc.b = 7;

// calculate the result
var answer = calc.Calculate();
</syntaxhighlight>

|- valign=top
|
Notes for the Java implementation:
* Ruby accessors names are generated from the attribute name with a {{code|{{=}}}} suffix. When assigning values, Java developers must use the Ruby accessor method name.
* Dynamic objects from a foreign language are not first-class objects in that they must be manipulated through an API.
|
Notes for the C# implementation:
* Objects returned from properties or methods of {{mono|dynamic}} objects are themselves of {{mono|dynamic}} type. When type inference (the {{mono|var}} keyword) is used, the variables calc and answer are inferred dynamic/late-bound.
* Dynamic, late-bounds objects are first-class citizens that can be manipulated using C# syntax even though they have been created by an external language.
*{{mono|new}} is a reserved word. The {{code|@}} prefix allows keywords to be used as identifiers.

|}

=== Fibonacci sequence ===
This example illustrates how the [[Fibonacci sequence]] can be implemented using the two languages. The C# version takes advantage of C# [[#Generator methods|generator methods]]. The Java version takes the advantage of {{mono|Stream}} interface and method references. Both the Java and the C# examples use [[K&R style]] for code formatting of classes, methods and statements.

{| style="width:100%; border:none;" class="wikitable"
|-
!Java
!C#
|-
|width=50%|<syntaxhighlight lang=Java style="font-size:90%">
// The Fibonacci sequence
Stream.generate(new Supplier<Integer>() {
    int a = 0;
    int b = 1;

    public Integer get() {
        int temp = a;
        a = b;
        b = a + temp;
        return temp;
    }
}).limit(10).forEach(System.out::println);
</syntaxhighlight>
|width=50% valign=top|<syntaxhighlight lang="csharp" style="font-size:90%">
// The Fibonacci sequence
public IEnumerable<int> Fibonacci() 
{
    int a = 0;
    int b = 1;

    while (true) 
    {
        yield return a;
        (a, b) = (b, a + b);
    }
}
</syntaxhighlight>
|-
|width=50%|
|width=50% valign=top|<syntaxhighlight lang="csharp" style="font-size:90%">
// print the 10 first Fibonacci numbers
foreach (var it in Fibonacci().Take(10)) 
{
    Console.WriteLine(it);
}
</syntaxhighlight>
|- valign="top"
|Notes for the Java version:
* The Java 8 Stream interface is a sequence of elements supporting sequential and parallel aggregate operations.
* The generate method returns an infinite sequential unordered stream where each element is generated by the provided Supplier.
* The limit method returns a stream consisting of the elements of this stream, truncated to be no longer than maxSize in length.
* The forEach method performs an action for each element of this stream, this action could be a lambda or a method reference.

====Using a foreach====
The same example above, but using a method returning an Iterable to maintain greater similarity with the C# example. Anything that implements the iterable interface can be iterated in a foreach.
<syntaxhighlight lang="java" style="font-size:90%">
Iterable<Integer> fibonacci(int limit) {
    return Stream.generate(new Supplier<Integer>() {
        int a = 0;
        int b = 1;
        
        public Integer get() {
            int temp = a;
            a = b;
            b = a + temp;
            return temp;
        }
    }).limit(limit)::iterator;
}
</syntaxhighlight> 
       
<syntaxhighlight lang="java" style="font-size:90%">
// print the 10 first Fibonacci numbers
for(int it: fibonacci(10)) {
    System.out.println(it);
}
</syntaxhighlight>

The most common way to do the example above would be to use Streams, not Iterables. This could be returned from a method like the C# example, but it's unnecessary and could be used directly by just collecting the Stream.

Below is an example using Streams and the collecting the Stream calling {{mono|toList}} in the foreach block.
<syntaxhighlight lang="java" style="font-size:90%">
var fibonacci = Stream.generate(new Supplier<Integer>() {
    int a = 0;
    int b = 1;
            
    public Integer get() {
        int temp = a;
        a = b;
        b = a + temp;
        return temp;
    }
});
</syntaxhighlight>

<syntaxhighlight lang="java" style="font-size:90%">
// print the 10 first Fibonacci numbers
for(int it: fibonacci.limit(10).toList()) {
    System.out.println(it);
}
</syntaxhighlight>

In addition to the toList collector in the foreach block, It's important to highlight that there are more collectors for every type of collection. Also, custom collectors could be created by implementing the {{mono|Collector}} interface or describing the implementation as a lambda expression, both cases passing it as arguments to the collect method of the {{mono|Stream}} object. In this example would be just calling the {{mono|collect}} method instead {{mono|toList}} if would have some complex type of object per item for the collection.

Both examples could also be done with {{mono|IntStream}} and {{mono|IntSupplier}} and avoid the {{mono|Integer}} generic in the {{mono|Supplier}} interface implementation, but the generic is used to preserve greater similarity with the C# example.

====Functional Style====
The above algorithm can be written even more consistently, using {{code|Stream.iterate}}. The iterate method receives a seed parameter, and a function that specifies what to do for each iteration. In this case, the seed can be a record class with the 2 initial values of the algorithm, and its respective transformation in each iteration. In short, the iterate method makes unnecessary the implementation of a Supplier.
<syntaxhighlight lang="java" style="font-size:90%">

record Pair(int a, int b) {};

Stream
  .iterate(new Pair(0, 1), p -> new Pair(p.b, p.a + p.b))
  .limit(10)
  .map(p -> p.a)
  .forEach(System.out::println);
</syntaxhighlight>

|Notes for the C# version:
* The method is defined as returning instances of the interface {{csharp|IEnumerable<int>}}, which allows client code to repeatedly request the next number of a sequence.
* The {{csharp|yield}} keyword converts the method into a generator method.
* The {{csharp|yield return}} statement returns the next number of the sequence and creates a continuation so that subsequent invocations of the {{csharp|IEnumerable}} interface's {{csharp|MoveNext}} method will continue execution from the following statement with all local variables intact.
* Tuple-assignment avoids the need to create and use a temporary variable when updating the values of the variables {{mono|a}} and {{mono|b}}.
|}

==See also==
* [[Comparison of C Sharp and Visual Basic .NET|Comparison of C# and VB.NET]]
* [[Comparison of Java and C++]]
* [[Java (programming language)|Java programming language]]

==References==
{{Reflist|30em}}

==External links==
* [http://msdn.microsoft.com/en-us/gg715299.aspx Moving to C# and the .NET Framework] at [[MSDN]]
* [http://msdn.microsoft.com/en-us/library/ms836794.aspx C# and Java: Comparing Programming Languages] at [[MSDN]]
* [http://www.javacamp.org/javavscsharp/ Java vs. C# – Code for Code Comparison]
* [http://www.osnews.com/story.php?news_id=5602 Nine Language Performance Round-up]
* [[Microsoft Developer Network]] (MSDN): [http://msdn.microsoft.com/en-us/library/ms228602.aspx The C# Programming Language for Java Developers]
* [http://www.ecma-international.org/publications/standards/Ecma-334.htm Standard ECMA-334 C# Language specification]
* [http://java.sun.com/docs/books/jls/ Java Language Specification (Sun)]
* [http://www.telerik.com/campaigns/devcraft/the-state-of-c-sharp The State of C#: Is It Still a Viable Language?]

{{.NET}}
{{Java (software platform)}}
{{Common Language Infrastructure}}

{{DEFAULTSORT:C Sharp and Java comparison}}
[[Category:.NET]]
[[Category:C programming language family]]
[[Category:Comparison of individual programming languages]]
[[Category:Java (programming language)]]
<!-- Hidden categories below -->
[[Category:Articles with example C Sharp code]]
[[Category:Articles with example Java code]]