编程C,C ++,Java,PHP,Ruby,图灵,VB
计算机科学加拿大 
编程C,C ++,Java,PHP,Ruby,图灵,VB  

用户名:   Password: 
 登记登记   

 Wiki.Wiki.   博客博客   搜索搜索   图灵图灵   聊天室  成员成员 
 为什么Java Sucks.
指数 -> java.
转到页面 1, 2, 3 ...... 14, 15, 16  下一页
查看上一个主题 可打印的版本下载主题订阅本主题私人信息刷新页面 查看下一个主题
作者 信息
WTD.




邮政发布: 2005年10月8日星期六1:49  帖子主题:为什么Java Sucks

java为什么吮吸?

在我潜水之前的几个笔记:

其中一些分数我关心比其他人更多。它们并不一定属于感知重要性。

这些缺陷都不是,他们自己是“交易破碎机”。我喜欢使用制作许多同样错误的语言。然而,在我看来,当你把所有这些都放在一起,在我看来,他们会变得压倒。即使是其中一些缺陷也会致力于使Java更令人愉快。

我相信本文件是一个重要的目的。有许多程序员可能没有意识到有java做事的方式有替代方案。如果这些投诉只能指出这一点,那么它已经完成了很大的成就。


  1. 我的名单和数组在哪里?

    每个人都使用列表。我们用它们 到处.

    您如何在Java中创建列表?

    java.:
    数组列表LST = 新的 数组列表();
    LST。添加(新的 整数(42));
    LST。添加(新的 整数(27));
    LST。添加(新的 整数(12));


    java. 1.5.0中的事情有点好。

    java.:
    数组列表<Integer> lst = 新的 ArrayList<Integer>();
    LST。添加(42);
    LST。添加(27);
    LST。添加(12);


    但为什么Java无法为列表或数组有某种文字语法?大量的其他语言只是这样做,它绝对不是被认为是浪费的句法糖。

    代码:
    LST = [42,27,12]

  2. 为什么无法返回多个值?

    是的,是的......在Java中,他们被称为“方法”。

    为什么他们不能返回多个值?

    因为C和C ++不能是一个好理由,但这是我们给出的。相反,我们必须为库添加额外的类,或返回列表。

    第二个选项似乎很好,但这意味着我们必须创建一个列表(使用上面列出的繁琐语法),返回它,将返回值分配给数组或列表变量,然后手动抓住该列表中的每个元素并将其分配给一些其他变量。

    能够返回一个以上的价值是怎么出错了?

    Python:
    defFoo():
       返回 (1, 2, 3)

    A,B, c = foo()

  3. 元素在哪里?

    这个与上一个问题有关。

    对元组的简单支持将非常缓解编程。这概念在哪里,这么多语言已经纠正?它完全缺失了。
  4. 每次和修改?

    为每个循环使得可以在迭代集合时避免逐个错误。但这仅适用于我们在读取集合中的元素的值时。

    如果我们想修改这些元素,我们不能使用每个循环。
  5. Lambda职能在哪里?

    代替:

    java.:
    jbutton.  helloButton = 新的 jbutton.("问好");
    你好Button.AddactionListener. (新的 ActionListener.() {
       上市 空白 actionPerformed(ActionEvent. ae) {
          系统.出去.println.(“你好”);
       }
    });


    为什么允许如下的内容是如此糟糕?

    代码:
    让你好 - 按钮:: <button> = make(<button>, text: "Say Hello");
    添加动作侦听器(Hello-Button,方法(ae :: <action-event>) format-out("Hello\n") end);


    没有不必要的命名。真的,有人关心“ActionListener”或“ActionPerformed”?不,我们只关心我们有一种方法考虑一个演出的方法。

    是的,匿名内部类可以提供灵活性,特别是当您想要持久状态时。然而,绝大多数时间是完全矫枉过正,以及一个重要缺失特征的坏致力。
  6. 参数标签在哪里?

    假设我有一个方法或构造函数,它需要几个参数。哪个论点做了什么?好的,我猜。哎呀,我弄错了,程序没有编译。

    嗯......有点编辑和瞧!它编译。现在让我运行它。哦......奇怪......我有一些奇怪的逻辑错误。哦,半小时搜索错误后,它是因为我有正确的参数类型,但我混在其中两个。让我去咨询API参考。

    为什么我们需要这样做?

    肯定有更好的方法。许多语言已经知道这一点。

    代码:
    让win = window〜title:"hello" ~width:400 ~height:300 ()


    我需要记住是否在参数订单中首先出现宽度或高度?不。
  7. 为什么没有参数需要括号的方法?

    在C和C ++中,函数的名称可以用作指向该函数的指针。在自己的情况下,它是内存中的地址。它是有道理的,因此在函数之后具有括号,作为所谓的指标。

    java.没有这样的概念。它也没有像D或C#这样的代表概念。没有办法在该方法的定义之外使用的方法的名称,这不是方法调用。

    然而,我们仍然必须在括号上钉在括号上,即使他们没有任何东西。它为程序增加了噪音,强制无数额外的击键。

    也许是理性的是,通过方法重载,不可能知道没有括号的方法是否是没有参数的故意呼叫,或者错误。但在这种情况下,为什么不假设程序员知道他或她在做什么?

    当我们有了,为什么不从方法定义中删除空括号?因为它会导致语法中的混淆?

    当然,我们肯定没有其他地方,我们会在名字之后直接使用卷曲括号。

    java.:
    细绳 getName. { 返回 .名称; }


    除了方法定义之外,上述几乎不会误读。
  8. 为什么房地产访问有句法糖?

    因此,很多语言都可以正确地抓住Java的“Get *”和“Set *”方法是一种耻辱。即使是c和c ++派生的c#也得到了这个权利。

    它们将不必要的句法噪声添加到程序并忽略了分配运营商的视觉影响。

    如果我看到:

    代码:
    窗口("hello");


    读取它肯定需要更长的时间,了解它的情况比我所做的事情:

    代码:
    window.title =."hello";


    后一个例子没有多余的“设置”或括号混淆了该声明的目的。
  9. 为什么默认情况下不能通过公共空域?

    当然,班上的大多数方法都是公开的。为什么他们默认为私人?

    霍夫曼编码原则说最常见的代码应该是最简洁的。

    java.:
    班级 名称
    {
       细绳 first, last;

       名称(细绳 F, 细绳 l)
       {
          first = f;
          last  = l;
       }

       细绳全名()
       {
          返回第一+ + last;
       }
    }


    当然,这比:

    java.:
    班级 名称
    {
       细绳 first, last;

       上市 名称(细绳 F, 细绳 l)
       {
          first = f;
          last  = l;
       }

       上市 细绳全名()
       {
          返回第一+ + last;
       }
    }


    噪音较小。少令人困惑。
  10. 为什么我需要使用“返回”?

    “返回”关键字最终是关于控制流程。它需要我们从方法中的任何给定点,并跳过到最后,可选地产生一些值。

    java.:
    细绳全名()
    {
       返回第一+ + last;
    }


    现在看看这段代码。为什么我需要一个“返回”?我已经在方法结束时了。还有其他地方去。

    java.:
    细绳全名()
    {
       first + + last;
    }


    我们去了。我们到达该方法的结尾,并且有一个字符串。嘿......我的方法返回一个字符串。这不是一个令人难以置信的巧合吗?也许我的方法应该返回此字符串。

    较少的句法噪音很好。

    但是如果我有更复杂的方法,“返回”显然是必要的,对吧?

    java.:
    细绳全名()
    {
       如果 (第一的。等于())
       {
          返回最后的;
       }
       别的
       {
          返回第一+ + last;
       }
    }


    嗯......实际上,当我看这个时,我意识到了一些东西。条件是该方法中的最后一件事。还有其他地方去。

    java.:
    细绳全名()
    {
       如果 (第一的。等于())
       {
          last;
       }
       别的
       {
          first + + last;
       }
    }


    看起来更好,不是吗?
  11. 虽然我们越来越多,但半冒号是什么?

    卷曲支撑是一个有效的标点符号。那我们为什么不用它?

    java.:
    细绳全名()
    {
       如果 (第一的。等于())
       {
          last
       }
       别的
       {
          first + + last
       }
    }


    显然,卷曲支撑表示块的末端。额外的半冒号没有告诉编译器有用的任何东西很有用。
  12. 多种方法......同样的事情。

    现在,在某些时候,我要覆盖ToString方法,所以我的名字类与API的其余部分播放。

    我已经通过使用我的更好的东西欺骗了一点。

    java.:
    班级 名称
    {
       细绳 first, last;

       名称(细绳 F, 细绳 l)
       {
          first = f;
          last  = l
       }

       细绳全名
       {
          如果 (第一的。等于())
          {
             last
          }
          别的
          {
             first + + last
          }
       }

       细绳 toString
       {
          fullName
       }
    }


    即使使用了预更版本,我仍然跳过人工篮球。清楚的全名和toString做同样的事情。

    java.:
    班级 名称
    {
       细绳 first, last;

       名称(细绳 F, 细绳 l)
       {
          first = f;
          last  = l
       }

       细绳全名, toString
       {
          如果 (第一的。等于())
          {
             last
          }
          别的
          {
             first + + last
          }
       }
    }

  13. 为什么必须单独指定参数类型?

    因此,当我声明变量时,我可以指定一次,然后是一个变量名称列表。

    然而,我不能用参数做同样的事情。

    我可以使用更多的句法噪声:

    java.:
    班级 名称
    {
       细绳 first, last;

       名称(细绳 F, l)
       {
          first = f;
          last  = l
       }

       细绳全名, toString
       {
          如果 (第一的。等于())
          {
             last
          }
          别的
          {
             first + + last
          }
       }
    }


    没有冲突,因为后续类型声明将开始新的参数。
  14. 为什么案件必须崩溃?

    案例通过Java突破的事实只是为了维持与C和C ++的句法和语义兼容性,它们本身由硬件考虑因素受到限制。当然,Java环境没有这些限制,因此保持与该限制的兼容性只是荒谬。

    创建落下的案件以解决缺乏另一个特征。让我们来看看一个创作的例子。如果数字为2,4,6或8,则我们希望返回true,否则为false。

    java.:
    转变 (数字)
    {
       案件 2:
       案件 4:
       案件 6:
       案件 8:
          返回 真的;
       default:
          返回 错误的;
    }


    现在,让我们看看一个替代造成的句法问题。

    java.:
    转变 (数字)
    {
       案件 2, 4, 6, 8:
          返回 真的;
       default:
          返回 错误的;
    }


    但由于这种交换机陈述不会崩溃,因此不需要控制流量突破以防止衰落。所以,如果这个开关单独在函数中,那么别的其他控制流可以去,我们可以避免返回。

    此外,我们可以使用括号作为标点符号。

    java.:
    布尔基 checkNumber( number)
    {
       转变 (数字)
       {
          案件 2, 4, 6, 8: 真的;
          default: 错误的
       }
    }


    句法噪声明显减少。
  15. 为什么不强制命名约定?

    java.,对于我可以选择的所有其他人,有一个不错的命名约定。

    编译器并未强制执行此类命名约定。

    这对此没有充分的理由。它只是为了安抚想要编写违反约定的代码的C ++程序员。
  16. 如何创建一个常量?

    哦,这很容易。

    java.:
    最终的 我= 42;


    我不能给“我”给出一个新的价值,对吗?所以,它是不​​变的。

    因此,以下不应该编译。

    java.:
    班级 Foo
    {
       细绳 bar;

       上市 Foo(细绳 initBar)
       {
          bar = initBar;
       }

       上市 细绳 getBar()
       {
          返回 bar;
       }

       上市 细绳 toString()
       {
          返回 getBar();
       }

       上市 空白 setBar(细绳 newBar)
       {
          bar = newBar;
       }
    }

    上市 班级 Test
    {
       上市 静止的 空白 main(细绳[] args)
       {
          最终的Foo f = 新的 Foo(“酒吧”);
          系统.出去.println.(f);
          wooble(f);
          系统.出去.println.(f);
       }

       上市 静止的 空白求爱(Foo F.)
       {
          f.套管(“Baz”);
       }
    }


    这不应该编译,对吗?我的意思是,“f”显然是一个恒定的foo对象。

    然而,它确实如此,它非常好。

    您看,“最终”关键字仅意味着变量无法指向另一个值。这适用于简单的不可变数据,如整数,但对于具有变形状态的对象,它不会阻止对对象的更改。

    当我们将数据指定为不可变,我们提供编译器额外信息。在这种情况下,我们会告诉我们,如果我们试图违反该限制并对一系列数据进行更改。使用大型API,这可以完全无意中完成。

    但Java为我们提供了编译程序时无法检查此类问题的能力。

    当然,为了做出这项工作,我们还必须能够将方法标记为有效地调用常量对象。另一个选项是假设返回“void”具有副作用的任何方法,因此不能在常量对象上调用。
  17. 在void背景下的非空隙方法?

    这可能听起来很奇怪,但你们都处理了这个。有可能有类似的东西:

    java.:
    F。GetBar.();


    它只是返回对象“f”的“栏”字段。没有什么能阻止您在Java程序中有所作为。它没有任何目的,但Java编译器不会警告这一点或禁止它。
  18. java.需要一个高优先级的演员。

    这纯粹的丑陋使其成为针对Java的点。

    java.:
    ((Foo)酒吧).Baz.()


    你认为我们可以写:

    java.:
    (Foo)酒吧。Baz.()


    ..........................................但这是低优先级,所以它转化为:

    java.:
    (Foo)(酒吧。Baz.())


    相反,这是完全合理的:

    java.:
    (酒吧作为foo).Baz.()


    正如我所说的那样,少数句法噪音是一件好事,这种代码足以保证关注。
  19. 为什么Java无法更深入的代码分析?


  20. 为什么切换有限于整数?

    它是“切换”的一块蛋糕,以允许使用==用于原始类型的==或对象类型的“等于”方法的比较。这可以大大简化了很多代码,它相对容易。甚至不会改变开关目前的工作方式,而是只需添加功能。

    为什么不这样做?哦,对,不要让C ++程序员感到不合适。
  21. 为什么我不能写独立的函数?

    “静态”上下文只是愚蠢。它使许多人困扰着哎呀,并且在无法使用独立功能和适当的模块系统,混合或多种实现继承方面无法实现的代码重新使用。

    课程本身对象的语言是有道理的,并且被视为这样。在这种语言中,“静态”方法和字段只是类对象的非静态字段和方法。

    当然:

    java.:
    空白 main(细绳[] args)
    {
       Foo f = 新的 Foo();
       系统.出去.println.(f);
    }

    班级 Foo
    {
       上市 细绳 toString()
       {
          返回 “你好”;
       }
    }


    比:

    java.:
    班级 Foo
    {
       上市 静止的 空白 main(细绳[] args)
       {
          Foo f = 新的 Foo();
          系统.出去.println.(f);
       }

       上市 细绳 toString()
       {
          返回 “你好”;
       }
    }


    从OO的角度来看,没有意义。
  22. 说说混合......

    为什么不实现这种强大而简单的代码重用机制?

    静态方法的主要用途之一是提供充满实用方法的类,用于各种类型的对象,所有类型的对象都实现了一些接口。只需查看一个例子的集合类。

    引用:
    此类仅包含在或返回集合的静态方法。它包含在集合上运行的多态算法,“包装”,它返回由指定集合支持的新集合,以及其他一些赔率和结尾。


    by andly,这些方法将某种排序(列出,设置等)收集为第一个参数。我知道我之前见过这个模式......

    哦,是的,在Python中,“self”对象被作为的第一个参数传递给一个类中的每个成员函数。这些成员函数作为方法。

    所以这不是太难看出:

    java.:
    收藏品.种类(奥姆伯斯特);


    作为:

    java.:
    索莫斯特。种类();


    很好,呃?

    当然,“排序”不是列表类的方法,因此不起作用。

    让我们看看它用另一种语言的方式。在这种情况下,Ruby。

    我希望能够对任何实现迭代内容的特定手段的任何东西(让我们调用这个“界面”),但我不想为每个类写下所有代码,尤其是我知道他们每个人都会是一样的。它只是取决于迭代方案,而不是其他关于对象的状态。

    所以我有一个类阵列。数组对象具有处理迭代的“每个”方法。然后,我“混合在”模块中令人令人担忧,除其他外,我得到了“排序”方法的实现。

    什么不想将这些方法添加到整个班级?只希望它们添加了一个对象?这很容易。结果是单身。

    甚至C#,而不是世界上最具创新性的语言,正在实施混合载体,包括单身支持,尽管Microsoft更喜欢称为“扩展类”。

    为什么Java忽略了这样的电源来源?为什么语言抢劫其用户的这种力量?

    如此深刻的缺乏,可能没有充分的理由。
  23. 编译时间代码分析发生了什么?

    显然,在编译时,我们可以查看以下内容并意识到只需要一个字符串对象创建。由于字符串是不可变的,这对此没有伤害。

    然而,通过“==”运算符进行参考平等的测试,我们可以看到已创建两个不同的字符串对象,其中包含完全相同的内容。

    java.:
    班级 Test
    {
       静止的 细绳Foo = "你好 world";
       静止的 细绳 酒吧= ;
       静止的 细绳Baz.= "你好" +酒吧+ “世界”;

       上市 静止的 空白 main(细绳[] args)
       {
          如果 (Foo == baz)
             系统.出去.println.(“真的”);
          别的
             系统.出去.println.(“错误的”);
       }
    }


    这种简单编译时间分析的级别不会发生的事实是令人不安的。

    当然,如果我们编写以下内容,它会显示它们确实指向同一个对象。

    java.:
    班级 Test
    {
       静止的 细绳Foo = "你好 world";
       静止的 细绳Baz.= "你好 world";

       上市 静止的 空白 main(细绳[] args)
       {
          如果 (Foo == baz)
             系统.出去.println.(“真的”);
          别的
             系统.出去.println.(“错误的”);
       }
    }


    因此,基本上发生了什么是编译器等待在运行时执行可以在编译时容易地完成的字符串连接。
  24. 为什么我们不能做一些类型的推理?

    C#,在设计方面与Java共享的语言,是有限的类型的推理形式。 java为什么不采用此类功能来使编程更容易?

    比较:

    java.:
    BufferedReader. 键盘= 新的 BufferedReader.(
       新的 InputStreamReader.(系统.));


    和:

    java.:
    var键盘= 新的 BufferedReader.(
       新的 InputStreamReader.(系统.));


    编译器可以在编译时轻松弄清楚“键盘”是BufferedReader实例。我为什么要明确地告诉它?
赞助
赞助
赞助
赞助
Rizzix.




邮政发布: 2005年10月8日星期六下午5:39  帖子主题:(没有主题)

我希望你现在感觉好多了...... 笑

在大多数情况下,我同意大多数东西......但有一些例外:

#1)在某些情况下,您提出的替代方法的语法非常难看(它只是令人难以置信,但是我知道它可以改进)

#2)Java的Switch语句是整数__and__枚举

#3)列表是不必要的..您可以使用arrays.aslist()函数。它为目的服务。

#4)而不是实施混合..我相信最好将AOP直接实现为语言。

#5)我不喜欢C ++实现不变性的方式(i,EA特别关键字)...... Infact我认为最好的注释是用来代表它以及方法类的访问限制等其他事情ETC(即公众,受保护,依此类推..所有这些都落在了Meta-Data的类别下。

#6)上面没有关于Java收到的Bashing数量的那些参数,在Compsci中... 笑
WTD.




邮政发布: 2005年10月08日星期六5:50  帖子主题:(没有主题)

Rizzix写道:
#3)列表是不必要的..您可以使用arrays.aslist()函数。它为目的服务。


嗯,我可以处理将其作为阵列,列表,arraylists返回......无论如何,但有些字面形式会很好。
WTD.




邮政发布: 2005年10月8日星期六5:59 PM  帖子主题:(没有主题)

Rizzix写道:
#4)而不是实施混合..我相信最好将AOP直接实现为语言。


面向方面的编程是一种略微含糊的术语。

也许某种类型的推理(比我在原来的帖子中描述的更深)是您在寻找的?

种类的红宝石鸭键入,但在编译时执行。

您可能希望查看O'Caml,以便与对象相结合的示例。

代码:
$ Ocaml.
       目标CAML版本3.08.2

#让foo bar = print_endline bar#baz ;;
val foo: < baz : string; .. > -> unit = <fun>
#类求=对象结束;;
课堂诉讼: object  end
#foo(new wooble);;
此表达式具有型求性,但此处与类型一起使用
  < baz : string; .. >
只有第二个对象类型有一个方法baz
#类忍者=对象方法baz ="hello" end;;
忍者类: object method baz : string end
#foo(new ninja);;
你好
- : unit = ()
#
WTD.




邮政发布: 2005年10月8日星期六7:52 PM  帖子主题:(没有主题)

Rizzix写道:
#5)我不喜欢C ++实现不变性的方式(I,E一个特别的关键字)


具有讽刺意味的是,Java保留但未使用的关键字相同的关键字。 眨眼

至少C ++具有不可变的。 微笑
WTD.




邮政发布: 2005年10月08日星期六9:29 PM  帖子主题:(没有主题)

Rizzix,我要感谢您的合理回复。我希望遗漏特别热的问题,如表演和操作员重载会鼓励这种反应。 微笑
WTD.




邮政发布: 2005年10月8日星期六9:58 PM  帖子主题:(没有主题)

让我加入另一件事希望Java有。

不,它不是C ++预处理器指令,但它在更高的水平上表现得很大。

d's“静态”允许编译时间决策。
Rizzix.




邮政发布: 孙09年10月9日12:48 AM  帖子主题:(没有主题)

实际上由AOP我指的是AspectJ。我只是认为它应该是Java的一组综合部分。
赞助
赞助
赞助
赞助
WTD.




邮政发布: Sun 09,2005 1:11 AM  帖子主题:(没有主题)

我可以看到DBC的东西有用,但我会使它成为语言的一个组成部分。另外鼓励使用这种技术,我会尽可能简单。

我认为,也许迫使程序员写出“如果”声明来评估一个条件并抛出异常,使其变得太难。考虑埃菲尔作为我在想什么的例子。

代码:
Foo(x : INTEGER) is
   require
      arg_too_small : x >= 42
   do
     std_output.put_integer.(x)
     std_output.put_new_line.
   end


当然调试方面(没有双关语)也很重要。我总是喜欢D'S“调试”关键字,这只是让它变得如此简单。

代码:
调试
{
   writefln("We're debugging!");
}

调试(4)//我们可以有数字来表示不同的调试级别
   writefln("我们可以使用调试行仅适用于一个语句");

调试(hello):
   //我们可以拥有用于控制调试块的字符串标签,
   //和调试部分可以扩展到当前块的末尾
WTD.




邮政发布: 太阳09年10月9日1:16 AM  帖子主题:(没有主题)

对于使用前动作的包装方法...... AspectJ的模式匹配能力有趣。没有它们,对于几种不同的方法具有相同的预先或发布行动肯定会乏味。
WTD.




邮政发布: 孙109年10月1日1:18 AM  帖子主题:(没有主题)

但是,除非他们大大改善了文档,否则我认为未来的未来支持。它很好,但它们在流行语上落后。 PHBS可能会喜欢它,但程序员不会。
WTD.




邮政发布: 孙09年10月9日1:58 AM  帖子主题:(没有主题)

一些Python代码挑逗您的AOP导向的思维。 微笑

代码:
>>> def pre(pre_f):
..........................................    def decorate(f):
..........................................       def x(*args, **kwds):
..........................................          pre_f()
..........................................          f(*args, **kwds)
..........................................       x .__ name__ = f .__ name__
..........................................       return x
..........................................    return decorate
..........................................
>>> def yo(): print "yo"
..........................................
>>> @pre(yo)
.......................................... def hello(): print "hello"
..........................................
>>> hello()

你好
>>> hello.__name__
'你好'
>>>
WTD.




邮政发布: 孙09年10月9日2:12 AM  帖子主题:(没有主题)

也有趣。 微笑

代码:
>>> def require(*types):
..........................................    def decorate(f):
..........................................       def x(*args, **kwds):
..........................................          for n, (type_name, arg) in enumerate(zip(types, args)):
..........................................             if not isinstance(arg, type_name):
..........................................                raise TypeError("在arg%d上键入不匹配。 应该是%s,但是%s。" % (n + 1, str(type_name), str(type(arg))))
..........................................          return f(*args, **kwds)
..........................................       x .__ name__ = f .__ name__
..........................................       return x
..........................................    return decorate
..........................................
>>> @require(int, int)
.......................................... def foo(a, b):
..........................................    return a + b
..........................................
>>> foo("hello", "foo")
追溯(最近的呼唤最后):
  File "<stdin>", line 1, in ?
  File "<stdin>", line 6, in x
TypeError.:arg 1键入不匹配。  Should be <type 'int'> but was <type 'str'>.
>>> foo(1, 2)
3
>>>
纳米




邮政发布: 太阳09年10月19日12:27 PM  帖子主题:(没有主题)

WTD写道:
留出特别的热门问题,如性能和操作员重载


我不完全理解这一点,但我认为谈论Java表现差是如何在某些方面的滥用神话。看一看。\

http://www-128.ibm.com/developerworks/java/library/j-jtp09275.html?ca=dgr-lnxw01JavaUrbanLegends
WTD.




邮政发布: 孙09年10月9日12:31 PM  帖子主题:(没有主题)

是的,它确实。

这就是为什么我选择不抱怨Java的表现。我认为没有触摸JVM的语言,我足以抱怨。
从上一个显示帖子:   
   指数 -> java.
查看上一个主题 告诉一个朋友可打印的版本下载主题订阅本主题私人信息刷新页面 查看下一个主题

116  [ 227 Posts ]
转到页面 1, 2, 3 ...... 14, 15, 16  下一页
跳到:   


Style:  
搜索: