JAVA常用知识总结（二）

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

    public class Test2 { 
   
       public static void main (String [] args)  {
             StringBuffer a = new StringBuffer ("A");
             StringBuffer b = new StringBuffer ("B");
             operate (a,b);
             System.out.println(a+","+b);
       }
   
       static void operate(StringBuffer x, StringBuffer y){
             x.append(y);
             y = x;
       }
    }

   该题会输出什么？

    public class Test2 { 
   
         public static void add3 (Integer i){
              int val=i.intValue();
              val += 3;
              i = new Integer (val);
          } 
   
         public static void main (String args [ ] )  {
              Integer  i = new Integer (0);
              add3 (i);
              System.out.println (i.intValue ( ));
         }
    }

   这个又会输出什么？
   答案是： 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都是传值并且传的都是拷贝的话，类似的题大家都能迎刃而解了。

1. JAVA中的代码执行顺序

2.  class SingleTon {
        private static SingleTon singleTon = new SingleTon();
        public static int count1;
        public static int count2 = 0;
   
        private SingleTon() {
            count1++;
            count2++;
        }
   
        public static SingleTon getInstance() {
            return singleTon;
        }
    }
   
    public class Test {
        public static void main(String[] args) {
            SingleTon singleTon = SingleTon.getInstance();
            System.out.println("count1=" + singleTon.count1);
            System.out.println("count2=" + singleTon.count2);
        }
    }
   
    正确答案
    count1=1
   
    count2=0
   
    class Singleton
    {    
   
        public static int counter1;
        public static int counter2=0;
        private static  Singleton singleton=new Singleton();
        private Singleton()
        {
            counter1++;
            counter2++;
        }
        public static Singleton getInstance()
        {
            return singleton;
        }
    }
   
    public class MyTest
    {
   
        public static void main(String[] args)
        {
            Singleton singleton=Singleton.getInstance();
            System.out.println("counter1="+singleton.counter1);
            System.out.println("counter2="+singleton.counter2);
        }
   
    }
   
    counter1 = 1;
    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变量的初始化顺序为：静态变量或静态语句块–>实例变量或初始化语句块–>构造方法
   有父子级关系的变量的初始化顺序为：父类--静态变量->父类--静态初始化块->子类--静态变量->子类--静态初始化块->父类--变量->父类--初始化块->父类--构造器->子类--变量->子类--初始化块->子类--构造器