head first java讀書筆記

時間 2019-11-08

標籤 head java 讀書筆記欄目 Java 简体版

原文原文鏈接

head first java讀書筆記

1. 基本信息

頁數：689
閱讀起止日期：20170104-20170215

2. 標籤

Java入門

3. 價值

8分

4. 主題

使用面向對象的思路介紹Java的基礎知識，從對象的基本概念、變量、方法，到函數庫，集成與多態，靜態，再到GUI，序列化，網絡，數據結構，最後介紹發佈和遠程調用。html

5. 綱要

Java的基本介紹-第1章
對象的基本介紹（變量與方法）-第2-5章
函數庫-第6章
對象的深刻-繼承、多態、構造函數-第7-9章
靜態的變量或方法-第10章
異常處理-第11章
GUI-第12-13章
序列化與IO-第14章
網絡與線程-第15章
經常使用數據結構-第16章
包與發佈程序-第17章
遠程過程調用、servlets等-第18章
附錄

6. 點評

本書最大的啓發是創建面向對象的基本思想，萬物皆在對象中，究竟是如何組成和實現的。java

7. 摘錄

7.1 Java的基本介紹

Java程序包括：源代碼、編譯器、輸出（class文件）、JVM；

最經常使用的java數據庫

public class ClassName {
     public static void main(String[] args){
         System.out.println("Hello World!");
     }
 }

Java不能像C同樣使用整型作測試條件
(int)(Math.random()*length)來出現隨機數；api

7.2 對象的基本介紹

對象自己已知的事物被稱爲實例變量，對象能夠執行的動做被稱爲方法；
類是對象的藍圖；
main的兩種用途：測試真正的類，啓動你的java應用程序；
Java的程序在執行期是一組會互相交談的對象；
變量有兩種類型primitive主數據類型和引用；
primitive主數據類型：boolean, char（0~65535）, byte（-128~127）, short（-32768~32767）, int, long, float, double。
沒有對象變量，只有引用到對象的變量；引用變量更像是對象的遙控器；
沒有引用到任何對象的引用變量的值爲null；
若是堆上的對象沒有任何引用變量，便會被回收；
數組就像杯架，數組變量就是數組對象的遙控器；
將實例變量標記爲private，將getter和setter標記爲public；
實例變量永遠都會有默認值，引用變量的默認值是null；局部變量沒有默認值。
程序設計的方法：找出類應該作的事情，列出實例變量和方法，編寫僞碼，編寫測試用的程序，實現類，測試方法，排錯或從新設計。
僞碼描述要作什麼事情，而不是如何作。
Interger.parseInt()只會在所給的String爲數字時有用。

7.3 API

ArrayList listName = new ArrayList ();
Java的API中，類是包含在包中的。使用時，必須import 類全名或直接打出去全名。除非是來自於java.lang這個包中，好比System, String, Math等。

7.4 對象深刻

extends表示繼承，繼承搜索方法時，會從底層向祖先搜索；
繼承是是一個，實例變量是有一個；
public會被繼承，private不會被繼承。
IS-A是單方向的；
繼承的意義有二：避免了重複的代碼；定義出共同的協議；
多態爲聲明父類的對象引用指向子類的對象；
經過多態，能夠寫出即便引進新型子類時，也沒必要修改的程序；
繼承雖然沒有層次的限制，但通常不會超過2層；
標識出final的類能夠確保方法都是本身須要的版本，final也能夠防止特定的方法被覆蓋，只要加在方法前；
覆蓋父類方法須要知足兩個條件：參數必需要同樣，且返回類型要兼容；不能下降方法的存取權限；
abstract表示抽象，抽象類不會被初始化；
abstract能夠放在方法前，直接以分號結尾。抽象方法只能放在抽象類中，全部的抽象方法在子類中必須被實現；
Java中，全部的類都繼承自object。object有equals,getClass,hashCode,toString等方法。
接口是爲了解決多重繼承的問題出現的，它沒有實例變量。像是一個100%的純抽象類，使用interface定義，全部的方法都是抽象的。其餘類用implements來實現接口的方法。類是能夠實現多個藉口的。
若是新的類沒法對其餘類經過IS-A測試，就設計不繼承的類；
只有在須要某類的特殊化版本時，已覆蓋或增長新的方法來繼承現有的類；
當你須要定義一羣子類的模板，又不想初始化此模板時，使用抽象類；
若是定義出類能夠扮演的角色，使用接口；
使用super關鍵字執行父類的方法；
抽象類能夠帶有抽象和非抽象的方法；
方法調用和局部變量在棧空間，全部的對象在堆空間；
構造函數沒有類型，也不會被繼承。一般必定要有沒有參數的構造函數。若是有了一個有參數的構造函數，則沒參數的構造函數必須本身寫纔會有，不然建立會出錯。
一般情況下，類的構造函數是public。
構造函數的調用鏈是自頂向下的，即先運行父類，再運行子類。
子類的構造函數若是想調用父類，使用super();一般情況下，super會被編譯器默認調用沒有參數的版本，顯示調用的話，必需要把super();放到第一行。
可使用this(args)調用重載版的其餘的構造函數，例如無參數的構造函數，加個默認值調用有參數的構造函數。this(Color.Red)

7.5 靜態的變量或方法

靜態方法不須要建立實例變量就能夠調用，像Math.abs(-1);
若是類只有靜態方法，即要限制非抽象類初始化，能夠將構造函數設置爲private；
靜態方法不能調用非靜態的變量或方法，例如在main中調用；但能夠調用靜態變量或方法。
類中靜態變量的值，對全部實例都相同，均是共享的；即實例變量每一個實例一個，靜態變量每一個類一個。
public static final double PI=3.1415public表示可供各方讀取，static表示不用建立實例便可使用，final表示不變；靜態final變量默認取名大寫，且必須初始化。
final的變量表明不能改變，final的方法不能被覆蓋，final的類不能被繼承；
使用相似ArrayList 時，要用到對主類型數據的封裝。由於ArrayList設計成只接受類和對象。Java5.0以前，int不能直接加入ArrayList，5.0以後能夠了，由於加入了autoboxing。Integer iWarp = new Integer(i); int unWrapped = iWrap.intValue();利用上述解包裝；
主數據類型的靜態方法：Integer.parseInt("2"), new Boolean("true").booleanValue();Double.toString(d);
格式化輸出String.format("%,d",1000);
日期的格式化輸出：%tc 完整的日期和時間，%tr是時間，%tA %tB %td 分別是星期，月份和日期。若是不想重複輸入參數，可使用String.format("%tA, %<tB %<td", today);

java.util.Calendar對象來操做日期數組

Calendar cal = Calendar.getInstance();
cal.set(2017,1,6,15,40);
cal.getTimeInMillis();
cal.HOUR_OF_DAY
cal.add(cal.DATE, 30);//月份滾動
cal.roll(cal.DATE, 30);//月份不動
cal.set(cal.DATE, 1);
//重要的方法
add(int field, int amount)
get(int field)
getInstance()
getTimeInMillis()
roll(int field, int amount)
set(int field, int amount)
set(year,month,day,hour,minute)
setTimeInMillis(long millis)
//關鍵字段
DATE / DAY_OF_MONTH
HOUR / HOUR_OF_DAY
MILLISECOND
MINUTE
MONTH
YEAR
ZONE_OFFSET

import static java.lang.System.out;靜態的import能夠到方法，而後直接調用out便可，不建議使用；瀏覽器

7.6 異常處理

Java經過throws語句來告訴你全部的異常行爲；把有風險的程序放在try塊中，用catch塊擺放異常的處理程序；異常時Exception類型的對象；

會拋出異常的方法必需要聲明它有可能會這麼作。方法能夠抓住其餘異常，異常總會丟回給調用方；安全

public void takeRisk() throws BadException{
     if (abandonAllHope){
         throw new BadException();
     }
 }
 public void crossFingers(){
     try{
         anObject.takeRisk();
     }catch (BadException ex){
         System.out.println("Aaargh");
         ex.printStackTrace();
     }
 }

try/catch塊用來處理真正的異常，而不是程序的邏輯錯誤。
開發與測試期間發生RuntimeException是不會受編譯器關因而否聲明它會拋出RuntimeException的檢查的，也不會管調用方是否定識到該異常；
不管成功或者失敗都要運行的放在finally中；即便try和catch都有return也同樣。
throws能夠拋出多個異常。throws Exception1, Exception2；catch也能夠用相似switch語句同樣來分別處理，可是要從小到大；
異常也能夠是多態的，能夠用所拋出的異常父型來catch異常。便可以用Exception ex來catch異常，可是不推薦這麼作；
duck異常表示，當調用有異常的方法，也聲明會拋出異常時，能夠不把此方法的調用放在try/catch塊中，可是不推薦這麼作。服務器

7.7 GUI相關

GUI的流程是建立frame，建立widget，加在widget，顯示出來。

監聽和事件源之間的溝統統過程序代碼調用button.addActionListener(this)來向按鈕註冊。按鈕會在事件發生時，調用註冊該接口的方法actionPerformed(theEvent)；網絡

import javax.swing.*;
 import java.awt.event.*;

 public class SimpleGui1B implements ActionListener{
     JButton button;

     public static void main(String[] args){
         SimpleGui1B gui = new SimpleGui1B();
         gui.go();
     }
     public void go(){
         JFrame frame = new JFrame();
         button = new JButton("click me");

         button.addAcitonListener(this);

         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

         frame.getContentPane().add(button);

         frame.setSize(300,300);
         frame.setVisible(true);
     }

     public void actionPerformed(ActionEvent event){
         button.setText("I've been clicked!");
     }
 }

frame默認有東西南北中五個位置來放置widget；

當有多個widget須要監聽事件時，用內部類來解決；數據結構

public void go(){
     //...
     labelButton.addActionListener(new LaberlListener());
     colorButton.addActionListener(new ColorListener());
     label = new JLabel("I'm a label")
     //...
 }
 class LaberListener implements ActionListener {
     public void actionPerformed(ActionEvent event){
         labnel.setText("Ouch!")
     }
 }

不一樣的事件有不一樣的對應回調函數，ActionListener對應的回調函數是actionPerformed，經過addActionListener添加。
每一個背景組件均可以有自定義規則的佈局管理器。BorderLayout表示五個區域，是frame默認的，FlowLayout表示從左至右，有必要時換行，是panel默認的；BoxLayout以垂直排列；
```
panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS));
 panel.add(button);
 frame.getContentPane().add(BorderLayout.North, panel);
```
JTextField文本框組件，JTextArea可滾動的文本框組件，JCheckBox組件，JList組件均爲經常使用組件。

7.8 序列化與IO

儲存對象的狀態能夠有兩種辦法，序列化（本身的Java程序讀），純文本文件（公共格式，其餘程序可讀）。
序列化寫入的步驟：建立FileOutputStream對應一個文件xxx.ser，有FileStream建立ObjectOutputStream，由ObjectOutputStream寫入object，關閉ObjectOutputStream。其中須要注意，可以寫入ObjectOutputStream的object必須implements Serializable，可是不須要實現任何方法。
```
FileOutputStream fileStream = new FileOutputStream("MyGame.ser");
 ObjectOutputStream os = new ObjectOutputStream(fileStream);
 os.writeObject(characterOne);
 os.close();
```
當一個類能夠序列化時，必須全部的實例變量都能被序列化，若是某個變量不須要序列化，須要標記transient，例如transient String currentID;

解序列化步驟，建立FileInputStream讀取一個文件，建立ObjectInputStream，讀取對象，轉換對象類型，關閉。

FileInputStream fileStream = new FileInputStream("MyGame.ser");
 ObjectInputStream os = new ObjectInputStream(fileStream);
 Object one = os.readObject();
 GameCharacter elf = (GameCharacter) one;
 os.close()

讀寫文本文件。注意可使用緩衝區的方法來減小磁盤IO。使用writer.flush()強制緩衝區內容寫入磁盤。

import java.io.*;
 class WriteAFile{
     public static void main(String[] args){
         try {
             FileWriter writer = new FileWriter("Foo.txt");
             writer.write("hello, foo!");
             //BufferedWriter bWriter = new BufferedWriter(writer);
             //bWriter.flush();
             writer.close();
             File myFile = new File("Foo.txt");
             FileReader fileReader = new FileReader(myFile);

             BufferedReader reader = new BufferedReader(fileReader);
             String line = null;
             while((line = reader.readLine()) != null){
                 System.out.println(line);
             }
             reader.close();
         } catch(IOException ex){
             ex.printStackTrace();
         }
     }
 }

java.io.File類的操做

//建立出File對象
 File f = new File("MyCode.txt");
 //建目錄
 File dir = new File("Chapter_8");
 dir.mkdir()
 //列出目錄內容
 if (dir.isDirectory()){
     String[] dirContents = dit.list();
 }
 //取得絕對路徑
 dit.getAbsolutePath();
 //刪除文件
 boolean isDeleted = f.delete()

每一個對象被序列化的同時，都會帶上一個類的版本的識別ID，即serialVersionUID。所以要注意版本。

7.9 網絡與線程

網絡接收消息的步驟：創建socket鏈接，輸入到底層的InputStreamReader上，轉換到緩衝區字符BufferedReader，讀取數據；

Socket chatSocket = new Socket("127.0.0.1", 5000);
 InputStreamReader stream = new InputStreamReader(chatSocket.getInputStream());
 BufferedReader reader = new BufferedReader(stream);
 String message = reader.readline();
 reader.close();

寫消息的流程是：創建socket，getOutputSream並創建PrintWriter，寫入數據；

Socket chatSocket = new Socket("127.0.0.1", 5000);
 PrintWriter writer = new PringWriter(chatSocket.getOutputStream());
 writer.println("haha");
 writer.close();

服務器端創建服務的流程爲：創建ServerSocket，等待客戶端鏈接，客戶鏈接後，調用accept方法創建新的socket。

ServerSocket serverSock = new ServerSocket(5000);
 while(true){
     Socket sock = serverSock.accept();
     PrintWriter writer = new PrintWriter(sock.getOutputStream());
     writer.println("haha");
     writer.close();
 }

Thread類用於建立線程，它有void join();void start();static void sleep();等方法。
啓動新線程的流程是：創建Runnable對象，創建Thread對象，並賦值Runnable任務；啓動Thread。

Runnable是一個接口，它只有一個方法public void run()。它就是線程要執行的工做。

public class MyRunnable implements Runnable {
     public void run(){
         go();
     }
     public void go(){
         System.out.println("top o' the stack");
     }
 }

 class ThreadTestDrive{
     public static void main(String[] args){
         Runnable threadJob = new MyRunnable();
         Thread myThread = new Thread(threadJob);
         myThread.start();
         System.out.println("back in main");
     }
 }

新建線程線程有新建(new)，可執行(start)，執行中，三個狀態，可執行和執行中兩個狀態是來回切換的，由JVM調度決定，是隨機不可控的。最多隻能靠sleep來影響最小保證時間。
線程不可重複啓動。
線程的名字能夠經過myThread.setName("Solon's Thread")來設定，並可經過調用Thread.currentThread().getName()來獲取。
線程會產生併發性問題(concurrency)，併發性問題會引起競爭狀態(race condition)，競爭狀態會引起數據損毀。舉個例子，兩個線程共用一個餘額，每次用錢時，先檢查餘額，再扣錢。這樣會因爲競爭緣由出現負數。因此須要一把鎖，來保證一個方法一次只能被一個線程調用，即用synchronized關鍵字。
```
private synchronized void makeWithDrawa(int amount){
    //...
}
```
要注意鎖是鎖在對象上的，只有對象包含同步化方法時才起做用。對象就算有多個同步化方法，也仍是隻有一個鎖。

同步化能夠只修飾幾行，這樣能夠減少原子操做的範圍，提升效率。

private void makeWithDrawa(int amount){
    //...
    synchronized(this){
        //...
    }
}

兩個線程和兩個對象就能夠引發死鎖，各自佔有一個資源，又須要調用彼此的資源。
靜態的方法是運行在類上的，當要對靜態的方法作同步化是，會使用類自己的鎖。

7.10 經常使用數據結構與泛型

TreeSet一有序狀態保持並可防止重複；
HashMap-KV來存儲；
LinkedList-針對常常插入和刪除的集合；沒有ArrayList經常使用；
HashSet-防重複的集合，快速查找；
LinkedHashMap-相似HashMap，但可記住元素的插入順序，可按照存取順序來排序；
可用java.util下的Collections.sort(List list)來給ArrayList排序，此函數會直接改變list的順序。
不用泛型時，任何object對象均可以加入ArrayList，形成混亂。使用泛型，只有任一單一類型可加入；

泛型有三件事是重要的：

new ArrayList<Song>(); //建立實例
 ArrayList<Song> songList = new ArrayList<song>(); //聲明指定泛型類型的變量
 void foo(ArrayList<Song> list); //聲明或調用指定泛型的方法

在說明文件中，通常用E表示指定類型；

public class ArrayList<E> extends AbstractList<E> implements List<E> ...{
     public boolean add(E o)
 }

運用泛型的方法可使用未定義在類聲明的類型參數。

public <T extends Animal> void takeThing(ArrayList<T> list)
//與後續的萬用字符相同
public void takeThing(ArrayList<? extends Animal>)
//與下面不同,下面的只能使用Animal，不能使用其子類
public void takeThing(ArrayList<Animal> list)

以泛型的觀點來講extends能夠表明extend或implement，表示是一個。
若是要對自定義類實現排序，有兩種方法，一是實現該類的Comparable接口，這個接口有compareTo方法。能夠調用已有的類型來輔助實現該方法；二是增長Comparator類的參數來比較。
能夠調用HashSet的addAll方法，來生成ArrayList對應的隊列；

一樣若是要使用HashSet去除重複，針對自定義類，要覆蓋equals方法和hashCode方法。它的比較過程是先比較hashCode()，若是相同，再比較equals。

class Song implements Comparable<Song>{
    ...
    public boolean equals(Object aSong){
        Song s = (Song)aSong;
        return getTitle().equals(s.getTitle());
    }
    public int hashCode(){
        return title.hashCode();
    }
}

HashMap適合用KV場景存儲數據

HashMap<String, Integer> scores = new HashMap<String, Integer>();
scores.put("Bert", 43);
System.out.println(scores.get("Bert"));

泛型參數和數組參數的區別

public void takeAnimals1(ArrayList<Animal> animals)
public void takeAnimals2(Animal[] animals)
//takeAnimals1(new ArrayList<Dog> dogs)會出錯，編譯錯誤
//takeAnimals2(new Dog[] dogs)不會出錯
//前者能夠防止在函數中進行Dog的特有相關操做，後者在執行期若是運行相關操做，會拋出異常

爲了解決上述前者的問題，可使用萬用字符

public void takeAnimals3(ArrayList<? extends Animal> animals)
//爲了防止此時，將ArrayList<Dog>中加入Cat，當用萬用字符時，不能對隊列作加入操做

7.11 包與發佈程序

可使用-d class_path來將源代碼與類文件相分離，實現對源碼的保護；
```
javac -d ../classes *.java
```
jar相似tar命令，它有本身的規則。首先要肯定全部的類文件都在classes目錄下，其次要有manifest.txt文件來描述哪一個類帶有main()方法，最後執行命令打jar包
```
cat manifest.txt
 Main-Class:MyApp
 cd MiniProject/classes
 jar -cvmf manifest.txt app1.jar *.class
```
若是jar包指定了manifest，則能夠執行java -jar app1.jar。
除非類是包的一部分，不然Java虛擬機不會深刻其餘目錄去找。
用包防止類名衝突，能夠把類放到各個包裏。就像java.util.ArrayList。
而爲了防止包命名衝突，通常反向使用domain做爲包名稱。
```
com.headfirstbooks.Book
 com.headfirstjava.projects.Chart
```
選定包名稱後，須要再類的源代碼的第一行將類加入包中package com.headfirstjava;。而後要設定對應的目錄結構。
通常Java程序的路徑爲項目根目錄下有source和classes兩個文件，source目錄下爲包路徑和源代碼，這樣用-d ../classes編譯後，-d會在classes目錄下創建對應的目錄和class文件。
按照上述約定時，manifest文件也放在class目錄下，通常爲Main-Class:com.headfirstjava.PackageExcise。
在classes目錄下執行jar語句打包，這裏只要指定com路徑就行。
```
jar -cvmf manifest.txt packEx.jar com
```
使用jar -xf packEx.jar解壓後會發現有META-INF目錄，其下有MANIFEST.MF文件，即爲寫入的對應文件。
JWS即Java Web Start，用戶能經過網頁上的某個鏈接來啓動Java程序，一旦程序下載後，下次就能獨立於瀏覽器來運行，它是經過網絡來發布程序的一種手段。jnlp文件是個描述應用程序可執行JAR文件的XML文件。
製做可執行jar程序；編寫jnlp文件；二者均放入Web服務器；Web服務器設定新類型application/x-java-jnlp-file；設定網頁連接到jnlp文件<a href="MyApp.jnlp">Launch My App</a>

7.12 遠程過程調用、servlets等

遠程過程調用最先是爲了利用Server端的強大處理能力。RMI全稱Remote Method Invocation；
RMI須要服務器與服務器helper和客戶端與客戶端helper。helper僞裝成服務，但其實只是真實服務的代理；
使用RMI時要肯定協議，兩端都是Java可以使用JRMP協議，IIOP能夠調用Java對象或其餘類型的遠程方法。
在RMI中客戶端的helper稱爲stub，客戶端的helper成爲skeleton
建立遠程服務的流程是建立接口(extends Remote)，實現類(extends UnicastRemoteObject impements MyRemote)，rmic產生stub與skeleton(rmic MyRemoteImpl)，啓動RMI registry(rmiregistry)，啓動遠程服務(Naming.rebind("Remote Hello", serviceMyRemote))。
客戶端查詢RMIregistry((MyRemote)Naming.lookup("rmi://127.0.0.1/Remote Hello"))，RMIregistry返回stub對象，客戶端調用stub上的方法；
注意點：啓動遠程服務前啓動registry；參數和返回類型可序列化；
servlet至關於Java的CGI，能夠處理用戶提交的請求，並將結果返回給瀏覽器的網頁；
建立並執行serverlet的步驟：找到網頁服務器能夠存放servlet的地方；取得servlet.jar並添加到classpath上（其不是標準函數庫的一部分）；extends HttpServlet來編寫servlet的類；編寫html來調用servlet；給服務器配置html和servlet；
servlet通常經過覆蓋HttpServlet的doGet和doPost來建立；它輸出帶有完整標識的HTML網頁；
EJB是Enterprise JavaBeans，它具備一組光靠RMI不會有的服務，好比交易管理、安全性、併發性、數據庫和網絡功能等；EJB服務器做用於RMI調用和服務層之間。service helper調用EJB object，object調用Enterprise bean，後者再調用DB等操做；
Jini也使用RMI，但具備自適應探索（接收服務註冊和客戶端調用查詢）和自恢復網絡（用心跳檢查服務）的功能；

7.13 附錄
按位非~，按位與&，按位或|，按位異或^；
右移>>，無符號右移>>>;
String具備不變性，放在String pool中，不受Garbage Collector管理。
包裝類沒有setter，其具備不變性。例如new Integer(42)，永遠都是42。

斷言能夠用來測試，它比println的好處是沒有特別設定的話，它會自動被JVM忽略，也可專門打開斷言調試程序。

assert (height > 0) : "height = " + height + " weight = " + weight;
 //冒號後面的語句能夠是任何返回非null值得語句，但必定要注意不要在這裏改變對象的狀態
 //斷言的編譯和普通編譯沒差異，執行時有差別。
 javac TestDriveGame.java
 java -ea TestDriveGame

new Foo().go()是一個調用go方法，但又不須要維持對Foo引用的方式；
靜態嵌套類，和普通類很像，可經過new Outer.Inner()來建立。可存取外層靜態私有變量；
非靜態的嵌套類，一般被稱爲內部類。

匿名內部類。

//button.addActionListener(quitListener); //一般是傳遞一個內部類的實例
 //雖然ActionListener是個接口，並且咱們不能聲明一個接口的實例，但匿名內部類是個例外
 button.addActionListener(new ActionListener() {
     public void actionPerformed(ActionEvent ev){
         System.exit(0);
     }
 });

public任何程序代碼均可公開存取；default只在統一包中的默認事物可以存取；protected可容許不在同一包的子類，繼承該部分；
對於經常使用的可變String，通常使用StringBuilder，Thread安全環境中，採用StringBuffer；
二維數組是指數組的數組，new int [4][2]實際上是建立一個包含四個元素的數組，每一個元素是一個長度爲2的數組。
枚舉相對於普一般量的優點是限定了範圍，其實際是繼承了java.lang.Enum。聲明時使用public enum Members {JERRY, BOBBY, PHIL};
每一個枚舉都內置values()能夠用於遍歷操做；
能夠在enum中加入構造函數，方法、變量和特定常量的內容；