Top Ten Errors Java Programmers Make

Very nice post

There is one top error beginners in Java make that also found its way into the referenced article: Java is always pass by value and never pass by reference.

Some of the mentioned "errors" are not programming errors at all because the code could would not compile. Some  other are stylisitc isssues rather than errors etc. DZ: garbage.

Should mention that the best-way to avoid the "overrides" problem is with the @Override annotation. If the method doesn't actually override a real method it is a compile time error! Unfortunately that does not work for Interfaces :( (maybe we need a @Implements ?).

Although the *BIGGEST* mistake I see in Java is people who don't get OOP and treat objects as structs and just have getters/setters on their objects and all the manipulation in static methods.

 

@David Qiao

BTW, "abc"=="abc" IS CORRECT because modern (1.4+ IIRC) compilers will only create one object per string literal per class.  Though other forms such as ("ab" + "c") == "abc" may not be... but I'm not sure if javac is smart enough yet.

Thomas,

I think your list is much better than the original post which has many items that won't even compile (hence impossible to get burned by them). I myself remember long hours of debugging until I figured out that "Double.NaN != Double.NaN" ;-)

Best,
Dmitriy Setrakyan
GridGain - Grid Computing Made Simple

"abc" == "abc" is TRUE because the Java Language Specification says that the expression must call String.intern() to construct both String objects and that the objects returned by intern() must be the same. And this is defined that way this since Java 1.0, I think. Just my 2 cents. ;) Best,

Strange. The Java Language Specification says the following about "abc" == "abc":

--------------------------------------------------------------

From http://java.sun.com/docs/books/jls/third_edition/html/lexical.html#3.10.5

Each string literal is a reference (§4.3) to an instance (§4.3.1, §12.5) of class String (§4.3.3). String objects have a constant value. String literals-or, more generally, strings that are the values of constant expressions (§15.28)-are "interned" so as to share unique instances, using the method String.intern.

Thus, the test program consisting of the compilation unit (§7.3):

    package testPackage;
    class Test {
            public static void main(String[] args) {
                    String hello = "Hello", lo = "lo";
                    System.out.print((hello == "Hello") + " ");   /// <----- This is the offending test case.
                    System.out.print((Other.hello == hello) + " ");
                    System.out.print((other.Other.hello == hello) + " ");
                    System.out.print((hello == ("Hel"+"lo")) + " ");
                    System.out.print((hello == ("Hel"+lo)) + " ");
                    System.out.println(hello == ("Hel"+lo).intern());
            }
    }
    class Other { static String hello = "Hello"; }

and the compilation unit:

    package other;
    public class Other { static String hello = "Hello"; }

produces the output:

    true true true true false true

--------------------------------------------------------------

As you can see, the first test case evaluates to true, as expected.

Best,

 

Maybe he should add this to the "Top Mistakes" list.

Eclipse's watch/inspect while debugging gives false as well. I guess they both don't intern String when evaluating. "Hello".intern() == "Hello".intern() returns true.