1.方法參數傳值

1.1 方法傳參

public  void changeParam(int i,String str,StringBuilder sb,StringBuilder sb2){
    i=1;
    str="1";
    sb.append("1");
    sb2=new StringBuilder("1");
}
@Test
public void change(){
    int i = 0;
    String str = "0";
    StringBuilder sb 
 
= new StringBuilder("0"),
            sb2 = new StringBuilder("0");
    changeParam(i, str, sb,sb2);
    System.out.format("i:%-3d str:%-3s sb:%-3s sb2:%-3s", i, str, sb, sb2);
}
結果：
i:0   str:0   sb:01  sb2:0 

1. 基本類型方法傳參是以復制值的形式，即change中的i變量復制給changeParam的i，但實際上changeParam的i擁有change的i的值，但changeParam中的i無論怎麽變則不會改變change的i的值；
2. String雖然是引用類型，但是String自己本身的特性是不能被改變，所以要改變String的值的話，則在java裏面是生成一個新的String，再把此值賦值給str，所以str這種參數和方傳參並沒有什麽關系，就算是在一個方法內也是如此。
3. 引用類型參數情況分為2種:
1. sb引用，在changeParam中sb修改屬性後，在change中的sb也一同跟著改變，原因是因為change方法和changeParam方法中的sb引用指向的是同一個對象，所以它們修改對象時，自然會在該對象的所有引用中體現。
2. sb2雖然調用changeParam方法時也是傳遞的是StringBuilder的引用，但是在changeParam中sb2重新指向新的對象，所以此時changeParam和change中的引用指向的不再是同一個對象了，所以它們之間的改變是互不影響的。

1.2 可變參數可會發生的問題

//參數類型後面是3個省略後就是可變參數
public void changeParam(String ... args){
    System.out.println(Arrays.deepToString(args));
    System.out.println(args[0]);
}
@Test
public void changeParamTest(){
    changeParam("a");
    changeParam("a","b","c");
}
結果：
[a]
a
[a, b, c]
a

/**
 * 可變參數可能會發生的問題
 * 當changeParam方法參數一個是Integer args一個是Integer ... args，編譯器是通過的
 * 當程序調用changParam方法但只有一個參數，而我此時是需要調用的是帶有Integer ... args方法
 * 但是程序會認為是我調用的Integer args方法，並執行該方法
 * @param args
 */
public void changeParam(Integer args){
    System.out.println("Integer:"+args);
}
public void changeParam(Integer ...args){
    System.out.println("Integer...:"+args);
}
//解決方式
public void changeParam(Long type,Integer ...args){
    for (Integer val:args) {
        System.out.println("int:"+val);
    }
}

@Test
public void changeParamRun(){
    changeParam(1L,1);
}

2.程序初始化流程

public class HelloA {
    public HelloA() {System.out.println("HelloA");}
    { 
        System.out.println("I‘m A class"); 
    }
    static { 
        System.out.println("static A"); 
    }
}
public class HelloB extends HelloA {
    public HelloB() {
        System.out.println("HelloB");
    }
    { 
        System.out.println("I‘m B class"); 
    }
    static {
        System.out.println("static B"); 
    }
}
public class Test {
    public static void main(String[]args){
        new HelloB();
    }
}
結果：
static A
static B
I‘m A class
HelloA
I‘m B class
HelloB

3.java垃圾回收機制

3.1 finalize方法的作用

class HandlerTest{
    static HandlerTest staticBl=new HandlerTest();//設置靜態變量
    boolean checkedOut=false;
    /**
     * 覆寫finalize方法
     * @throws Throwable
     */
    @Override
    protected void finalize() throws Throwable {
        //控制清理條件，且清理內容
        if(checkedOut){
            System.out.println("執行清理");
            /**
             * java垃圾回收器只回收new出來的對象放在堆裏面，
             * 而靜態區域是不做處理，那麽可以通過finalize方法將其作為處理，
             * 並再下一次垃圾回收時回收
             */
            staticBl=null;
            super.finalize();
            flag=false;
        }
    }
    @Override
    public String toString() {
        return "staticBl";
    }
}
static boolean flag=true;
@Test
public void runGC(){
    while (flag){
        HandlerTest handler=new HandlerTest();
        handler.checkedOut=true;

        HandlerTest handler2=new HandlerTest();
        System.out.println(HandlerTest.staticBl);
        System.gc();
    }
}
結果:
staticBl
staticBl
staticBl
staticBl
staticBl
staticBl
執行清理
staticBl
執行清理
執行清理
執行清理
執行清理
執行清理

3.2 內存分配

3.3 垃圾回收如何工作

3.3.1 引用記數技術

3.3.2 遍歷引用鏈條追蹤對象

3.3.3 區分活的對象和死的對象後，垃圾回收器是如何清理的？

1. 得有兩個完全隔離的堆，得在這兩個堆之間來回搗騰，即假設實際運行時需要100個空間，那麽還得預留此空間單純是用來搗騰，效率低下，
2. 復制，當程序趨於穩定，沒有多少垃圾產生，甚至沒有垃圾。盡管如此，復制式回收器仍會將所有內存一處復制到另一處，假如有100個對象，其中有5個是垃圾對象，那麽還是得把95個移動到另一個堆中，只為了清除那5個垃圾。性能浪費

3.3.4 自適應，分代的

4 總結：

02-方法傳參和初始化與垃圾回收清除