×

Loading...
Ad by
  • 推荐 OXIO 加拿大高速网络，最低月费仅$40. 使用推荐码 RCR37MB 可获得一个月的免费服务
Ad by
  • 推荐 OXIO 加拿大高速网络，最低月费仅$40. 使用推荐码 RCR37MB 可获得一个月的免费服务

@Las Vegas

You hit some dark corners...

jabber(jabber)
本文发表在 rolia.net 枫下论坛Java is a very "simple" language.

In Java, if you create an Object and don't assign it to some reference, it will be an "orphan" Object. It means it is abandoned and it is subject to garbage collection. Of course, JVM can generate some internal references for an Object, but this is transparent to us, application programmers.

You have listed 4 cases. 2), 3) and 4) are meaningless, no matter what results you get.
Operator == is used to check if two references point to the same Object in the same JVM. In your case 2-4, you played the game agaist this rule. In some case, you pass because of the internal implementaion of JVM. In practice, no Java programmers write code of type 2), 3) and 4).

Now about your case 1). You created two different Objects (Strings) in JVM. They have two different references "s1" and "s2". You compared s1 and s2. This should return false. However, you don't pick up this return value, so your comparison is much ado about nothing. In other word, your comparison has no effects.

Reference is widely used in the conditionals such as

if(s==null) {
//do sth
}


if(s1==s2) {
//do sth
}

I advise you stop thinking about case 2, 3, and 4). You cannot find similar code in practice. Thinking about them does not help you understand Java.

In Passing, I mention the folllowing is OK though we don't give a reference to the created Object. See:

new Timer().start();

System.out.println(new String("abc").toUpperCase());更多精彩文章及讨论，请光临枫下论坛 rolia.net
(#20204@0)
Last Updated: 2001-1-3
This post has been archived. It cannot be replied.
Report

Replies, comments and Discussions:

  • 工作学习 / IT技术讨论 / Help: the following doesn't compile, why? -kummer(ciao); 2000-12-30 {45} (#19863@0)
    new String("Hello")==new String("Hello");
    • == means shallow comparison -jabber(jabber); 2001-1-2 {820} (#20081@0)
      In Java, one should exactly distingish Objects and their references. Take the following as an example:

      Animal a = new Bird();

      This means 3 steps: 1) Declare a variable with a type of Animal; 2) Create a Bird (Animal) according to the shape of a bird, using key word "new"; 3) Assign this Bird(Animal) to variable a. "a" is a kind of reference.

      In Java, to judge where two Object references point to the same Objects or not,
      we use the operator ==. This is called "shallow comparison".

      Now on your issue. You created 2 Strings. However, your assignment is wrong. You did not follow the following rule: Assign an Object to an Object reference.


      You created two Strings. They are not assigned to Object references. They are called "orphan Objects" because nobody can access them.
      • No democracy among Java objects? -kummer(ciao); 2001-1-3 {774} (#20187@0)
        Hi, jabber, thanks a lot for your answer.
        I totally agree with you, but look at the following cases:

        1) String s1=new String("abc");
        String s2=new String(edf");
        s1==s2;
        This is a standard Java statement.
        Of course, compile and run well.

        2) "abc"=="edf";
        Complie and run well.
        A little bit strange since we compare two objects(not references), nevertheless it is understandable if noticing special properties of anonymous strings.

        3) new String("abc")==new String("edf");
        doesn't compile.
        Excluded Java standards. However,

        4) For all wrapper classes like
        new Boolean("TRUE")==new Boolean("hi");
        compile and run well!

        So democracy doesn't exist, there are some special objects having extraordinary rights.
        Do you agree?
        • You hit some dark corners... -jabber(jabber); 2001-1-3 {1523} (#20204@0)
          本文发表在 rolia.net 枫下论坛Java is a very "simple" language.

          In Java, if you create an Object and don't assign it to some reference, it will be an "orphan" Object. It means it is abandoned and it is subject to garbage collection. Of course, JVM can generate some internal references for an Object, but this is transparent to us, application programmers.

          You have listed 4 cases. 2), 3) and 4) are meaningless, no matter what results you get.
          Operator == is used to check if two references point to the same Object in the same JVM. In your case 2-4, you played the game agaist this rule. In some case, you pass because of the internal implementaion of JVM. In practice, no Java programmers write code of type 2), 3) and 4).

          Now about your case 1). You created two different Objects (Strings) in JVM. They have two different references "s1" and "s2". You compared s1 and s2. This should return false. However, you don't pick up this return value, so your comparison is much ado about nothing. In other word, your comparison has no effects.

          Reference is widely used in the conditionals such as

          if(s==null) {
          //do sth
          }


          if(s1==s2) {
          //do sth
          }

          I advise you stop thinking about case 2, 3, and 4). You cannot find similar code in practice. Thinking about them does not help you understand Java.

          In Passing, I mention the folllowing is OK though we don't give a reference to the created Object. See:

          new Timer().start();

          System.out.println(new String("abc").toUpperCase());更多精彩文章及讨论，请光临枫下论坛 rolia.net

More Topics

  • 看大家讨论日语，俺也正在认真学习。其实语言问题应该是很快也很容易就解决的，可能比自动驾驶来的还快。TREK里面，全宇宙的人都在大脑里安装了UNIVERSAL TRANSLATOR，外星人之间相互交流无障碍。废话少说，看视频。。。加上个MIC和耳机，不同国家的人就可以无障碍交流。
  • 肉脸真有搞 IT 的？Linux 把俄国中国伊朗踢出去了好像肉脸 IT 没啥感觉似的
  • 请问web developer和software developer技术上有什么区别？
  • Elon Musk 带着川普总统奔向火星了。
  • 扔硬币的实验研究
    • 枫下论坛主坛 /  工作学习 /  IT技术讨论