论C#与Java之异同_net开发与java开发区别资源-CSDN文库

Java

5星 · 超过95%的资源需积分: 9 180 浏览量 2009-03-12 23:03:07 上传评论收藏 421KB PDF 举报

资源详情

资源评论

A COMPARISON OF

MICROSOFT'S C# PROGRAMMING LANGUAGE

TO SUN MICROSYSTEMS' JAVA PROGRAMMING

LANGUAGE

Dare Obasanjo

Introduction

The C# language is an object-oriented language that is aimed at enabling programmers to quickly build a wide range of applications for the

Microsoft .NET platform. The goal of C# and the .NET platform is to shorten development time by freeing the developer from worrying about several

low level plumbing issues such as memory management, type safety issues, building low level libraries, array boundschecking , etc. thus allowing

developers to actually spend their time and energy working on their application and business logic instead. As a Java developer the previous sentence

could be described as "a short description of the Java language and platform" if the words C# and the .NET platform were replaced with words Java and

the Java platform.

What follows is an overview of similarities and differences between the language features and libraries of the C# and Java programming languages based

on my experience using both languages. All code snippets below were tested on Microsoft's .NET Framework version 2.0

for C# snippets and Java™

Platform, Standard Edition version 6 for the Java snippets.

Quick Index

A. The More Things Change The More They Stay The Same

This section describes concepts and language features that are almost exactly the same in C# and Java.

1. We Are All Objects

2. Keyword Jumble

3. Of Virtual Machines and Language Runtimes

4. Heap Based Classes and Garbage Collection

5. Arrays Can Be Jagged

6. No Global Methods

7. Interfaces, Yes. Multiple Inheritance, No.

8. Strings Are Immutable

9. Unextendable Classes

10. Throwing and Catching Exceptions

11. Member Initialization at Definition and Static Constructors

12. Boxing

B. The Same But Different

This section describes concepts and language features that differ either only in syntax or in some similarly minor manner between C# and Java.

1. Main Method

2. Inheritance Syntax

3. Run Time Type Identification (is operator)

4. Namespaces

5. Constructors, Destructors and Finalizers

6. Synchronizing Methods and Code Blocks

7. Access Modifiers

8. Reflection

9. Declaring Constants

10. Primitive Types

11. Array Declarations

12. Calling Base Class Constructors and Constructor Chaining

13. Variable Length Parameter Lists

14. Generics

15. for

-each Loop

16. Metadata Annotations

17. Enumerations

C. An Ever So Slight Feeling of Dèjà Vu

This section describes concepts and language features that exist in C# that are similar to those that exist in Java but with a significant difference.

1. Nested classes

2. Threads and Volatile Members

3. Operator Overloading

4. switch Statement

5. Assemblies

6. Collections

7. goto (no longer considered harmful)

8. Virtual Methods (and final ones too)

9. File I/O

10. Object Serialization

11. Documentation Generation from Source Code Comments

12. Multiple Classes in a Single File

13. Importing Libraries

14. Events

15. Cross Language Interoperability

D. Now For Something Completely Different

This section describes language features and concepts that exist in C# and have no Java counterpart.

1. Deterministic Object Cleanup

2. Delegates

3. Value Types (Structs)

4. Run Time Type Identification (as operator)

5. Properties

6. Multidimensional Arrays

7. Indexers

8. Preprocessor Directives

9. Aliases

10. Runtime Code Generation

11. Pointers and Unsafe Code

12. Pass by Reference

13. Verbatim Strings

14. Overflow Detection

15. Explicit Interface Implementation

16. Friend Assemblies

17. The Namespace Qualifier

18. Iterators (Continuations)

19. Partial Types

20. Static Classes

21. Nullable Types

22. Anonymous Methods

E. Wish You Were Here

This section describes language features and concepts that exist in Java and have no C# counterpart.

1. Checked Exceptions

2. Cross Platform Portability (Write Once, Run Anywhere)

3. Extensions

4. strictfp

5. Dynamic

Class Loading

6. Interfaces That Contain Fields

7. Anonymous Inner Classes

8. Static Imports

F. Conclusion(2001)

G. Conclusion (2007)

H. Resources

I. Acknowledgements

The More Things Change The More They Stay The Same

1. We Are All Objects

Just like Java, C# has a single rooted class hierarchy where all classes in C# are subclasses of System.Object the same way all Java classes are

subclasses of

java.lang.Object. The methods of the two languages' Object classes share some similarities (e.g. System.Object's ToString() to

java.lang.Object's toString()) and differences (System.Object does not have analogs to wait(), notify() or notifyAll() in java.lang.Object).

NOTE: In C#, the object class can either be written as object or Object. The lower case "object" is a C# keyword which is replaced with the class

name "System.Object" during compilation.

Keyword Jumble

There are a large number of syntactic similarities between Java and C#, similarly almost every Java keyword has a C# equivalent except for a few

like transient, throws and strictfp. Below is a table of Java and C# keywords with the Java keywords in red while the equivalent C# keywords are

in blue.

keyword

Java

keyword

Java

keyword

Java

keyword

Java

keyword

abstract abstract extern native operator N/A throw throw

as N/A false false out N/A true true

base super finally finally override N/A try try

bool boolean fixed N/A params ... typeof N/A

break break float float partial N/A uint N/A

NOTE: Although goto and const are Java language keywords they are unused in the Java language.

NOTE: The

[NonSerialized] attribute in C# is equivalent to the transient keyword in Java.

Of Virtual Machines and Language Runtimes

Just like Java is typically compiled to Java byte code which then runs in managed execution environment (the Java Virtual Machine or JVM) so

also is C# code compiled to an Intermediate Language (IL) which then runs in the Common Language Runtime (CLR). Both platforms support

native compilation via Just In Time compilers

NOTE: While the Java platform supports interpretation of byte code or byte code being JITed then run natively, the .NET platform only supports

native execution of C# code because the IL code is always natively compiled before running.

Heap Based Classes and Garbage Collection

In Java objects are created on the heap using the new keyword. Most classes in C# are created on the heap by using the new keyword. Also just as

the JVM manages the destruction of objects so also does the CLR via a Mark and Compact garbage collection algorithm

NOTE: C# also supports stack-based classes, called value types, which are discussed further below.

Arrays Can Be Jagged

In languages like C and C++, each subarray of a multidimensional array must have the same dimensions. In Java and C# arrays do not have to be

uniform because jagged arrays can be created as one-dimensional arrays of arrays. In a jagged array the contents of the array are arrays which may

hold instances of a type or references to other arrays. For this reason the rows and columns in a jagged array need not have uniform length as can

be seen from the following code snippet:

int [][]myArray = new int[2][];

myArray[0] = new int[3];

myArray[1] = new int[9];

The above code snippet is valid for both C# and Java.

No Global Methods

Just like Java and unlike C++, methods in C# have to be part of a class either as member or static methods.

Interfaces, Yes. Multiple Inheritance, No

C#, like Java, supports the concept of an interface which is akin to a pure abstract class. Similarly C# and Java both allow only single inheritance

of classes but multiple inheritance (or implementation) of interfaces.

Strings Are Immutable

C# has a System.String class which is analogous to the java.lang.String class. Both classes are immutable meaning that the values of the strings

cannot be changed once the strings have been created. In both instances methods that appear to modify the actual content of a string actually create

a new string to return, leaving the original string unchanged. Thus the following C# and Java code does not modify the string in either case

C# Code

byte N/A for for private private ulong N/A

case case foreach for protected N/A unchecked N/A

catch catch get N/A public public unsafe N/A

char char goto

goto

readonly N/A ushort N/A

checked N/A if if ref N/A using import

class class implicit N/A return return value N/A

const

in N/A sbyte byte virtual N/A

continue continue int int sealed final void void

decimal N/A interface interface set N/A volatile volatile

default default internal protected short short where extends

delegate N/A is instanceof sizeof N/A while while

do do lock synchronized stackalloc N/A yield N/A

double double long long static static : extends

else else namespace package string N/A : implements

enum N/A new new struct N/A N/A strictfp

event N/A null null switch switch N/A throws

explicit N/A object N/A this this N/A

transient

String csString = "Apple Jack";

csString.ToLower(); /* Does not modify string, instead returns lower case copy of string */

Java Code

String jString = "Grapes";

jString.toLowerCase(); /* Does not modify string, instead returns lower case copy of string */

To create a string-like object that allows modification in C# it is advisable to use the System.Text.StringBuilder class whereas in Java one would

use the java.lang.StringBuffer class.

NOTE: In C#, the string class can either be written as

string or String.

Unextendable Classes

Both Java and C# provide mechanisms to specify that a class should be the last one in an inheritance hierarchy and cannot be used as a base class.

In Java this is done by preceding the class declaration with the

final keyword while in C# this is done by preceding the class declaration with the

sealed keyword. Below are examples of classes that cannot be extended in either language

C# Code

sealed class Student {

string fname;

string lname;

int uid;

void attendClass() {}

}

Java Code

final class Student {

String fname;

String lname;

int uid;

void attendClass() {}

}

10. Throwing and Catching Exceptions

Exceptions in C# and Java share a lot of similarities. Both languages support the use of the try block for indicating guarded regions, the catch

block for handling thrown exceptions and the finally block for releasing resources before leaving the method. Both languages have an inheritance

hierarchy where all exceptions are derived from a single Exception class. Exceptions can be caught and rethrown after some error handling occurs

in both languages. Finally, both languages provide a mechanism for wrapping exceptions in one another for cases where a different exception is

rethrown from the one that was caught. An example of using the exception wrapping capability is a three tier application where a SQLException is

thrown during database access but is caught, examined, then an application specific exception is thrown. In this scenario the application specific

exception can be initialized with the original SQLException so handlers of the application specific exception can access the original exception

thrown if needed. Below are two equivalent code samples that show the similarities between exceptions in both languages.

NOTE: Although exceptions in both languages support methods for getting a stack trace, only Java exceptions have methods that allow one to alter

the stack trace.

C# Code

using System;

using System.IO;

class MyException: Exception{

public MyException(string message): base(message){ }

public MyException(string message, Exception innerException):

base(message, innerException){ }

}

public class ExceptionTest {

static void DoStuff(){

throw new FileNotFoundException();

}

public static void Main(string[] args){

try{

DoStuff();

return; //won't get to execute

}catch(IOException ioe){ /* parent of FileNotFoundException */

throw new MyException("MyException occured", ioe); /* rethrow new exception with inner exception specified */

}

}finally{

Console.WriteLine("***Finally block executes even though MyException not caught***");

}

}//Main(string[])

} // ExceptionTest

Java Code

class MyException extends Exception{

public MyException(String message){ super(message); }

public MyException(String message, Exception innerException){ super(message, innerException); }

}

public class ExceptionTest {

static void doStuff(){

throw new ArithmeticException();

}

public static void main(String[] args) throws Exception{

try{

doStuff();

return; //won't get to execute

}catch(RuntimeException re){ /* parent of ArithmeticException */

throw new MyException("MyException occured", re); /* rethrow new exception with cause specified */

}

}finally{

System.out.println("***Finally block executes even though MyException not caught***");

}

}//main(string[])

} // ExceptionTest

11. Member Initialization at Definition and Static Constructors

Instance and static variables can be initialized at their point of definition in both C# and Java. If the member variable is an instance variable, then

initialization occurs just before the constructor is called. Static members are initialized sometime before the first usage of the member and before

the first creation of an instance of the class. It is also possible to specify a block of code that should run before the class is used either via creation

of an instance variable or invocation of a static method. These code blocks are called are called static constructors in C# and static initialization

blocks in Java. Static constructors are invoked before the first invocation of a static method in the class and before the first time an instance of the

class is created.

C# Code

using System;

class StaticInitTest{

string instMember = InitInstance();

string staMember = InitStatic();

StaticInitTest(){

Console.WriteLine("In instance constructor");

}

static StaticInitTest(){

Console.WriteLine("In static constructor");

}

static String InitInstance(){

Console.WriteLine("Initializing instance variable");

return "instance";

}

static String InitStatic(){

Console.WriteLine("Initializing static variable");

return "static";

}

static void DoStuff(){

Console.WriteLine("Invoking static DoStuff() method");

}

public static void Main(string[] args){

剩余53页未读，继续阅读

评论收藏

内容反馈

炫辉

2014-03-19

全英文的看起来有点困难

论C#与Java之异同

评论9

最新资源

论C#与Java之异同

评论9

最新资源

相关推荐

java与C#的相同点与不同点

c#与java异同（绝世之作）

北大青鸟内部资料C#和java

"易语言.飞扬”与 JAVA、C#、C++ 的异同

C#特点详细介绍，与其他语言的区别

浅析C语言和Java语言的异同.pdf

NIIT ISAS C#与JAVA的异同资料及简单ppt

Java比较2个文件的异同

c++与Java的异同

Java与C_C++异同

C#基础理论知识总结

针对Java开发人员的C# 编程语言.pdf

java面试题

几种语言实现公历计算

解析在C#中接口和类的异同

动力节点_Java基础视频教程139_HashTable与HashMap的异同点

Javascript和Java语言有什么关系？两种语言间的异同比较

计算机后端-Java-Java核心基础-第20章 多线程 16. sleep()和wait()的异同.avi

《计算机体系结构—软件篇3》 之 解释器、语言、算法

二十三种设计模式【PDF版】

23个设计模式源码案例.zip

net学习笔记及其他代码应用

Java定时任务schedule和scheduleAtFixedRate的异同

用来熟悉C#中GDI+几种坐标异同的案列

VM-Pro通用化视觉系统框架V1.6

串口侦听 串口监听 不占用串口 不占用串口的监听

net framework4.0和4.5开发包（用于visual studio 2022 安装net旧版本）

【C#源码】TCP+串口通信的调试工具 （源码+教学视频）

计算机后端-Java-Java核心基础-第20章多线程 16. sleep()和wait()的异同.avi

《计算机体系结构—软件篇3》之解释器、语言、算法

串口侦听串口监听不占用串口不占用串口的监听

【C#源码】TCP+串口通信的调试工具（源码+教学视频）