Java学习笔记1------c#和Java的区别

    很多人说C#是微软用来和Java抗衡的武器，因为二者在很大程度上有着惊人的相似，尽管如此，两者不同的地方也很多，所谓“于细微处见差异”。那么两者的相似和区别都在什么地方呢？我们从今天开始，会从各个角度来对比C#和Java的特点，希望能对正在学习、使用C#的朋友有所帮助。

     1、C#和.NET平台的概貌

      2000年6月，微软发布C#语言和.NET平台。C#语言是一种强类型的，面向对象的语言，它具有语法简单、表达力强的特点，而.NET平台则是构成微软的“.NET计划”的基石。

       .NET平台的核心包括两方面，一方面就是著名的通用语言运行机(Common Language Runtime)，虽然这个名词起得晦涩了点，不过大家可以拿它和Java的虚拟机来作比较，二者完成的任务大致相同；另一方面就是一大堆通用函数库，这些库函数可以被多种语言调用，并且通过编译都产生一种共同的中间语言（Intermediate  Language），这种语言也可以拿Java的字节码来类比，虽然完成的方式有些不一样。

     2、C#和Java

      下面简单地把C#和Java的相似处列出来，虽然在这里我们重点讨论的是C#和Java的不同点，但是了解一下二者的相同之处也是很有必要的。

       二者都编译成跨平台的、跨语言的代码，并且代码只能在一个受控制的环境中运行

        自动回收垃圾内存，并且消除了指针（在C#中可以使用指针，不过必须注明unsafe关键字）

        都不需要头文件，所有的代码都被“包(package)”限制在某个范围内，并且因为没有头文件，所以消除了类定义的循环依赖

         所有的类都是从对象派生出来，并且必须使用New关键字分配内存

         用对象加锁的方式来支持多线程

          都具有接口(interface)的概念

            内部类

            　　继承类的时候不会以某种特定的访问权限来继承；

            　　没有全局函数或者常量，一切必须属于类；

            　　数组或者字符串都自带长度计算和边界检查；

            　　只使用“.”操作符，没有“->”和“::”；

            　　“null”、“boolean”和“bool”成为了关键字；

            　　任何变量均在使用前进行初始化；

            　　不能使用整数来返回到if条件语句中，必须使用布尔值；

            　　“Try”模块后可以有“finally” ；

        3. 属性（Property）

            属性的概念对大家来说应该是很熟悉的，类成员函数可以自由地访问本类中的任何属性成员。不过若要从一个类中去访问另一个类中的属性，那就比较麻烦了，所以很多时候我们使用Getxxx和Setxxx方法，这样看起来显得极不自然，比如用Java或者C++，代码是这样的：

            　　foo.setSize (getSize () + 1);
            　　label.getFont().setBold (true);

            但是，在C#中，这样的方法被“属性化”了。同样的代码，在C#就变成了：

            　　foo.size++;
            　　label.font.bold = true;

            可以看出来，C#显然更容易阅读和理解。我们从这个“属性方法”的子程序代码中，也可以看到类似情况：

            Java/C++:

            public int getSize()
            {
            　　return size;
            }

            public void setSize (int value)
            {
            　　size = value;
            }

            C#:
            public int Size
            {
            　get{return size;}
            　set{size = value;}
            }

          为了区分这种属性化的方法和类的属性成员，在C#中把属性成员称作“域(field)”，而“属性”则成为这种“属性化的方法”专用的名词。顺便说一句，其实这样的属性化方法在VB和DELPHI中是经常碰到的，在VB中它也就叫属性。

         另外，在C#中Get和Set必须成对出现，一种属性不能只有Get而没有Set（在Java和C++中就可以只有Get或者只有Set），C#中这样做的好处在于便于维护，假如要对某种属性进行修改，就会同时注意Get和Set方法，同时修改，不会改了这个忘了那个。

      4、对象索引机制（Indexer）

         C#中引入了对象索引机制。说得明白点，对象索引其实就是对象数组。这里和上一节中的属性联系起来讲一下，属性需要隐藏Get和Set方法，而在索引机制中，各个对象的Get或者Set方法是暴露出来的。比如下面的例子就比较清楚地说明了这一点。

            public class Skyscraper
            {
            　Story[] stories;
            　public Story this [int index] {
            　　get {
            　　　return stories [index];
            　　}
            　　set {
            　　　if (value != null) {
            　　　　stories [index] = value;
            　　　}
            　　}
            　}
            ...
            }

            Skyscraper empireState = new Skyscraper (...);
            empireState [102] = new Story ("The Top One", ...);

           呵呵，有了这种特性，我们就再不用怕课堂上老师叫我们写对象数组这种程序了。 
       5. 指代（Delegate） 
         指代这个玩意很特别，它有点象指针，但又不完全是，不过大家还是可以把它理解为一种类型安全的、面向对象的指针。（什么是类型安全和面向对象就不用讲了吧？）顺便提一句，有很多书上把Delegate翻译成代理，我觉得这样翻不够确切，翻译成“指代”更恰当些，道理上吻合，并且还符合它的本来意思——微软本来就是用Delegate来“取代指针”，所以叫“指代”，呵呵。

          说起指代，也许至今Sun还会对它愤愤不已，为什么呢？因为在Sun的标准Java中是没有这个东西的，它是微软99年发布的MSVJ++6添加的“新特性”。为此，两家公司吵得不亦乐乎，并且还专门在网上写了大量文章互相攻击，有兴趣的朋友可以去看看（只有英文版）。
            http://www.Javasoft.com/docs/white/delegates.html
            http://msdn.microsoft.com/visualj/technical/articles/delegates/truth.asp

          话归正传，指代有什么特点呢？一个明显的特点就是它具有了指针的行为，就好象从Java又倒回到了C++。在C#中，指代完成的功能大概和C++里面的指针，以及Java中的接口相当。但是，指代比起C++的“正宗指针”来又要高明一些，因为它可以同时拥有多个方法，相当于C++里面的指针能同时指向多个函数，并且是类型安全的，这一点体现了它的“对象”特性；而比起Java的接口来，指代高明的地方在于它能可以不经过内部类就调用函数，或者用少量代码就能调用多种函数，这一点体现了它的“指针”特性。呵呵，很有“波粒二象性”的味道吧？指代最重要的应用在于对于事件的处理，下一节我们将重点介绍。

     6、事件（Event）

      C#对事件是直接支持的（这个特点也是MSVJ所具有的）。当前很多主流程序语言处理事件的方式各不相同，Delphi采用的是函数指针（这在Delphi中的术语是“closure”）、Java用改编类来实现、VC用WindowsAPI的消息系统，而C#则直接使用delegate和event关键字来解决这个问题。下面让我们来看一个例子，例子中会给大家举出声明、调用和处理事件的全过程。

            //首先是指代的声明，它定义了唤醒某个函数的事件信号
            public delegate void ScoreChangeEventHandler (int newScore, ref bool
            cancel);

            //定义一个产生事件的类
            public class Game
            {
            　// 注意这里使用了event关键字
            　public event ScoreChangeEventHandler ScoreChange;
            　　int score;
            　　// Score 属性
            　　public int Score
            　　{
            　　　get {
            　　　　return score;
            　　　}
            　　　set {
            　　　　if (score != value)
            　　　　{
            　　　　　bool cancel = false;
            　　　　　ScoreChange (value, ref cancel);
            　　　　　if (! cancel)
            　　　　　score = value;
            　　　　}
            　　}
            }

            // 处理事件的类
            public class Referee
            {
            　public Referee (Game game)
            　{
            　　// 裁判负责调整比赛中的分数变化
            　　game.ScoreChange += new ScoreChangeEventHandler
(game_ScoreChange);
            　}

            　// 注意这里的函数是怎样和ScoreChangeEventHandler的信号对上号的
            　private void game_ScoreChange (int newScore, ref bool cancel)
            　{
            　　if (newScore < 100)
            　　　System.Console.WriteLine ("Good Score");
            　　else
            　　{
            　　　cancel = true;
            　　　System.Console.WriteLine ("No Score can be that high!");
            　　}
            　}
            }

            // 主函数类，用于测试上述特性
            public class GameTest
            {
            　public static void Main ()
            　{
            　　Game game = new Game ();
            　　Referee referee = new Referee (game);
            　　game.Score = 70;
            　　game.Score = 110;
            　}
            }

      在主函数中，我们创建了一个game对象和一个裁判对象，然后我们通过改变比赛分数，来观察裁判对此会有什么响应。

      请注意，我们的这个系统中，Game对象是感觉不到裁判对象的存在的，Game对象在这里只负责产生事件，至于有谁会来倾听这个事件，并为之作出反应，Game对象是不作任何表态的。

       我们注意到，在裁判类的Referee函数中，Game.ScoreChange后面使用了+=和-=操作符，这是什么意思呢？回到我们定义ScoreChange的地方，可以发现ScoreChange是用event关键字修饰的，那么这里的意思就很明白了：ScoreChange是一个事件，而事件被触发后需要相应的事件处理机制，+=/-=就是为这个事件增加/移除相对应的事件处理程序，而且，并不是一个事件只能对应一个处理程序，我们还可以用这两个操作符为同一事件增加/移除数个事件处理程序。怎么样？很方便吧！

       在实际应用中，和我们上面讲的（竞赛-裁判）机制很相近的系统就是图形用户界面系统了。Game对象可以看作是图形界面上的小零件，而得分事件就相当于用户输入事件，而裁判就相当于相应的应用程序，用于处理用户输入。

        指代机制的首次亮相是在MSVJ里，它是由Anders
            Hejlsberg发明的，现在又用到了C#中。指代用在Java语言中的后果，则直接导致了微软和Sun之间对类和指针的关系产生了大量的争论和探讨。有意思的是，Java的发明者James
            Gosling非常幽默地称呼指代的发明者Anders Hejlsberg为“‘函数指针’先生”，因为Anders
            Hejlsberg总是想方设法地把指针变相地往各种语言中放；不过有人在看了Java中大量地使用了各种类后，也戏称Java的发明者James
            Gosling为“‘全都是类’先生”，真是其中滋味，尽在不言中啊。
      http://www.daima.com.cn/Info/107/Info35374/

      C#和Java都是很不错的语言。他们通过类似的方式达到了类似的目的，尽管C#比Java多出来一些和句法相关的东西，例如foreach关键字和一些更加让人高兴的扩展／实现架构。不幸的是，这些改进的光芒被削弱的东西掩盖掉了。在本文里，我将比较两种语言，并尽量避免深入到JVM和CLR层。

      Java：无可争辩地具有C++所有的精华
      在比较Java和C#的时候，你不可能不注意到它们诸多的相似之处，这在某种程度上要归结于它们共同的来源：C和C++。但是，当Gosling和他的同事们坐下来创造Java的时候，他们不仅吸取了C++的能力，而且更重要的是，他们减掉了一些无用特性，后者让C++更容易出错误而且更难学习。C#的设计者加入了很多C++的特性，而Java也加入了这些特性，但是C#却没有去掉C++的最糟糕的一些特性。其结果就是这样一门语言，它仍然为所有人提供了所有的特性，但其结局是内部冲突不断，而且过于复杂。

      散漫的句法缺陷
      最容易找出的错误是流控制和句法。C#提供了goto command，将其作为更改程序执行点的机制。自从Edsger W.
      Dijkstra在1968年出版了他的《关于Go to陈述式害处的考虑（Go To Statement Considered
      Harmful）》。Goto语句导致代码难以调试，而且很难被测试工具处理。

      在另一种不同的情况下，操作符过载同样也有很大问题，只不过层次不一样罢了。当“+”根据操作数的类型而代表任何东西的时候，代码的功能就不再透明，难以预料的副作用就会发生。

      C#在安全上的削弱
      C#有一个用于将代码区域标示为不安全的简单机制。在这些不安全的区域里，Java以及后来的C#安排到位了一些安全措施，用以防止程序员直接修改内存位置，以及使用点运算，但是这些措施是值得怀疑的。在使用具有垃圾清理功能的高级语言时，如果下到内存地址这一层，就会把对象／内存之间有意作出分离弄混。错误就会容易出现，调试成了恶梦，缓冲区溢出再次抬头，C和C++里著名的安全漏洞再次现身。

      C#还允许对主机系统上本机库的简单访问。这个与非.NET对象相结合的访问同Java本机接口（JNI）所提供的功能类似，但是它更加危险。JNI被设计用来小心地限制Java代码以及本机代码同已定义好的接口之间的交互操作，.NET使得调用本机对象文件变得极其简单，结果导致开发人员在做这的时候，无法意识到他们在这一过程中把平台的可移植性也扔出了窗外。

      SOAP的集成
      C#，及其更大的扩展.NET，已经同SOAP
      Web服务紧密地集成在一起。SOAP是使用XML指定参数和结果值来进行远程过程调用的好标准，但是它并不是唯一的方式。利用用于Web服务的外部库能够允许Java开发人员轻易地更改其Web服务的风格，使其成为SOAP、XML-RPC，或者什么还没有发明的东西。当然，C#的开发人员总是能够选择将外部库用于SOAP的Web服务，但是由SOAP标准的紧密集成所造成的限制要比它能够做的东西更多。

      所有者的恐慌
      C#里最令人恐慌的特性可能就是其所有者了。微软已经为将C#和.NET用于非Windows平台进行了精心的展示，但是这在很大程度上还只是作秀。其用于非Windows平台的CLR是问题多多，错误多多。它通过ECMA标准化过程来运行C#——这一步连Sun也不敢在Java上迈出。其担心来自于微软对此可能封锁的程度，如果它愿意的话。微软已经申请了一个专利，以排斥他人编写第三方的CRL，例如Mono计划。如果微软决定对免费的C#和.NET社区施压，它就有能力拿票子和法律的大棒把其开发活动赶回到Win32平台——当然这也不是它想看到的情况。

      而Java语言则相反，不是ECMA标准的，真可惜Sun没有遵从这一标准。但是，它是可以实现的，而且没有专利的阻碍，其虚拟机和核心类库都有来自第三方的开放和封闭源代码的实现。C#看起来是免费的，其实不然，而Java看起来限制很多，但是它能够依据法律通过免费的途径来实现。

      最后，我从来都没有想到我会说这个，但是Java具有更好工具的支持，即使是在考虑到集成开发环境（IDE）的情况下。Visual Studio
      .NET是一个很不错的IDE。它代表了多年的努力，而且特性很丰富。但是，Eclipse
      IDE包括了对Java的支持，它在稳定性、易用性和所提供的特性上超过了Visual
      Studio。IBM对Eclipse的贡献举足轻重，而且如果你信奉原来的软件格言“创建一个扔掉的（Build one to throw
      away）”，那么你可以把Visual
      Age作为第一个（被抛弃掉了的）尝试。对于使用C#的开发人员来说幸运的是，Eclipse的.NET版本正在开发中。

      不是那么差，但是还不是Java
      客观一点评价，C#里并没有什么很恐怖的东西。它没有Visual
      Basic里的那些很恐怖的东西，而且它事实上也没有继承像C里的一些东西，而这些东西会让开发人员开枪却打中自己脚。但是，底线是，C#并没有做很多东西，如果有任何东西比Java更好的话。它在某些方面很明显的要更差。在这两个非常类似的语言之间作选择的时候，请选择稍稍更好且经历风雨的那个：Java。 

Java 和 C#的比较

2007年11月1日
  1。访问控制方面：C#有public、internal、protected、private，比java多了个internal，其实它跟java的包访问差不多，internal表示同一个编译集合（如exe、dll）下的类可以互访。
  对于protected，java和C#有区别。在java中，protected和包访问级别差不多，即不是私有的。而在C#中，protected和private差不多，即它标志的成员是私有的。
  有这样一种情况：类中的一个成员，需要它能被子类访问到，同时能被同一个集合中（无论是java的包还是C#中的编译集合）的其他类访问到，怎么办呢？在java中，只要用protected就行了。在C#中，可以同时指定internal protected（二者的顺序随意）。
  在有这样一种情况：类中的一个成员，需要它能被子类访问到，但不能被同一个集合中（无论是java的包还是C#中的编译集合）的其他类访问到，怎么办呢？在C#中，可以指定protected（二者的顺序随意）。但java就无能为力了。
 2。C#中有static constructor的概念，这跟java中的静态初始模块一样。
    C# : static [类名]{}
     java :static{}
 3。Java中的main函数必须是public static void main(String[] args)的样子，否则虚拟机拒绝运行。C#中，Main函数可以是private的（甚至可以是protected），可以没有参数，可以返回int值。有点像C语言。
 4。发现csc.exe有一个功能很好，100后面加一个小写的L，它会警告：“l”后缀容易与数字“1”混淆；为清楚起见，请使用“L”。
 5.C#提供了一种机制，使得某个变量可以被动态赋值一次，以后就不能再改了。那就是readonly关键字的功能。
 6.java在继承、多态方面，比C#强多了。Java默认的多态，C#要求加上virtual（被继承的方法）和override（继承的方法），而且C#要求不能改变原来的访问修饰符，不像java那样，可以指定更加宽松的访问方式。如果有人利用C#来写程序，必须经常带上virtual和override，还必须照抄原来的访问控制符，不会很郁闷吗？难道有人用C#的面向对象特性时，会舍弃多态的特性？这会引起多大的混乱啊。
  多态是面向对象的精髓，像java那样默认不是更好吗？ 
7. C#中new还可以用来指定子类的某个方法要隐藏父类的具有相同签名的方法。这是不是多余的？你不用也可以，不过csc.exe会警告你，如“lan.Other.Main(string[])”隐藏了继承的成员“lan.HelloWorld.Main(string[])”。如果是有意隐藏，请使用关键字 new。
像java那样默认多好啊。
但是话又说回来，C#这样做也是有原因的。如果类B继承了类A，B接下来有添加了一个方法叫做hi（），那是B特有的。然后类A（假设是别人来维护的，你不能看到源码）突然也增加了一个方法hi（）。如果B自己那个hi（）跟A那个hi（）的返回值不一样，当你更新类库A后，可能导致程序运行错误或不能编译。C#就很好就地避免了这种问题。（虽然这种问题出现的概率挺小的…）
8.C#中，防止一个类被继承，要用关键字sealed。而定义一个常量时，要用const。
  像java统一用final多好啊。
9.在C#中，要比较两个引用变量是否指向同一个对象，不能用java中的= =，而要用Object里的ReferenceEquals方法。C#中，不能用一个类的实例去调用该类的类方法，必须用类名。所以java中的o1= =o2等价于C#中的Object.ReferenceEquals(o1,o2)。
10.C#中没有原始类型的包装类，但是也提供自动装拆箱的功能，和java有的一样。区别是，C#的装箱是自动的，拆箱就要强制转换了。
int i=100;
object obj=i;
i=(int)obj;
具体怎么装和拆，我们不知道。只知道CLR将int转换成object了。
11.java的内部类有时候帮助很大。到了C#那，就只提供静态的内部类了。这意味着外部类只相当于是一个命名空间而已。C#中的内部类能访问外部类的私有成员，这可能会让它有点用。
12.C#中虽然有运算符重载，但是为了整个.net的一致性，应该不会鼓励使用。因为有的.net语言没有运算符重载，而.net的一个目标就是消除各种语言的差别。
13.C#多了一个struct值类型，它就跟原始类型一样。微软在必要的时候会帮你将struct封装成Object，就像封装int类型一样。以至于你可以认为struct也是由Object继承而来，虽然struct本身并不支持继承。（struct可以不用new来初始化，但它里面的内容必须初始化后才能调用其方法；struct没有析构方法；struct没有默认的构造方法）。

2007年11月2日
1.java中类的访问控制符只能是public，或者没有（即默认的包访问）。但是C#中，class和interface的访问控制符可以是public / private / internal / protected / internal protected。当然你必须先取得对类的访问，才可能访问到类的成员。
 一个C#集合中可以包含多个public的类或接口，跟文件名没有关系。
2.C#中的接口不能包含常量，而java可以。
3.C#中的as和java中的instanceof功能一样。但C#提供一个据说是效率更高的as关键字。
4.接口和抽象类在C#和java中都差不多，这里提一下接口设计和抽象类设计的区别之处。如果你更改了一个接口的设计，比如增加了一个方法，使用你以前的代码的用户将不得不改变他们的代码，否则不能运行和编译。但是如果是一个抽象类，你可以提供一个含默认实现的方法，用户的代码则不需要改变。
5.C#中一个类实现一个接口时，它的相关方法不必指明override；但一个类继承一个抽象类的抽象方法时，必须加上override，否则视为隐藏。（事实上，只有抽象方法或者是virtual、或者是接口方法才能被覆盖即override。不能无缘无故地override。）
6。C#中存在一个“多态起始点”的问题。如果一个类实现了接口的某个方法，只是接口到该类才有多态的功能，若要这种多态继承下去，该类必须指明是virtual，多态起始了，接下来的子类提供override就能多态了，不需要更多的virtual。
  但是抽象类的抽象方法默认就是一个多态起始点，后续的子类只要override就行了。
7.当一个类实现了两个接口，两个接口有一个相同的方法定义，C#有一种解决机制，叫做显示实现。Java干脆就不处理这种情况，反正实现之后就能调用了，不必指明是哪个接口的，留给程序员自己考虑。
 当然C#中的显示实现还有其他功能。举个例子，接口A有一个方法叫做f（），类B实现了A。按理说B的实例就能自由调用f（）了，但是如果有这样的要求：B的实例只有被cast成A之后才能调用f（）。在java中，这样无理的要求是不允许的。但是C#可以做到，就是通过显示实现的方式。有谁会使用这样的特性？

Java与c#的区别（语言级别）

大致列在下面：

1. 源文件方面。C#可以在一个.cs 文件中。出现多个name sapce（命名空间，有些类似于pacakage），并定义多个类。C#包含有预处理指令。

2. 数据类型方面。

a) C#定义了struct（结构），不能是抽象的，也不能被继承，是值类型的。

b) C#没有基本类型的概念，全部是面向对象的类型，int是Int32的简写。

c) 在Java中const是保留字，final与C#中的const意思相同，C#中还有readonly允许运行时赋初值。

d) 字符串比较，C#中可以用=比较值，与Java一样用StringBuffer来减少内存开销。

3. 运算符方面。C#增加了Checked和Unchecked以绕过编译错误。比如“把一个long付给int32 ，如果高32为零 则不会出错，否则会有溢出错误，unchekced就是告诉编译器不要去管溢出，尽你可能转化”

4. 分支语句方面。在Java中goto是保留字。C#中switch中的case不会顺序执行，末尾必须有break或者goto关键字。

5. 循环语句好像没有什么不同的。

6. 访问修饰符方面。在范围放main，C#增加了internal和protected internal，前者表示只能从当前程序集内可见，即可以在编译时可Assembly的DLL或EXE，类似于JAR；后者表示对当前程序集或者从此包含类继承的类可见。Sealed相当于Java中的final关键字。

7. 方法方面。与Java相同，只有基本类型通过值传递，其他都是传递引用。不过C#也可以以引用的方式传递基本类型，利用ref关键字。而out关键字有些类似于Oracle存储过程，与ref的区别在于：方法忽略out参数初始值，方法必须为out参数赋值。

8. 属性方面。Getter和Setter的写法不太一样。

9. 继承方面。C#增加了base关键字以指向父类。C#中父类方法中具有virtual关键字的才可以被子类重写，重写时还需要声明override。与抽象类相同，abstract关键字也必须被override重写。C#中的接口不能声明常量，接口的属性只是表示Getter或Setter。

10. 事件。Java中没有(Java通过实现自定义侦听器类执行事件)。C#定义了类似于函数指针的委托来实现事件。

11. 运算符重载。Java中无。运算符重载必须为类的静态方法，重载==，其他判等操作也必许重载。

12. 异常方面。与Java非常相似，只是没有throws关键字，无须截获异常（当然要在程序主入口去截）。

13. C#增加了索引器，可以象访问数组一样访问类或结构。个人感觉就是少些几个字而已，还造成一定的困扰。

14. C#的Attribute要比Java的Annotation强很多。不过加上AOP后，这种动态功能Java也不错了。

15. 在C#中也可以直接使用指针，开辟或者回收内存，只是要使用两个关键字unsafe和fixed。