查看完整版本: [原创]java中一些可能被忽略的地方~

[原创]java中一些可能被忽略的地方~

1）全局的变量如果不初始化的话，JVM会给一个默认值，但局部变量不初始化JVM则会报错！
     比如说以下代码：
public class test{
        private int x; //全局类变量

        public static void main(String[] args){
                int y;    //局部变量
                System.out.println(y);
                System.out.println(new test().x);
        }
}
这个程序编译时将出现variable y might not have been initialized的错误！将y初始化而x不初始化时，则会输出x为0。

2）同一个文件里定义两个类，只有一个类可以被声明成public，并且文件名也应该用public类的名字~
另一个类不能被声明成public及protected。
3）String 对象可以用+=号。比如：
String s = "hello !";
s += "world."
此时s指向一个新的"hello ! wrold"的String对象，而"hello !"对象将被垃圾回收器回收

4）JAVA有类似于的goto语句。
比如说可以用一个break跳出两层循环。
看下面的代码:
lable:
                        for(int i=0;i<10;i++){
                                for(int j=0;j<10;j++)
                                if(i!=5){
                                        if(j!=5)
                                                System.out.println(i+" "+j);
                                        else break;
                                        if(i==3)        break lable;
                                }
                        }
当j=5时跳出内层循环，当i=3时从内层循环直接跳出两层循环

带标签的continue会到达标签的位置，并重新进入紧跟在标签后面的循环
带标签的break会中断并跳出标签所指的循环

[[i] 本帖最后由 大饼先生 于 2006-9-2 18:16 编辑 [/i]]

5）关于初始化顺序：
如果一个类继承了另一个类的时候，初始化顺序是这样的：
先初始化基类的static块，再初始化子类的static块，再调用基类的构造子，最后调用子类的构造子~
看看下面这个例子：
有两个类：
class A{
        static{
                System.out.println("1st mark");
        }
        public A(){
                System.out.pirntln("A mark");
        }
}

public class B extends A{
        static{
                System.out.println("2nd mark");
        }
        public B(){
                System.out.println("B mark");
        }
        public static void main(String[] args){
                System.out.println("Begin!");
                B b = new B();
        }
}

该代码输出为：
1st mark
2nd mark
Begin!
A mark
B mark

class A{       
        public A(){
                System.out.println("A mark");
        }       
}
class B{
        public B(){
                System.out.println("B mark");
        }
}

class C extends A{
       
        static {
                System.out.println("2nd mark");
        }
        B b = new B();
        public C(){
                System.out.println("C mark");
        }
}
class D extends C{
        static {
                System.out.println("1st mark");
        }
        public D(){
                System.out.println("D mark");
        }
}
class E extends B{
        A a = new A();
        public E(){
                System.out.println("E mark");
        }
}
public class test extends D{
        E e = new E();
        public test(){
                System.out.println("test mark");
        }
        public static void main(String[] args){
                test t = new test();
        }
}

试试这个程序的输出~~

5续）还是关于初始化~~看下面程序：

abstract class fruit{
       
        abstract void grow();
        public fruit(){
                System.out.println("before grow()");
                grow();
                System.out.println("after grow()");
        }
}

class apple extends fruit{
        private int i = 1;
       
        public apple(int i){
                this.i = i;
                System.out.println("count number = "+ i);
        }

        void grow(){
                System.out.println("apple growing, count number = "+ i);
        }
}


public class test{
        public static void main(String[] args){
                fruit a = new apple(5);
        }
}

程序流程为：
从main()进入，生成一个apple()对象，new apple()将执行的动作：
1）为各个对象的成员变量进行分配空间，值均为二进制的零
2）在执行apple之类构造之前，先执行基类构造，在基类构造里又会调用子类的被重载的grow()方法。由于1)的缘故，此时i=0。
3）初始化子类的成员变量
4）调用子类构造

所以程序输出为：
before grow()
apple growing, count number = 0
after grow()
count number = 5

::84::
5楼……