import java.util.Date;

/*
 * 
 * 面試題： == 和 equals() 區別
 * 
 * 一、回顧 == 的使用：
 * == ：運算符
 * 1. 可以使用在基本數據類型變數和引用數據類型變數中
 * 2. 如果比較的是基本數據類型變數：比較兩個變數保存的數據是否相等。（不一定類型要相同）
 *    如果比較的是引用數據類型變數：比較兩個對象的地址值是否相同.即兩個引用是否指向同一個對象實體
 * 補充： == 符號使用時，必須保證符號左右兩邊的變數類型一致。
 * 
 * 二、equals()方法的使用：
 * 1. 是一個方法，而非運算符
 * 2. 只能適用於引用數據類型
 * 3. Object類中equals()的定義：
 *    public boolean equals(Object obj) {
            return (this == obj);
      }
 *    說明：Object類中定義的equals()和==的作用是相同的：比較兩個對象的地址值是否相同.即兩個引用是否指向同一個對象實體
 * 
 * 4. 像String、Date、File、包裝類等都重寫了Object類中的equals()方法。重寫以後，比較的不是
 *    兩個引用的地址是否相同，而是比較兩個對象的"實體內容"是否相同。
 *    
 * 5. 通常情況下，我們自定義的類如果使用equals()的話，也通常是比較兩個對象的"實體內容"是否相同。那麼，我們
 *    就需要對Object類中的equals()進行重寫.
 *    重寫的原則：比較兩個對象的實體內容是否相同.
 */
public class EqualsTest {
    public static void main(String[] args) {
        
        //基本數據類型
        int i = 10;
        int j = 10;
        double d = 10.0;
        System.out.println(i == j);//true
        System.out.println(i == d);//true
        
        boolean b = true;
//        System.out.println(i == b);
        
        char c = 10;
        System.out.println(i == c);//true
        
        char c1 = 'A';
        char c2 = 65;
        System.out.println(c1 == c2);//true
        
        //引用類型：
        Customer cust1 = new Customer("Tom",21);
        Customer cust2 = new Customer("Tom",21);
        System.out.println(cust1 == cust2);//false
        
        String str1 = new String("atguigu");
        String str2 = new String("atguigu");
        System.out.println(str1 == str2);//false
        System.out.println("****************************");
        System.out.println(cust1.equals(cust2));//false--->true
        System.out.println(str1.equals(str2));//true
        
        Date date1 = new Date(32432525324L);
        Date date2 = new Date(32432525324L);
        System.out.println(date1.equals(date2));//true
        
        
    }
}

toString()方法在Object類中定義，其返回值是String類型，返回類名和它的引用地址。 
在進行String與其它類型數據的連接操作時，自動調用toString()方法
Date now=new Date();
System.out.println(「now=」+now); 相當於System.out.println(「now=」+now.toString()); 
可以根據需要在用戶自定義類型中重寫toString()方法
如String 類重寫了toString()方法，返回字元串的值。
s1=「hello」;
System.out.println(s1);//相當System.out.println(s1.toString()); 基本類型數據轉換為String類型時，調用了對應包裝類的toString()方法
int a=10; System.out.println(「a=」+a);

/*
 * Java中的JUnit單元測試
 * 
 * 步驟：
 * 1.選中當前工程 - 右鍵選擇：build path - add libraries - JUnit 4 - 下一步
 * 2.創建Java類，進行單元測試。
 *   此時的Java類要求：① 此類是public的  ②此類提供公共的無參的構造器
 * 3.此類中聲明單元測試方法。
 *   此時的單元測試方法：方法的許可權是public,沒有返回值，沒有形參
 * 
 * 4.此單元測試方法上需要聲明註解：@Test,並在單元測試類中導入：import org.junit.Test;
 * 
 * 5.聲明好單元測試方法以後，就可以在方法體內測試相關的程式碼。
 * 6.寫完程式碼以後，左鍵雙擊單元測試方法名，右鍵：run as - JUnit Test（eclipse中）
 * 
 * 說明：
 * 1.如果執行結果沒有任何異常：綠條
 * 2.如果執行結果出現異常：紅條
 */

import java.util.Date;

public class JUnitTest {
    
    int num = 10;
    
    @Test
    public void testEquals(){
        String s1 = "MM";
        String s2 = "MM";
        System.out.println(s1.equals(s2));
        //ClassCastException的異常
//        Object obj = new String("GG");
//        Date date = (Date)obj;
        
        System.out.println(num);
        show();
    }
    
    public void show(){
        num = 20;
        System.out.println("show()....");
    }
    
    @Test
    public void testToString(){//測試誰就單擊選中誰
        String s2 = "MM";
        System.out.println(s2.toString());
    }
}

import org.junit.Test;

/*
 * 包裝類的使用:
 * 1.java提供了8種基本數據類型對應的包裝類，使得基本數據類型的變數具有類的特徵
 * 
 * 2.掌握的：基本數據類型、包裝類、String三者之間的相互轉換
 * 
 * 
 * 
 */
public class WrapperTest {
    
    //String類型 --->基本數據類型、包裝類：調用包裝類的parseXxx(String s)
    @Test
    public void test5(){
        String str1 = "123";
        //錯誤的情況：
//        int num1 = (int)str1;不行
//        Integer in1 = (Integer)str1;強轉需要子父類之間的關係
        //可能會報NumberFormatException
        int num2 = Integer.parseInt(str1);
        System.out.println(num2 + 1);
        
        String str2 = "true1";
        boolean b1 = Boolean.parseBoolean(str2);
        System.out.println(b1);
    }
    
    //基本數據類型、包裝類--->String類型：調用String重載的valueOf(Xxx xxx)
    @Test
    public void test4(){
        
        int num1 = 10;
        //方式1：連接運算
        String str1 = num1 + "";
        //方式2：調用String的valueOf(Xxx xxx)
        float f1 = 12.3f;
        String str2 = String.valueOf(f1);//"12.3"
        
        Double d1 = new Double(12.4);
        String str3 = String.valueOf(d1);
        System.out.println(str2);
        System.out.println(str3);//"12.4"
        
    }
    
    /*
     * JDK 5.0 新特性：自動裝箱 與自動拆箱
     */
    @Test
    public void test3(){
//        int num1 = 10;
//        //基本數據類型-->包裝類的對象
//        method(num1);
        
        //自動裝箱：基本數據類型 --->包裝類
        int num2 = 10;
        Integer in1 = num2;//自動裝箱
        
        boolean b1 = true;
        Boolean b2 = b1;//自動裝箱
        
        //自動拆箱：包裝類--->基本數據類型
        System.out.println(in1.toString());
        
        int num3 = in1;//自動拆箱
        
    }
    
    public void method(Object obj){
        System.out.println(obj);
    }
    
    //包裝類--->基本數據類型:調用包裝類Xxx的xxxValue()
    @Test
    public void test2(){
        Integer in1 = new Integer(12);
        
        int i1 = in1.intValue();
        System.out.println(i1 + 1);
        
        
        Float f1 = new Float(12.3);
        float f2 = f1.floatValue();
        System.out.println(f2 + 1);
    }
    
    //基本數據類型 --->包裝類：調用包裝類的構造器
    @Test
    public void test1(){
        
        int num1 = 10;
//        System.out.println(num1.toString());
        Integer in1 = new Integer(num1);
        System.out.println(in1.toString());
        
        Integer in2 = new Integer("123");
        System.out.println(in2.toString());
        
        //報異常
//        Integer in3 = new Integer("123abc");
//        System.out.println(in3.toString());
        
        Float f1 = new Float(12.3f);
        Float f2 = new Float("12.3");
        System.out.println(f1);
        System.out.println(f2);
        
        Boolean b1 = new Boolean(true);
        Boolean b2 = new Boolean("TrUe");
        System.out.println(b2);
        Boolean b3 = new Boolean("true123");
        System.out.println(b3);//false
        
        
        Order order = new Order();
        System.out.println(order.isMale);//false
        System.out.println(order.isFemale);//null
    }
    
}

class Order{
    
    boolean isMale;
    Boolean isFemale;
}

Object o1 = true ? new Integer(1) : new Double(2.0);
System.out.println(o1);
//1.0
//解析：編譯時就要求類型是一致的，int型自動轉換為double類型的

public void method1() {
Integer i = new Integer(1);
Integer j = new Integer(1);
System.out.println(i == j);// false
/*
Integer內部定義了IntegerCache結構，IntegerCache中定義了Integer[],保存了從-128~127範圍的整數。如果我們使用自動裝箱的方式，給Integer賦值的範圍在-128~127範圍內時，可以直接使用數組中的元素，不用再去new了。目的：提高效率
*/        

Integer m = 1;
Integer n = 1;
System.out.println(m == n);//true
//

Integer x = 128;//相當於new了一個對象
Integer y = 128;//相當於new了一個對象
System.out.println(x == y);//false
//

}