本文原創作者：pipi-changing
本文原創出處：http://www.cnblogs.com/pipi-changing/
本文版權歸作者和博客園共有，未經作者同意必須保留此段聲明，
且在文章頁面明顯位置給出原文連接 ，否則保留追究法律責任的權利。
面向對象概念
理解面向對象
面向對象是相對面向過程而言 面向對象和面向過程都是一種思想 面向過程 •強調的是功能行為 面向對象 •將功能封裝進對象，強調具備了功能的對象。 面向對象是基於面向過程的。
面向過程
在一個結構體中定義窗口的大小，位置，顏色，背景等屬性，對窗口操作的函數與窗口本身的定義沒有任何關系，
如HideWindow，MoveWindow，MinimizeWindow，這些函數都需要接受一個代表要被操作的窗口參數 ，
是一種謂語與賓語的關系 。
面向對象
定義窗口時，除了要指定在面向過程中規定的那些屬性，如大小，位置，顏色，背景等外，還要指定該窗口可能具有的動作 ，
如隱藏，移動，最小化等。這些函數被調用時，都是以某個窗口要隱藏，某個窗口要移動的語法格式來使用的 ，
這是一種主語與謂語的關系。
面向對象和面向過程的思想有著本質上的區別, 作為面向對象的思維來說，當你拿到一個問題時，
你分析這個問題不再是第一步先做什麼，
第二步再做什麼，這是面向過程的思維，你應該分析這個問題裡面有哪些類和對象，這是第一點，
然後再分析這些類和對象應該具有哪些屬性和
方法。這是第二點。最後分析類和類之間具體有什麼關系，這是第三點。
面向對象有一個非常重要的設計思維：合適的方法應該出現在合適的類裡面
面向對象的設計思想
面向對象的基本思想是，從現實世界中客觀存在的事物出發來構造軟件系統，並在系統的構造中盡可能運用人類的自然思維方式。
面向對象更加強調運用人類在日常生活的邏輯思維中經常采用的思想方法與原則，如抽象、分類，繼承、聚合、多態等。
人在思考的時候，首先眼睛裡看到的是一個一個的對象。
面向對象的特點
是一種符合人們思考習慣的思想 可以將復雜的事情簡單化 將程序員從執行者轉換成了指揮者 完成需求時： • 先要去找具有所需的功能的對象來用。 • 如果該對象不存在，那麼創建一個具有所需功能的對象。
• 這樣簡化開發並提高復用。
面向對象開發，設計，特征
開發的過程：其實就是不斷的創建對象，使用對象，指揮對象做事情。 設計的過程：其實就是在管理和維護對象之間的關系。 面向對象的特征： •封裝(encapsulation) •繼承(inheritance) •多態(polymorphism)
面向對象還支持如下幾個功能：
1）對象是面向對象方法中最基本的概念，它的基本特點是：標識唯一性、分類性、多態性、封裝性、模塊獨立性好。
2）類是具有共同屬性、共同方法的一類事物。類是對象的抽象；對象則是類的實例。
而類是整個軟件系統最小的程序單元，類的封裝性將各種信息細節隱藏起來，並通過公用方法來暴露該類對所提供的功能，
從而提高了類的內聚性，降低了對象之間的耦合性。
3）對象間的這種相互合作需要一個機制協助進行，這樣的機制稱為“消息”。消息是一個實例與另一個實例之間相互通信的機制。
4）在面向對象方法中，類之間共享屬性和操作的機制稱為繼承。繼承具有傳遞性。
繼承可分為單繼承（一個繼承只允許有一個直接父類，即類等級為樹形結構）與多繼承（一個類允許有多個直接父類），
但Java不支持多繼承。
在Java語言中除了8個基本數據類型值之外，一切都是對象，而對象就是面向對象程序設計的中心。
對象具有狀態，一個對象用數據值來描述它的狀態。Java通過對對象定義Field（以前常被稱為屬性，現在也稱字段）來描述對象的狀態；
對象還有操作，這些操作可以改變對象的狀態，
對象的操作也被稱為對象的行為，Java通過為對象定義方法來描述對象的行為。
對象是Java程序的核心，所以在Java裡的對象具有唯一性，每個對象都有一個標識來引用它，
如果某個對象失去了標識，這個對象將變成垃圾，只能等著系統垃圾回收機制來回收它。Java語言不允許直接訪問對象，
而是通過對對象的引用來操作對象。
在Java語言使用class關鍵字定義類，定義類時可使用Field來描述該類對象的數據，可使用方法來描述該類對象的行為特征。
Java語言使用extends關鍵字來表示繼承關系。
Java使用new關鍵字來創建指定類的對象，每個類可以創建任意多個對象，多個對象的Field值可以不同。
類與對象的關系
使用計算機語言就是不斷的在描述現實生活中的事物。 java中描述事物通過類的形式體現，類是具體事物的抽象，概念上的定義。 對象即是該類事物實實在在存在的個體。
類是對某一類事物的描述，是抽象的、概念上的定義；對象是實際存在的該類事物的每個個體，因而也稱實例(instance)。
類與對象的關系如圖
可以理解為： •類就是圖紙 •汽車就是堆內存中的對象
對於同一類事物可以抽取它們的共性的內容，定義在類中。
如生活中的汽車，每一台車都有輪胎數和顏色。
那麼在通過java描述汽車這類事物時，就可以將這兩個共性屬性作為類中的屬性進行定義。
通過該類建立的每一個汽車實體都具有該屬性，並可以有對象特有的屬性值。
類的定義
生活中描述事物無非就是描述事物的屬性和行為。
•如：人有身高，體重等屬性，有說話，打球等行為。
Java中用類class來描述事物也是如此
•屬性：對應類中的成員變量。
•行為：對應類中的成員函數。
定義類其實在定義類中的成員(成員變量和成員函數)。 每一個JAVA裡面的class（類）都對應了我們現實生活中某一類事物的一個抽象。
成員變量和局部變量的區別？
成員變量： •成員變量定義在類中，在整個類中都可以被訪問。 •成員變量隨著對象的建立而建立，存在於對象所在的堆內存中。 •成員變量有默認初始化值。 局部變量： •局部變量只定義在局部范圍內，如：函數內，語句內等。 •局部變量存在於棧內存中。 •作用的范圍結束，變量空間會自動釋放。 •局部變量沒有默認初始化值。 方法體中局部變量若與成員變量同名，局部變量將屏蔽成員變量。
class Variable {
int x = 0, y = 0, z = 0; // 類的成員變量
void init(int x, int y) {
this.x = x;
this.y = y;
int z = 5; // 局部變量
System.out.println("** in init**");
System.out.println("x = " + x + "y = " + y + "z = " + z);
}
}
public class VariableTest {
public static void main(String args[]) {
Variable v = new Variable();
System.out.println("** before init **");
System.out.println("x = " + v.x + "y = " + v.y + "z = " + v.z);
v.init(20, 30);
System.out.println("** after init **");
System.out.println("x = " + v.x + "y = " + v.y + "z = " + v.z);
}
}
創建對象，使用對象
class Car//對Car這類事物進行描述
{
String color = "red";
int num = 4;
void show()
{
System.out.println("color="+color+"..num="+num);
}
}
1 class CarDemo
2 {
3 public static void main(String[] args)
4 {
5 Car c = new Car();//建立對象
6 c.color = "black";//對對象的屬性進行修改
7 c.show();//使用對象的功能。
8 }
9 }
對象內存結構
Car c1 = new Car(); c1.color="blue";
Car c2 = new Car();
只要是用new操作符定義的實體就在會堆內存中開辟一個新的空間。
並每一個對象中都有一份屬於自己的屬性。
通過 對象.對象成員 的方式操作對象中的成員，
對其中一個對象的成員進行了修改。和另一個對象沒有關系。
匿名對象
匿名對象是對象的簡化形式 匿名對象兩種使用情況 •當對對象方法僅進行一次調用時 •匿名對象可以作為實際參數進行傳遞
封裝(Encapsulation)
封裝：是指隱藏對象的屬性和實現細節，僅對外提供公共訪問方式。
好處：
•將變化隔離。
•便於使用。
•提高重用性。
•提高安全性。
封裝原則：
•將不需要對外提供的內容都隱藏起來。
•把屬性都隱藏，提供公共方法對其訪問。
要求使對象之外的部分不能隨意存取對象的內部數據，從而有效避免了錯誤對它的“交叉感染”，使軟件錯誤能局部化，降低排錯難度
封裝是把過程和數據包圍起來，對數據的訪問只能通過已定義的界面。面向對象計算始於這個基本概念，
即現實世界可以被描繪成一系列完全自治、封裝的對象，這些對象通過一個受保護的接口訪問其他對象。封裝隱藏了類的內部實現機制，
從而可以在不影響使用者的前提下改變類的內部結構，同時保護了數據。
private(私有)關鍵字
private關鍵字：
•是一個權限修飾符。
•用於修飾成員(成員變量和成員函數)
•被私有化的成員只在本類中有效。
常用之一：
•將成員變量私有化，對外提供對應的set ，get方法對其進行訪問。提高對數據訪問的安全性。
構造函數
特點：
1.函數名與類名相同 2.不用定義返回值類型 3.沒有具體的返回值。作用：
給對象進行初始化。
注意：
1.默認構造函數的特點。 2.多個構造函數是以重載的形式存在的。
this關鍵字
特點：this代表其所在函數所屬對象的引用。
換言之：this代本類對象的引用。
什麼時候使用this關鍵字呢？
當在函數內需要用到調用該函數的對象時，就用this。
static(靜態)關鍵字
static關鍵字：
•用於修飾成員（成員變量和成員函數）
被修飾後的成員具備以下特點：
隨著類的加載而加載
優先於對象存在
被所有對象所共享
可以直接被類名調用
使用注意
靜態方法只能訪問靜態成員
靜態方法中不可以寫this，super關鍵字
主函數是靜態的
繼承的概述
多個類中存在相同屬性和行為時，將這些內容抽取到單獨一個類中，那麼多個類無需再定義這些屬性和行為，只要繼那個類即可。
多個類可以稱為子類，單獨這個類稱為父類或者超類。
子類可以直接訪問父類中的非私有的屬性和行為。
通過 extends 關鍵字讓類與類之間產生繼承關系。
•class SubDemo extends Demo{}
繼承的出現提高了代碼的復用性。
繼承的出現讓類與類之間產生了關系，提供了多態的前提。
注意：子類不可以具備父類中私有的內容。
父類怎麼來的？共性不斷向上抽取而來的。
繼承關系封裝了這樣一種邏輯：“XX是一種XX”，只要能說通，就可以考慮用繼承關系來封裝它。
繼承的特點
Java只支持單繼承，不支持多繼承。
•一個類只能有一個父類，不可以有多個父類。
•class SubDemo extends Demo{} //ok
•class SubDemo extends Demo1,Demo2...//error
Java支持多層繼承(繼承體系)
•class A{}
•class B extends A{}
•class C extends B{}
定義繼承需要注意：
•不要僅為了獲取其他類中某個功能而去繼承
•類與類之間要有所屬( " is a " )關系，xx1是xx2的一種。
注意：因為多繼承容易出現問題。
兩個父類中有相同的方法。子類到底要執行哪一個是不確定的。
所以java不支持多繼承，但將這種機制換了另一個種安全的方式來體現，多實現。
多次繼承出現的繼承體系中，通常看父類中的功能，了解該體系的基本功能，建立子類對象即可使用該體系功能。
繼承是一種聯結類的層次模型，並且允許和鼓勵類的重用，它提供了一種明確表述共性的方法。
對象的一個新類可以從現有的類中派生，這個過程稱為類繼承。新類繼承了原始類的特性，新類稱為原始類的派生類（子類），
而原始類稱為新類的基類（父類）。
派生類可以從它的基類那裡
繼承方法和實例變量，並且類可以修改或增加新的方法使之更適合特殊的需要。
因此可以說，繼承是為了重用父類代碼，同時為實現多態性作准備。
super關鍵字
super和this的用法相像
this代表本類對象的引用
super代表父類的內存空間的標識。
當子父類出現同名成員時，可以用super進行區分
子類要調用父類構造函數時，可以使用super語句。
函數覆蓋(Override)
子類中出現與父類一模一樣的方法時，會出現覆蓋操作，也稱為重寫或者復寫。
父類中的私有方法不可以被覆蓋。
在子類覆蓋方法中，繼續使用被覆蓋的方法可以通過super.函數名獲取。
覆蓋注意事項：
•覆蓋時，子類方法權限一定要大於等於父類方法權限
•靜態只能覆蓋靜態。
覆蓋的應用：
•當子類需要父類的功能，而功能主體子類有自己特有內容時，可以復寫父類中的方法，
這樣，即沿襲了父類的功能，又定義了子類特有的內容。
子類的實例化過程
子類中所有的構造函數默認都會訪問父類中空參數的構造函數
因為每一個構造函數的第一行都有一條默認的語句super();
子類會具備父類中的數據，所以要先明確父類是如何對這些數據初始化的。
當父類中沒有空參數的構造函數時，子類的構造函數必須通過this或者super語句指定要訪問的構造函數。
final關鍵字
final可以修飾類，方法，變量。
final修飾的類不可以被繼承。
final修飾的方法不可以被覆蓋。
final修飾的變量是一個常量。只能被賦值一次。
內部類只能訪問被final修飾的局部變量。
抽象類概述
抽象定義： •抽象就是從多個事物中將共性的，本質的內容抽取出來。 •例如：狼和狗共性都是犬科，犬科就是抽象出來的概念。 抽象類： •Java中可以定義沒有方法體的方法，該方法的具體實現由子類完成，該方法稱為抽象方法，包含抽象方法的類就是抽象類。 抽象方法的由來： •多個對象都具備相同的功能，但是功能具體內容有所不同，那麼在抽取過程中，只抽取了功能定義，並未抽取功能主體， 那麼只有功能聲明，沒有功能主體的方法稱為抽象方法。 •例如：狼和狗都有吼叫的方法，可是吼叫內容是不一樣的。所以抽象出來的犬科雖然有吼叫功能，但是並不明確吼叫的細節。
抽象——就是忽略一個主題中與當前目標無關的那些方面，以便更充分地注意與當前目標有關的方面。
(就是把現實世界中的某一類東西，提取出來，用程序代碼表示，抽象出來一般叫做類或者接口。)抽象並不打算了解全部問題，
而只是選擇其中的一部分，暫時不用部分細節。抽象包括兩個方面，一是數據抽象，二是過程抽象。
數據抽象——就是用代碼的形式表示現時世界中一類事物的特性，就是針對對象的屬性。
比如建立一個鳥這樣的類，鳥都有以下屬性：一對翅膀、兩只腳、羽毛等。抽象出來的類都是鳥的屬性，或者成員變量。
過程抽象——就是用代碼形式表示現實世界中事物的一系列行為，就是針對對象的行為特征（方法）。
比如鳥會飛、會叫等。抽象出來的類一般都是鳥的方法。
抽象類的特點
抽象類和抽象方法必須用abstract關鍵字來修飾。
抽象方法只有方法聲明，沒有方法體，定義在抽象類中。
•格式：修飾符 abstract 返回值類型 函數名(參數列表) ;
抽象類不可以被實例化，也就是不可以用new創建對象。原因如下：
•抽象類是具體事物抽取出來的，本身是不具體的，沒有對應的實例。例如：犬科是一個抽象的概念，真正存在的是狼和狗。
•而且抽象類即使創建了對象，調用抽象方法也沒有意義。
抽象類通過其子類實例化，而子類需要覆蓋掉抽象類中所有的抽象方法後才可以創建對象，否則該子類也是抽象類。
用abstract關鍵字修飾類:抽象類
用abstract關鍵字修飾方法：抽象方法
抽象類必須被繼承，抽象方法必須被重寫
抽象方法只需聲明，無需實現
抽象類不能被實例化，抽象類不一定要包含抽象方法
若類中包含抽象方法，給類必須被定義為抽象類
接口
格式：
interface {}
接口中的成員修飾符是固定的。
•成員常量：public static final
•成員函數：public abstract
•發現接口中的成員都是public的。
接口的出現將“多繼承”通過另一種形式體現出來，即“多實現”。
接口的特點
接口是對外暴露的規則。
接口是程序的功能擴展。
接口的出現降低耦合性。
接口可以用來多實現。
類與接口之間是實現關系，而且類可以繼承一個類的同時實現多個接口。
接口與接口之間可以有繼承關系。
接口是抽象類的一種，只包含常量和方法的定義，沒有變量和方法的實現，且其方法都是抽象方法。
用處體現在：
通過接口，實現不相關類的相同行為
通過接口，指明多個類需要實現的方法
通過接口，了解對象的交互界面，無需了解對象所對應的類
接口的實現：
在類的聲明中用implements子句來表示一個類使用某個接口
類體中可以使用接口中定義的常量，必須實現接口中定義的所有方法
一個類可以實現多個接口，在implements中用逗號隔開
接口類型的使用：
接口作為一種引用類型來使用
任何實現該接口的類的實例，都可以存儲在該接口類型的變量中，通過這些實例，訪問該類接口中的方法。
接口與抽象類
共 性：
都是不斷抽取出來的抽象的概念
區別 1：
抽象類體現繼承關系，一個類只能單繼承
接口體現實現關系，一個類可以多實現
區別 2：
抽象類是繼承，是 "is a "關系
接口是實現，是 "like a"關系
區別 3：
抽象類中可以定義非抽象方法，供子類直接使用
接口的方法都是抽象，接口中的成員都有固定修飾符
多態
定義：某一類事物的多種存在形態。
例：動物中貓，狗。 貓這個對象對應的類型是貓類型 •貓 x = new 貓(); 同時貓也是動物中的一種，也可以把貓稱為動物。 •動物 y = new 貓(); •動物是貓和狗具體事物中抽取出來的父類型。父類型引用指向了子類對象。
class A {
void callme() {
System.out.println("Inside A's callme()) method");
}
}
class B extends A {
void callme() {
System.out.println("Inside B's callme() method");
}
}
public class Dispatch {
public static void main(String args[]) {
A a = new B(); // 引用子類的實例
a.callme();
}
}
程序中體現：
父類或者接口的引用指向或者接收自己的子類對象。
好處和作用：
多態的存在提高了程序的擴展性和後期可維護性
前提：
•需要存在繼承或者實現關系
•要有覆蓋操作
子類繼承父類後，同一個方法有不同的表現
體現在兩個方面：方法重載實現的靜態多態性（編譯時多態），方法重寫實現的動態多態性（運行時多態）
重寫方法的調用原則：子類重寫父類的方法，調用子類方法；反之，調用父類的方法
多態的特點
成員函數：
•編譯時：要查看引用變量所屬的類中是否有所調用的成員。
•在運行時：要查看對象所屬的類中是否有所調用的成員。
成員變量：
•只看引用變量所屬的類。
多態指是的子類對象可以直接賦給父類變量，但運行時依然表現出子類的行為特征
多態性是指允許不同類的對象對同一消息作出響應。多態性包括參數化多態性和包含多態性。
多態性語言具有靈活、抽象、行為共享、代碼共享
的優勢，很好的解決了應用程序函數同名問題。總的來說，方法的重寫、重載與動態鏈接構成多態性。
Java引入多態的概念原因之一就是彌補
類的單繼承帶來的功能不足。（為規避C++中多繼承造成的復雜繼承問題，java采用單繼承。）
動態鏈接——對於父類中定義的方法，如果子類中重寫了該方法，那麼父類類型的引用將會調用子類中的這個方法，這就是動態鏈接。
注意：繼承與重載：一是子類與父類的關系，二是重載方法的調用問題。
子類對象可以直接當成父類對象使用，但反過來就不可以。舉例來說，人是父類，學生是人的子類，
所以學生對象一定具備人對象的屬性，但是人對象就未必具有學生對象的特性。
所以學生對象可以當做人對象來使用，但是人對象就不能當做學生對象使用。
注意當把子類對象當成父類對象使用時，子類對象將失去所有的子類特性，
只保留與父類同名的屬性和方法（同名方法不僅是函數名相同，而且參數類型也要一樣，否則不予
保留）。此時可以對父類方法進行重寫。
一個類中如果定義了重載的方法，則系統在調用方法時，會根據參數的類型自動選擇調用合適的方法。
內部類
將一個類定義在另一個類的裡面，對裡面那個類就稱為內部類（內置類，嵌套類）。
訪問特點：
•內部類可以直接訪問外部類中的成員，包括私有成員。
•而外部類要訪問內部類中的成員必須要建立內部類的對象。
內部類的位置
內部類定義在成員位置上
•可以被private static成員修飾符修飾。
•被static修飾的內部類只能訪問外部類中的靜態成員。
內部類定義在局部位置上
•也可以直接訪問外部類中的成員。
•同時可以訪問所在局部中的局部變量，但必須是被final修飾的。
匿名內部類
就是內部類的簡化寫法。
前提：
•內部類可以繼承或實現一個外部類或者接口。
格式為：
•new 外部類名或者接口名(){覆蓋類或者接口中的代碼，(也可以自定義內容。)}
簡單理解：
•就是建立一個帶內容的外部類或者接口的子類匿名對象。
什麼時候使用匿名內部類呢？
通常在使用方法是接口類型參數，並該接口中的方法不超過三個時，可以將匿名內部類作為參數傳遞。
增強閱讀性。
匿名內部類示例：
abstract class A {
abstract public void fun1();
}
class Outer {
public static void main(String[] args) {
new Outer().callInner(new A() {
public void fun1() {
System.out.println("implement for fun1");
}
});
}
public void callInner(A a) {
a.fun1();
}
}
異常
異常的體系
•Throwable
•Error
•通常出現重大問題如：運行的類不存在或者內存溢出等。
•不編寫針對代碼對其處理
•Exception
•在運行時運行出現的一種情況，可以通過try catch finally
lException和Error的子類名都是以父類名作為後綴。
Java在設計異常體系時，將容易出現的情況都封裝成了對象。
Throwable中的方法
getMessage()
•獲取異常信息，返回字符串。
toString()
•獲取異常類名和異常信息，返回字符串。
printStackTrace()
•獲取異常類名和異常信息，以及異常出現在程序中的位置。返回值void。
printStackTrace(PrintStream s)
•通常用該方法將異常內容保存在日志文件中，以便查閱。
throws和throw
throws用於標識函數暴露出的異常。
throw用於拋出異常對象。
throws與throw的區別：
•thorws用在函數上，後面跟異常類名。
•throw用在函數內，後面跟異常對象。
定義功能方法時，需要把出現的問題暴露出來讓調用者去處理。那麼就通過throws在函數上標識。
在功能方法內部出現某種情況，程序不能繼續運行，需要進行跳轉時，就用throw把異常對象拋出。
異常處理
try
{
需要檢測的代碼；
}
catch(異常類 變量)
{
異常處理代碼；
}
finally
{
一定會執行的代碼；
}
Finally代碼塊只有一種情況不會被執行。就是在之前執行了System.exit(0)。
處理過程：
Try中檢測到異常會將異常對象傳遞給catch，catch捕獲到異常進行處理。
Finally裡通常用來關閉資源。比如：數據庫資源，IO資源等。
需要注意：try是一個獨立的代碼塊，在其中定義的變量只在該變量塊中有效。
如果在try以外繼續使用，需要在try建立引用。在try對其進行初始化。IO，Socket就會遇到。
自定義異常
自定義類繼承Exception或者其子類。
通過構造函數定義異常信息。
例：
Class DemoException extends Exception
{
DemoException(String message)
{
super(message);
}
}
通過throw將自定義異常拋出。
異常細節
RuntimeException以及其子類如果在函數中被throw拋出，可以不用在函數上聲明。
一個方法被覆蓋時，覆蓋它的方法必須拋出相同的異常或異常的子類。
如果父類拋出多個異常，那麼重寫（覆蓋）方法必須拋出那些異常的一個子集，不能拋出新的異常。
介紹異常在分層設計時的層內封裝。
包(package)
對類文件進行分類管理。
給類提供多層命名空間。
寫在程序文件的第一行。
類名的全稱的是 包名.類名。
包也是一種封裝形式。
classpath
給JVM提供的一個環境變量。
指定類或者包所在的路徑。
包之間的訪問
被訪問的包中的類權限必須是public的。
類中的成員權限：public或者protected
protected是為其他包中的子類提供的一種權限
四種權限
public
protected
default
private
同一類中
√
√
√
√
同一包中
√
√
√
子類
√
√
不同包中
√
import *
一個程序文件中只有一個package，可以有多個import。
用來導包中的類，不導入包中的包。
Jar包
Java的壓縮包
•方便項目的攜帶。
•方便於使用，只要在classpath設置jar路徑即可。
•數據庫驅動，SSH框架等都是以jar包體現的。
Jar包的操作
通過jar.exe工具對jar的操作。
•創建jar包
•jar -cvf mypack.jar packa packb
•查看jar包
•jar -tvf mypack.jar [>定向文件]
•解壓縮
•jar -xvf mypack.jar
•自定義jar包的清單文件
•jar –cvfm mypack.jar mf.txt packa packb
c：創建壓縮文檔。
f：制定存檔名稱。
v：顯示詳細信息。
m：加入自定義清單信息。
通常應用與Java制作的圖形界面程序。在清單文件中其中定一個Main-Class:空格 帶有主函數的類名回車
在設置一下jar文件的打開方式通過javaw –jar就可以雙擊執行了。
