包的主要作用以及定義
    包的匯入操作
    系統常見的開發包
    jar 程式命令
    
    包的定義
        在任何的作業系統之中都有一個統一的共識：同一個目錄下不能夠存在有相同的檔名稱
        但是在實際的開發之中又不可能出現不重名的情況
        所以為了解決這樣的衝突問題，在專案裡面往往會引用包的概念，而所謂的包儲存的就是一個資料夾
        也就是說在不同的目錄中可以存放有相同的檔案
        如果要想在javac中定義包，直接使用 package 關鍵字即可
        範例：定義包

    package cn.mldn.demo; // 包名稱
    public class packageDefinition{
        public static void main(String args[]){
            System.out.println("浪");
        }
    }

           
            一旦程式中聲明瞭包，那麼就必須生成的*.class 檔案儲存在包裡面
            這個包並不是手工建立的，在java裡面考慮到了使用者開發所需要的種種情況，所以專門提供有打包編譯的操作
        範例：打包編譯
            開啟控制檯.......
            java -d . Hello.java
            
            在以上的編譯命令中有兩個引數：
                "-d" :生成目錄，預設情況下是根據 package 定義的內容生存

                "." ：生成程式的儲存路徑，如果設定為 "." 表示當前目錄下儲存
            此時如果程式有包了，那麼在解釋程式ude時候必須加上包名稱，也就是說此時的 packageDefinition 類包執行
            java cn.mldn.demo.packageDefinition
            
            所有的java專案開發過程之中，程式類必須要有包的定義才可以使用，沒有包的類不存在。而類的完整名稱“包.類”
            
    
    包的匯入操作
        利用程式包可以將一個很多的 *.class 類歸類儲存起來，但是這樣一來就有可能出現包與包之間進行類的互相呼叫問題
        所以此時就可以利用 import 語句來解決
        範例：定義一個 cn.mldn.util.Message 的類

    package cn.mldn.util; // 包名稱
    class Message{
        public String getInfo(){
            return "..................";
        }
    }

           
        範例：定義一個 packageDefinition

    package cn.mldn.test;
    import cn.mldn.util.Message; // 匯入其他包的類
    public class packageDefinition{
        public static void main(String args[]){
            Message msg = new Message();
            System.out.println(msg.getInfo);
        }
    }

 

            現在的程式肯定是需要進行編譯，但是從理論上來講應該先編譯 Message.java ,而後再編譯 packageDefinition.java
            於是按照此順序編譯
            編譯出錯： Message 在 cn.mldn.util 中不是公共的：無法從外部程式包對其進行訪問
            之所以造成此問題，是因為此時的 Message 類的定義中使用的是預設的訪問控制權限，而這個許可權的特點是指同一包中的類可以互相訪問
            但是不能夠被外包所訪問，所以學習完包的定義之後對於程式碼也可以進行一些規範化要求：
            以後寫的類都要寫在包中，而包中的  *.java 檔案 裡面只會有一個 public class 宣告
            總結：關於 public class 與 class 宣告類的區別？
                public class 定義要求檔名稱與類名稱保持一致，而在 *.java 檔案之中只允許有一個 public class 定義，如果該類要被不同的包所使用，則必須使用 public class 宣告
                class 定義的類檔名稱可以與類名稱不一致，但那是在編譯之後每個 class 宣告的類都會生成一個 *.java 檔案，此類只能夠在一個包中使用
                
        範例：修改Message 類的定義

    package cn.mldn.util; // 包名稱
    public class Message{
        public String getInfo(){
            return "..................";
        }
    }

           
            現在發現多個程式編譯的時候要考慮編譯順序，那麼這實在是太麻煩了，所以為了方便編譯，可以使用“*.java”進行自動順序編譯：javac -d . *.java
            
        但是現在的程式碼出現了兩個問題：
            問題一：每次都是單獨匯入特定的類：
                import cn.mldn.util.Message;
                在進行匯入的時候都需要寫上完整的類名稱，那麼假設說現在在 cn.mldn.util 包中存在有500個類，並且本次專案需要匯入20個類，難道要寫20個 import 嗎？
                這樣就很麻煩了。所以可以使用萬用字元“*”完成： import cn.mldn.util.*;
                使用 import 包.* 的情況並不會將一個包中所有的類都匯入進來，包括所謂的類載入的時候實際上只會載入所需要的類，不需要的類不載入
            問題二：有可能在同一個程式中匯入不通過的包，但是這不同的包有相同的類，現在模擬環境：
                現在有類一： cn.mldn.util.Message;
                現在有類二：com.yootk.Message;
                

    package cn.mldn.util; // 包名稱
    public class Message{
        public void show(){
            System.out.println("------------------");
        }
    }

       
                隨後編譯第二個 Message 程式類： javac -d . Message.java
                範例：在 packageDefinition 類中由於某種需要同時匯入了兩個包

    package cn.mldn.test;
    import cn.mldn.util.*; // 匯入其他包的類
    import com.yootk.*;
    public class packageDefinition{
        public static void main(String args[]){
            Message msg = new Message();
            System.out.println(msg.getInfo);
        }
    }

                   
                結果出錯
                為了避免使用中的類衝突，那麼就建議在操作類的時候直接寫上類的完整名稱
                範例：使用完整名稱避免錯誤

    package cn.mldn.test;
    import cn.mldn.util.*; // 匯入其他包的類
    import com.yootk.*;
    public class packageDefinition{
        public static void main(String args[]){
            cn.mldn.util.Message msg = new cn.mldn.util.Message();
            System.out.println(msg.getInfo);
        }
    }

                   
                    這種情況在開發之中一定會出現許多次，所以用的時候就寫上完整名稱
                    編寫順序： package, import, public class
            
    系統常見包
        java 的開發類庫非常的龐大，而開發包也非常的多，比較常見的幾個包如下：
            java.lang：像 Object,String Intger,Number 都是這個包中定義的，從JDK 1.1 開始自動匯入
            java.reflect：反射開發包，直接與框架開發有關係
            java.util： java的 工具包
            java.regex：正則表示式的開發包
            java.text：國際化程式支援包
            java.io：資料流的開發包（Input，Output），前提是要弄懂抽象類就差不多學會這個包
            java.net：網路程式設計包
            java.spl：資料庫的程式設計包
            java.awt，javax.swing：影象介面開發包
                java在JDK1.0 的時候只提供有java.的 開發包，這個開發包可以實現影象介面的開發，最初的設計較為倉促要大量的使用Windows的系統函式
                在JDK 1.2（java2）推出了輕量級的元件，有了swing開發元件
            java.applet.*：是在網頁上嵌入的java程式，是java發展的標誌

    jar 命令
        當一個專案開發完成之後，雖然不同功能的類要要存在不同的包裡面，但是這裡面也會出現一個問題，你不可能將所有的*.class 檔案給使用者
        往往有可能是若干個*.class檔案完成某一特定的功能組合，那麼如果要更新也只會更新這幾個檔案
        所以在實際的專案中為了方便管理，往往會利用jar檔案負責處理
        範例：；現在有個packageDefinition。java類

    package cn.mldn.util;
    public class packageDefinition{
        public String getInfo(){
            return "**************";
        }
    }

            1.進行打包編譯：javac -d . packageDefinition.java;
            2.將開發包打成 pd。jar 檔案：jar -cvf pd.jar cn
            打成的pd.jar 檔案可以通過rar壓縮檔案開啟，而後在這個檔案裡面會存在有一個資料夾：META-INF/MANFEST.MF
            3.當程式打包完成之後肯定需要進行程式碼的執行，肯定需要編寫測試類

    package cn.mldn.test;
    public class packageDefinition{
        public static void main(String args[]){
            cn.mldn.util.Message msg = new cn.mldn.util.Message();
            System.out.println(msg.getInfo);
        }
    }
    //出錯

                   
            實際上每個jar檔案都是一個獨立的路徑，所以要想讓jar檔案起作用，必須配置CLASSPATH,但是CLASSPATH 中有一個“.” ，所以如果要想配置多個CLASSPATH 使用“;”分割
            SET CLASSPATH = .;(檔案目錄)
            
            以上的配置只能夠在當前命令列中使用，如果要想讓其成為全域性的配置，則需要修改環境屬性
            如果現在只使用記事本開發程式，那麼所有需要的第三方的*.jar 檔案啊都必須在環境屬性配置
            
            
    總結
        1.以後的程式都要寫上 package 打包
        2.import 語句往往不需要編寫，前提：使用開發工具
        3.jar命令是最好用的，比開發工具提供的好用