本章重點:構造函數，封裝，重載
本章難點:static關鍵字 this關鍵字

1.面向過程與面向對象的區別
面向過程是在Main函數中完成功能，從開始到結束，一步一步的實現功能
面向對象是各個類之間協同工作，相互影響，需要考慮哪些類，有什麽屬性和方法


2.如何使用面向對象進行編程
2.1 抽象出類(找名詞)
2.2 定義屬性(找特征)
2.3 定義方法(找行為或者動詞)

 1 /
 2 *
 3 * 現在有這樣一個例子，小張到買了一個冰淇淋，他挺高興的
 4 *   1.首先我們找名詞發現出小張(人)，冰淇淋(物)這兩個類
 5 *   2.第二步找人有哪些特征 我們發現了名字(小張)，滿意度(高興)的特征 
 
 6 *   3.第三步發現人有哪些行為 我們通過示例發現了“買”這個動作   
 7 */
 8 public class Person{
 9     private String name;//名字 
10     private  int love;//滿意度  
11 
12     public void setName(String name){
13         this.name = name;
14     }
15     
16     public String getName(){
17         
18         return this.name
19     }
 
20     
21     /**
22     *  購買的方法
23     */
24     public void buy(SomeThing st){
25 
26     }
27      
28 }
29 class Something{
30    
31   private String name;
32   
33   public String getName(){
34       return name;    
35   }  
36 }

3.構造函數
3.1 用於類進行初始化的相關操作
3.2 無返回值
3.3 如果類不定義構造函數，都會提供一個默認的構造函數
3.4 構造函數支持重載

 1 /**
 2  * Created by niechen on 17/4/18.
 3  */
 4 public class Test3 {
 5 
 6     public Test3() {
 7         System.out.println("這個是默認的構造函數");
 8     }
 9 
10     public Test3(int number) {
11         System.out.println("這是一個number構造函數");
12     }
13 
14     public Test3(String text) {
15         this(10);
16         System.out.println("這是一個Text構造函數");
18     }
19 
20     public Test3(String... text) {
21         System.out.println("這也是一個構造函數");
22     }
23 　　//該方法有返回值 所以只是個普通的方法
24     public void Test3() {
25         System.out.println("這只是一個普通的方法");
26     }
27 
28     public static void main(String[] args) {
29         new Test3();
30     }
31 }

4.static關鍵字
4.1 static關鍵字可以定義在成員變量，方法，靜態區域及內部類上
4.2 static方法不能直接調用非靜態成員的屬性與方法
4.3 static可用於所有對象的共享數據
4.4 類加載的時候，就被賦值了
4.5 靜態內存-》靜態代碼塊-》構造方法 (多個靜態代碼塊按照順序進行執行)

/**
 *　示例代碼
 *
 * Created by niechen on 17/4/18.
 */
public class Test4 {

    public static int age = 10;

    public static int number;

    static {
        age--;
        System.out.println("靜態代碼塊中輸出age:" + age);
    }

    static {
        age--;
        System.out.println("第二個靜態代碼塊中輸出age:" + age);
    }

    Test4() {
        number++;
        System.out.println("構造函數裏輸出age:" + age);
    }

    public static int test() {
        System.out.println(age);
        return age;

    }

    public static void main(String[] args) {
        new Test4();
        new Test4();
        Test4.test();
        System.out.println("創建對象的個數:" + Test4.number);
    }

    public static class Test2 {

    }

輸出結果：
靜態代碼塊中輸出age:9
第二個靜態代碼塊中輸出age:8
構造函數裏輸出age:8
構造函數裏輸出age:8
8
創建對象的個數:2

5.this關鍵字
5.1 可以區分於方法參數與成員變量
5.2 this指的是當前的引用對象，在內存中開辟一個內存塊引用自己
5.3 用於在構造函數中調用其他構造函數,必須放在第一行代碼中

 1 package org.lyrk.accp8.s2.chapter.one;
 2 
 3 /**
 4  * Created by niechen on 17/4/18.
 5  */
 6 public class Test5 {
 7     private int number;
 8     private String name;
 9 
10     public Test5(int number, String name) {
11         this.name = name;//this關鍵字作用之一當參數與屬性名相同時,區分內部屬性還是入參參數
12         this.number = number;
13     }
14 
15     public Test5() {
16         this(10, "你好");//this關鍵字作用之一調用本類中的其他構造函數
17         System.out.println("這個是默認構造函數");
18     }
19 
20     public Test5 setName(String name) {
21         this.name = name;
22         return this;//this關鍵字作用之一返回當前的引用對象
23     }
24 
25     public Test5 setNumber(int number) {
26         this.number = number;
27         return this;
28     }
29 
30     public static void main(String[] args) {
31         Test5 test5 = new Test5().setName("張三").setNumber(10);
32         System.out.println(test5.name);
33         System.out.println(test5.number);
34     }
35 
36 }

6.關於常量
6.1 用於描述無需改變的數值
6.2 它是靜態的不可變的，使用static final進行修飾 （書上只用final修飾）

7.關於封裝
7.1 對內實現具體細節，對外提供方法供於調用
7.2 內部成員變量用private修飾符修飾，對外提供getter setter方法
7.3 public > protected(第二章會講到) > package(不加訪問修飾符) > private

8.關於重載
8.1 必須在同一個類，方法名相同，參數列表不同(方法參數的個數或參數類型不同)，與方法返回值和方法修飾符沒有任何關系
8.2 重載匹配方法規則由精確到模糊，直到找到合適的方法為止

package org.lyrk.accp8.s2.chapter.one;

/**
 * Created by niechen on 17/4/17.
 */
public class Test8 {

    public static void test(int t1) {
        System.out.println(t1 + "int");
    }

    public static void test(char t1) {
        System.out.println(t1 + "char");
    }

    public static void test(double t1, double t2) {
        System.out.println(t1 + t2);
    }

    public static int test(String c,String s){return 0;}

    //public static int test(int t1){return 0;}

    public static void test(int t1, double t2) {
        System.out.println(t1 - t2);
    }

    public static void test(Integer t1, double t2) {
        System.out.println("Integer:" + (t1 - t2));
    }

    public static void main(String[] args) {
        test(10,2.0);
        test(‘c‘,2);
    }
}
輸出結果：
8.0
97.0

ACCP8.0 java課程第二學期-關於類和對象