有意思的Java代码

java

1.main方法

class A {
    public static void main(String[] args) {
        for (String str : args) {
            System.out.println(str);
        }
    }
}
public class Ac {
    public static void main(String[] args) {
        String[] strs = "I am XQF".split(" ");
        A.main(strs);
    }
}

2.在main方法前输出

public class Ac {
    static {
        System.out.println("没有进入main方法");
    }
    public static void main(String[] args) {
    }
}

3.与构造方法名字相同的成员方法

class T {
    public T() {
        System.out.println("T constructor!");
    }
    public void T() {
        System.out.println("Call T ");
    }
}
public class Test {
    public static void main(String[] args) {
        T t = new T();
        t.T();
    }

结果，说明这样是没毛病，只是不建议

T constructor!
Call T

4.陷阱覆盖重载陷阱

首先，方法名字相同，即有可能是重载也有可能是覆盖。

说他是覆盖，但是返回类型也不一样。
说他是重载，但是参数列表又同样是空。

所以都不是，。，。
要改成覆盖，就应该使返回类型相同，
要改成重载，就应该其具有不同的参数列表

返回类型不能作为任何判断依据

class T {
    public int print() {
        return 1;
    }
}
public class Test extends T {
    public float print() {
        return 2f;
    }
    public static void main(String[] args) {
        T t = new Test();
        System.out.println(t.print());
    }
}

5.自定义label跳出多重循环

  public static void main(String[] args) {
        int a = 0;
        out:
        for (int i = 0; i < 100; i++) {
            for (int j = 0; j < 100; j++) {
                if (j == 5) {
                    a = j;
                    break out;
                }
            }
        }
        System.out.println("Over");
        System.out.println("a:" + a);
    }

结果

Over
a:5
Java中保留goto关键字，为了将来可能会加入。这种标签跳出看上去好像很好用似的。