JAVA常用知识总结（二）

JAVA中的参数传递总结
先看两道笔试题：

 1 public class Test2 { 
 2 
 3    public static void main (String [] args)  { 
 4          StringBuffer a = new StringBuffer ("A"); 
 5          StringBuffer b = new StringBuffer ("B"); 
 6          operate (a,b); 
 7          System.out.println(a+","+b); 
 8    }
 9 
10    static void operate(StringBuffer x, StringBuffer y){ 
11          x.append(y); 
12          y = x; 
13    }
14 }

该题会输出什么？

 1 public class Test2 { 
 2 
 3      public static void add3 (Integer i){ 
 4           int val=i.intValue();
 5           val += 3; 
 6           i = new Integer (val); 
 7       } 
 8 
 9      public static void main (String args [ ] )  { 
10           Integer  i = new Integer (0); 
11           add3 (i); 
12           System.out.println (i.intValue ( )); 
13      } 
14 }

这个又会输出什么？
答案是： 1：AB,B 2：0
首先我们应该明白JAVA中的参数传递全是以值传递的。是基本类型，就拷贝一个基本类型传进方法；是引用，就拷贝一个引用变量传进去方法，理解了这两点就能理解方法操作对象的相关问题了。最好能画出引用指向对象的图出来，就能完全理解了。

第1题，调用operate方法时，传入了两个引用a,b的拷贝x,y，注意这里a，b不是基本类型而是引用！！作为拷贝，x和y也都是引用，指向对象StringBuffer("A")和StringBuffer("B")，这两个x,y都指向原a,b引用所指向的对象。x.append(y)对它指向的对象(即a指向的对象)进行了操作。而x=y，只是两个拷贝变量在赋值，并没有影响到原b所指向的对象。所以b所指向的对象仍然为B。

　　　第2题，i=new Integer(val) 这里等于重新把i的引用指向别的对象了，所以原有对象的数没改，而原来的i仍然是指向对象new Integer(0)的。

　　　把握住了JAVA都是传值并且传的都是拷贝的话，类似的题大家都能迎刃而解了。

JAVA中的代码执行顺序

 1 class SingleTon {
 2     private static SingleTon singleTon = new SingleTon();
 3     public static int count1;
 4     public static int count2 = 0;
 5 
 6     private SingleTon() {
 7         count1++;
 8         count2++;
 9     }
10 
11     public static SingleTon getInstance() {
12         return singleTon;
13     }
14 }
15 
16 public class Test {
17     public static void main(String[] args) {
18         SingleTon singleTon = SingleTon.getInstance();
19         System.out.println("count1=" + singleTon.count1);
20         System.out.println("count2=" + singleTon.count2);
21     }
22 }
23 
24 正确答案
25 count1=1
26 
27 count2=0
28 
29 
3031 class Singleton
32 {    
33     
34     public static int counter1;
35     public static int counter2=0;
36     private static  Singleton singleton=new Singleton();
37     private Singleton()
38     {
39         counter1++;
40         counter2++;
41     }
42     public static Singleton getInstance()
43     {
44         return singleton;
45     }    
46 }
47  
48 public class MyTest
49 {
50  
51     public static void main(String[] args)
52     {
53         Singleton singleton=Singleton.getInstance();    
54         System.out.println("counter1="+singleton.counter1);
55         System.out.println("counter2="+singleton.counter2);
56     }
57  
58     
59 }
60 
61 counter1 = 1;
62 counter2 = 1;

原因:

首先调用类的静态方法（Singleton.getInstance()），会加载这个类（这里指Singleton类）。

执行过程：
1.给所有的静态变量赋予一个默认值（int类型的默认值为0）counter1=0,counter2=0(赋值操作未执行),singleton=null
2.初始化（从上到下开始执行，把右边的值赋值给左边）
3.new Singleton()要生成对象（实例），会自动调用它的构造方法。

题目一：此时counter1没有赋值，故counter1还是等于0.counter2被赋值为0，故counter2=0.

题目二：此时counter1++，所以counter=1；counter2++,counter2=1；所以最后counter1=1,counter2=1.

Java变量的初始化顺序为：静态变量或静态语句块–>实例变量或初始化语句块–>构造方法
有父子级关系的变量的初始化顺序为：父类--静态变量->父类--静态初始化块->子类--静态变量->子类--静态初始化块->父类--变量->父类--初始化块->父类--构造器->子类--变量->子类--初始化块->子类--构造器