一、面對對象編程的三個特性

1. 封裝性：經數據和對數據的操作封裝在一起。通過抽象，從實例中抽取共同性質形成一般概念，例如類。
2. 繼承：子類可繼承父類的屬性和行為，繼承父類所具有的數據和數據上的操作，同時增添子類獨有的數據和數據上的操作。
3. 多態：一是操作名稱的多態，多個操作具有相同名字，這些操作所接受的消息必須不同；二是和繼承有關的多態，同意操作被不同對象調用時產生不同行為。

二、類聲明

1. 類是JAVA程序的基本要素，JAVA應用程序有若幹類組成，類聲明的變量為對象變量。
2. 類的定義兩部分：類聲明、類體

   class 類名 {             //class為關鍵字，用來定義類，類名要符合標識符規定
           類體內容
   }
    
   

三、類體

1. 類使用類體來描述所抽象出的屬性和行為。
2. 類體的內容：變量的聲明、方法的定義。

四、成員變量

1. 所聲明的變量成為成員變量和域變量。
2. 類型：基本類型、引用類型（數組、對象、接口）。

   class Factory {
       float [] a;
       Workman zhang;  //zhang是Workman類聲明的變量，即對象
   }
   class Workman {
       double x;
   }

3. 有效範圍：在整個類中都有效。

五、方法

1. 方法返回的數據類型可以是JAVA中任意一種數據類型。
2. 方法體內可以對成員變量和方法體內聲明的局部變量進行操作。
3. 局部變量與聲明位置有關，從聲明位置之後開始有效
   。
4. 如果局部變量和成員變量的名字相同，那麽成員變量被隱藏，在該方法內暫時失效。若還想用該成員變量，則必須使用關鍵字this。

   class Tom {
       int x = 10,y;
       void f() {
           int x = 5;
           y = x+this.x;  //y得到的值是15
       }
   }

5. 成員變量有默認值，局部變量沒有默認值。使用局部變量前，必須初始化局部變量值。
6. 對成員變量的操作只能放在方法中。

   class A {
       int a;
       float b;
       a = 12;      //非法，這是賦值語句（不是變量聲明，只能出現在方法中）
    
   
       b = 12.56f;  //非法
   }

   
   
   

六、構造方法

1. 用類聲明對象後，必須創建對象，即為聲明的對象分配所擁有的變量。
2. 構造方法是類中一種特殊方法，程序用類創建對象時，需使用它的構造方法。
3. 構造方法：與所在類的名字完全相同，而且沒有類型。
4. 一個類中可以有多個構造方法，但必須保證它們參數不同。
5. 若類中沒有編寫構造方法，系統會默認一個構造方法，此方法無參數，且方法內無語句。

   class Point {
       int x,y;
       Point() {                  //是構造方法
           x = 1;
           y = 1;
       }
       void Point(int a,int b) {  //不是構造方法（該方法的類型是void）
           x = a;
           y = b;
       }
       int Point() {
           return 12;
       }
   }

七、創建對象

1. 對象聲明：類名 對象名;
2. 為聲明的對象分配變量：使用new運算符和類的構造方法為聲明的對象分配變量，即創建對象。
3. new運算符的作用：一是為變量分配內存。二是計算出引用的值（該值代表成員變量內存位置及相關重要信息），即表達式new XiyoujiRenwu()是一個值，賦值給對象。
4. nwe運算符只能和類的構造方法進行運算，運算的最後結果是一個十六進制的數，這個數是對象的引用。
5. 對象引用存在於棧中，對象的實體存在堆中。

八、使用對象

1. 對象操作自己的變量：對象的變量是對象的實體，對象通過使用點運算符“.”訪問自己的變量，格式為：對象.變量;
2. 對象調用類中的方法：對象.方法;
3. 體現封裝：當對象調用方法時，方法中出現的成員變量就是指分配給該對象的變量。
4. new XiyoujiRenwu()為一個匿名對象，可以用“.”來訪問自己的變量，但要盡量避免使用。

九、對象的引用和實體

1. 避免使用空對象。
2. 一個類聲明的兩個對象如果具有相同的引用，二者就具有完全相同的變量。
3. 垃圾收集：若某個實體是否已不再被任何對象所擁有，就釋放該實體占有的內存。
4. JAVA不像C++有類的析構方法，會自動釋放內存。

十、類與程序的基本結構

1. JAVA應用程序有一個主類，即含有main方法的類，JAVA應用程序從main方法開始執行。
2. 若應用程序主類的源文件和其他源文件在同一目錄中，也可以只編譯主類源文件，JAVA系統會自動先編譯主類需要的其他源文件。
3. JAVA程序的類既可以存放在一個源文件中，也可以存放在不同源文件中。
4. javac *.java可編譯該目錄下的全部源文件。

十一、參數傳值

1. 在JAVA中，方法的所有參數都是“傳值”的。
2. JAVA的引用型數據有：數組、對象、接口。
3. 可變參數：使用“...”表示若幹參數，這些參數類型必須相同，且最後一個參數必須是方法參數列表中最後一個參數。

   public void g(double a,int ... x)

   public void method(int ... x,int y)  //×錯誤，最後一個參數y不是可變參數x所代表的參數之一

4. 參數代表可以通過下標運算來表示參數列表中具體參數：x[0]、x[1]、...、x[m-1]來表示第1至m個參數。x.length表示參數個數。
5. 對於可變參數，JAVA提供增強for語句。

   public int getSum(int ... x) {
       int sum = 0;
       for(int param:x) {     //for(聲明循環變量：參數代表)
           sum = sum+param;
       }
   }

十二、對象的組合

1. 如果對象a組合了對象b，那麽對象a可以以組合的方式復用對象b的方法。
2. 復用方法特點：一是對當前對象所包含對象的特點一無所知。二是當前對象隨時可更換所包含對象。
3. 如果A類的成員變量是用B類聲明的對象，那麽A和B是關聯關系，在UML圖中用實線連接。
4. 如果A類的某方法的參數是用B類聲明的對象或A類的某方法返回的數據類型是B類對象，那麽A和B是關聯關系，在UML圖中用虛線連接。

十三、實例成員與類成員

1. 成員變量分為：實例變量、類變量。
2. 在聲明成員變量時，用關鍵字static給予修飾的稱作類變量。

   class Dog {
       float x;        //實例變量
       static int y;  //類變量
   }

3. 實例變量僅僅是對象相關聯的變量，類變量是和該類創建的所有對象相關聯的變量。
4. 可以通過類名直接訪問類變量。
5. JAVA庫提供的Arrays類，許多方法都是static方法。

   import java.util.*;                                             //Arrays類在java.util包中
   public class Example4_11 {
       public static void main(String args[]) {
           Scanner scanner = new Scanner(System.in);
           int [] a = {12,34,9,23,45,6,45,90,123,19,34};
           Arrays.sort(a);                                         //將double類型數組按升序排序
           System.out.println(Arrays.toString(a));                 //返回a數組的字符串
           System.out.println("輸入整數，程序判斷是否在數組中：");
           int number = scanner.nextInt();
           int index = Arrays.binarySearch(a,number);               //判斷number是否在數組a中，若是，返回索引；若不是，返回一個負數
           if(index>=0)
               System.out.println(number+"和數組中索引為"+index+"的元素值相同");
           else
               System.out.println(number+"不與數組中任何元素值相同");
       }
   }

十四、方法重載

1. JAVA中存在兩種多態：重載、重寫。
2. 對象的行為通過類中方法來體現，行為的多態性就是方法的重載。
3. 方法重載：一個類中，多個方法可具有相同名字，但這些方法的參數必須不同。
4. 構造方法可以重載。

十五、this關鍵字

1. this可以出現在實例方法和構造方法中，但不可以出現在類方法中。
2. 在構造方法中使用this：

   public class People {
       int leg,hand;
       String name;
       People(String s) {
           name = s;
           this.init();               //可以省略this，寫成“init()”
       }
       void init() {
           leg = 2;
           hand = 2;
           System.out.println(name+"有"+hand+"只手"+leg+"條腿");
       }
       public static void main(String args[]) {
           People boshi = new People("布什");      //創建boshi時，構造方法中的this就是對象boshi
       }
   }

3. 類的實例方法可以調用類的其他方法，默認格式為：

   this.方法    //“this.”可省略

   類方法調用的格式為

   類名.方法   //“類名.”可省略

4. this不能出現在類方法中，類方法可通過類名直接調用，此時可能還沒用任何對象產生。

十六、包

1. 包：有效管理類的一個機制，目的是有效區分名字相同的類。
2. package語句是JAVA源文件的第一條語句，指定類所在的包。包名可以是合法標識符，也可以由若幹標識符加“.”分隔而成。

   package sunrise;
   package sun.com.cn;

3. 若省略了package語句，隱含地認為是無名包的一部分。
4. 程序如果使用了包語句，例如：

   package tom.jiafei;

   則存儲文件的目錄結構中須包含：...\tom\jiafei，並要將字節碼文件保存在此目錄中。

5. 可以進入tom\jiafei的上一層目錄中編譯源文件：

   C:\1000> javac tom\jiafei\源文件

6. 主類：必須到tom\jiafei的上一層目錄中去運行：

   C:\1000> java tom.jiafei.主類名

7. JAVA語言不允許用戶使用java作為包名的一部分

十七、import語句

1. 作用：引入包中類和接口。
2. java.lang是JAVA語言的核心類庫，系統自動引入，無需再使用import語句。
3. 如果引入整個包的類，會增加編譯時間，但不影響程序運行性能。
4. 如果不用impot語句，也可直接帶包名使用：

   java.util.Date date = new java.util.Date();

5. 若想要引用自定義包中的類，則可更新classpath的值，指明包所在位置。
6. 若不希望更新classpath，則需要把程序所使用包名所形成的目錄放在同一個文件夾下。
7. 有包名的類無論如何都不能使用無包名的類。

十八、訪問權限

1. 指對象是否能用“.”運算符操作自己的變量或通過“.”運算符調用類中的方法。
2. 訪問修飾限制符：private、protected、public，用來修飾成員變量和方法。
3. 在編寫類時，類中實例方法總是可以操作類中實例變量和類變量，類方法總是可以操作該類中類變量，與訪問限制符無關。
4. private：私有變量和私有方法，對象不能訪問私有變量和私有方法。
5. public：公有變量和共有方法，在其他同包和不同包類中都能通過對象名和類名來訪問共有變量和共有方法。
6. 友好變量和友好方法：不被訪問修飾限制符所修飾，只能在同包的類中通過對象名和類名訪問友好成員變量和友好方法。
7. protected：受保護成員變量和受保護方法，不被訪問修飾限制符所修飾，只能在同包的類中通過對象名和類名訪問友好成員變量和友好方法。
8. public類：可在任何另外一個類中使用public類創建對象。
9. 友好類：在另外一個類中使用友好類創建對象時，保證它們在同一包中。
10. 不能用private和protected修飾類。
11. 訪問權限由高到低排序：public、protected、友好的、private。

十九、基本類型的類封裝

• Double(double num);   //創建double類型對象
  doubleValue();        //返回該對象含有的double型數據

  Character(char c);
  charVaule();

二十、對象數組

1. 創建對象數組

   Student [] stu;
   stu = new Student[10];

   Student stu[] = new Student[10];

2. 在使用對象數組前，應當創建數組所包含的對象

   stu[0] = new Student();

二十一、JRE擴展與jar文件

1. JAVA運行環境提供擴展（\jre\lib\ext），只要將類打包為jar格式文件，放入擴展中，程序就可以使用import語句使用擴展中的類了。
2. 將同包的源文件編譯。
3. 編寫一個清單文件：hello.mf(Manifestfiles)

   Manifest-Version: 1.0
   Class: moon.star.TestOne moon.star.TestTwo  //包名+class文件名，以空格隔開
   Created-By: 1.8                             //jdk1.8

   將此文件保存在包所在的目錄中。（所有的冒號下面都要一個空格）

4. 進入包所在目錄，使用jar命令來生成Jerry.jar文件

   jar cfm Jerry.jar hello.mf moon\star\TestOne.class moon\star\TestTwo.class

   若包中只有class文件，也可以如下使用jar命令

   jar cfm Jerry.jar hello.mf moon\star\*.class

5. 將Jerry.jar文件復制到JDK安裝目錄的jre\lib\ext文件夾中。
6. 此時，就可以用import語句引入Jerry.jar中的類了：

   import moon.star.*;
   public class Use {
       public static void main(String args[]) {
           TestOne a = new TestOne();
           a.fTestOne();
           TestTwo b = new TestTwo();
           b.fTestTwo();
       }
   }

二十二、文檔生成器

1. 使用JDK提供的javadoc.exe來制作源文件類結構的html格式文檔

   javadoc Example.java

   查看這些文檔可知道源文件中類的組成結構。

2. 也可以使用參數-d指定生成文檔所在目錄，如：

   javadoc -d F:\gxy\book Example.java

   

二十三、靜態塊

• 類的字節碼進入內存時，類中靜態塊會被立即執行：

  class AAA {
      static {   //靜態塊
          System.out.println("我是AAA中的靜態塊！");
      }
  }
  public class E3 {
      static {    //靜態塊
          System.out.println("我是最先被執行的靜態塊！");
      }
      public static void main(String args[]) {
          AAA a = new AAA();  //AAA的字節碼進入內存
          System.out.println("我在了解靜態(static)塊");
      }
  }

  

習題：

3.1

3.2

3.3

3.5

3.6

4

public class Test {
    public static void main(String args[]) {
        CPU cpu = new CPU();
        HardDisk disk = new HardDisk();
        PC pc = new PC();
        cpu.setSpeed(2200);
        disk.setAmount(200);
        pc.setCPU(cpu);
        pc.setHardDisk(disk);
        pc.show();
    }
}
class CPU {
    int speed = 0;
    void setSpeed(int m) {
        speed = m;
    }
    int getSpeed() {
        return speed;
    }
}
class HardDisk {
    int amount = 0;
    void setAmount(int m) {
        amount = m;
    }
    int getAmount() {
        return amount;
    }
}
class PC {
    CPU cpu;
    HardDisk HD;
    void setCPU(CPU c) {
        cpu = c;
    }
    void setHardDisk(HardDisk h) {
        HD = h;
    }
    void show() {
        System.out.println("硬盤速度為："+cpu.getSpeed());
        System.out.println("硬盤容量為："+HD.getAmount());
    }
}

第四章 類與對象