java抽象工廠
1. java 抽象工廠和工廠方法模式的區別
工廠方法模式：一個抽象產品類，可以派生出多個具體產品類。
一個抽象工廠類，可以派生出多個具體工廠類。
每個具體工廠類只能創建一個具體產品類的實例。
抽象工廠模式：多個抽象產品類，每個抽象產品類可以派生出多個具體產品類。
一個抽象工廠類，可以派生出多個具體工廠類。
每個具體工廠類可以創建多個具體產品類的實例。
2. java工廠方法和抽象工廠的區別
而抽象工廠模式有多個：一個抽象產品類，可以派生出多個具體工廠類。 每個具體工廠類可以創建多個具體產品類的實例。 一個抽象工廠類：工廠方法模式只有一個抽象產品類，可以派生出多個具體產品類。抽象工廠模式：多個抽象產品類。 一個抽象工廠類，每個抽象產品類可以派生出多個具體產品類。 區別。 工廠方法模式的具體工廠類只能創建一個具體產品類的實例。 每個具體工廠類只能創建一個具體產品類的實例工廠方法模式，而抽象工廠模式可以創建多個，可以派生出多個具體工廠類
3. java常用的的設計模式和開發模式都有哪些
設計模式主要分三個類型、創建型、結構型和行為型。設計模式分：3種類型及23種模式。
JAVA中的開發模式：MVC是一個很常用的程序開發設計模式，M-Model（模型）：封裝應用程序的狀態；V-View（視圖）：表示用戶界面；C-Controller（控制器）：對用戶的輸入作出反應，創建並設置模型。
(3)java抽象工廠擴展閱讀
創建型模式：單例模式、抽象工廠模式、建造者模式、工廠模式、原型模式。
結構型模式：適配器模式、橋接模式、裝飾模式、組合模式、外觀模式、享元模式、代理模式。
行為型模式：模版方法模式、命令模式、迭代器模式、觀察者模式、中介者模式、備忘錄模式、解釋器模式（Interpreter模式）、狀態模式、策略模式、職責鏈模式(責任鏈模式)、訪問者模式。
4. JAVA設計模式中，抽象工廠與工廠方法的區別是什麼，兩者有什麼不同嗎
抽象工廠的方法經常以工廠方法的方式實現，兩者很容易混淆。他們的工作都是負責創建對象。不同的是工廠方法用的方法是繼承過來的，而抽象工廠是通過對象組合。其實整個工廠方法模式，只不過就是通過子類來創建對象。只需知道超類型就可以了，具體的類型由子類負責。在這一點上，抽象工廠表示毫無壓力，但是做法不同。抽象工廠提供一個用來創建一個產品家族的抽象類型，這個類型的子類定義了產品被產生的方法。要想使用這個工廠，必須先實例化它（產品家族的抽象類型，通過組合而來）。它的優點是可以把一群相關的產品集合起來，缺點是如果有新產品加入需要修改介面代碼，這會涉及到所有子類介面的更改，是一個很繁瑣的工作。而工廠方法有點相反，它只是創建一個產品，不需要很大的介面，一個方法就可以了。如果你目前還不知道將來需要實例化哪些類時，也可以使用工廠方法，只要繼承它，實現工廠方法就可以了。
舉一個例子：如果你有一個超市，只買一種物品，建議用工廠方法。如果有很多物品，就使用抽象工廠。當然，各有各的特點，最終都是學以致用，解決實際問題。很多問題都是結合各種辦法解決的。
5. java 設計模式（工廠方法）
面向抽象（抽象類或介面）編程。
IWorkFactory studentWorkFactory = new StudentWorkFactory(); 注意：類型是介面類型，即抽象工廠，抽象工廠生產的是抽象產品，而new的則是具體工廠，是由子類實現的，具體工廠生產具體產品。面向抽象的好處：1.在設計抽象的時候不用管具體的實現，只要定義介面知道它用來干什麼就行，這樣，我只需要知道抽象介面就能繼續下面的開發設計工作了，而不用事先設計具體的實現內容；2. 可以擴展多個子類實現抽象介面，更利於系統後期的擴展，而對原系統不造成任何影響，即：開-閉原則。
TeacherWork tt = new TeacherWork(); 不用說就是面向具體實現類編程，缺點就是擴展性不好，對系統後期維護擴展影響較大。
舉個簡單的例子：
假如在系統的A.java中代碼中使用了TeacherWork 類型對象，是滿足了目前軟體的需求，但是，如果有一天需求變化了需要一個StudentWork 類型對象，該怎麼辦？只能修改A.java類來滿足這樣的修改需求。這樣就影響了原來系統結構穩定性，需要重新調試和測試，而這帶來的維護成本是非常大的，有時可能還會帶來系統錯誤，而影響系統運行。
如果在A.java類中應用Work介面類型就不會存在這種問題，A.java不需要任何修改，只需要修改注入到A中的Work介面的具體實現類即可。
面向抽象編程的好處就在於對系統維護和擴展上，即在不影響原系統穩定運行的基礎上增加新的擴展行為，即要符合「開-閉」原則。可能會因此而失去一定的效率問題，但是對於後期的維護成本來說，這個可以忽略不計。 推薦你一本好書：《軟體秘笈-設計模式那點事》其中講解的設計模式很到位，還有每個模式的靜態類圖和JDK中設計模式的具體分析講解，讀了收獲一定很大。祝你成功！
6. java 抽象工廠模式
工廠模式在項目中是常常用到的,有人說只有大項目才會用到,小項目是體會不出來.其實使用設計模式與項目的大小沒有實質性的聯系.設計模式是經驗的總結而不是衡量項目大小的標准.
以開發項目的DAO層為例,在項目中客戶的需求是常常變動的,臨時更換資料庫的需求也是常常發生的,那我們要如何解決跨資料庫的功能,這里就要使用到抽象工廠模式了.工廠模式常常用於創建多系列化的對象(如Orale系列,Mysql系列)
1.首先定義相關介面(與平常的做法沒什麼區別)
Java代碼
// 角色表DAO介面
interface IroleDao {
void insert();
void update();
}
// 用戶表DAO介面
interface IuserDao {
void find();
void delete();
}
// 角色表DAO介面
interface IroleDao {
void insert();
void update();
}
// 用戶表DAO介面
interface IuserDao {
void find();
void delete();
} 2.不同的資料庫有不同的SQL語句所以實現時必須分資料庫來實現
Java代碼
// 用戶表Oralce資料庫DAO
class OracleuserDao implements IuserDao {
public void delete() {
System.out.println("Oralce 刪除用戶表數據");
}
public void find() {
System.out.println("Oralce 查詢用戶表數據");
}
}
// 用戶表MySql資料庫DAO
class MySqluserDao implements IuserDao {
public void delete() {
System.out.println("MySql 刪除用戶數據");
}
public void find() {
System.out.println("MySql 查詢用戶數據");
}
}
// 角色表Oracle資料庫DAO
class OracleroleDao implements IroleDao {
public void insert() {
System.out.println("Oralce 對角色表插入數據");
}
public void update() {
System.out.println("Oracle 對角色表更新數據");
}
}
// 角色表MySql資料庫DAO
class MySqlroleDAO implements IroleDao {
public void insert() {
System.out.println("MySql 對角色表插入數據");
}
public void update() {
System.out.println("Mysql 對角色表更新數據");
}
}
// 用戶表Oralce資料庫DAO
class OracleuserDao implements IuserDao {
public void delete() {
System.out.println("Oralce 刪除用戶表數據");
}
public void find() {
System.out.println("Oralce 查詢用戶表數據");
}
}
// 用戶表MySql資料庫DAO
class MySqluserDao implements IuserDao {
public void delete() {
System.out.println("MySql 刪除用戶數據");
}
public void find() {
System.out.println("MySql 查詢用戶數據");
}
}
// 角色表Oracle資料庫DAO
class OracleroleDao implements IroleDao {
public void insert() {
System.out.println("Oralce 對角色表插入數據");
}
public void update() {
System.out.println("Oracle 對角色表更新數據");
}
}
// 角色表MySql資料庫DAO
class MySqlroleDAO implements IroleDao {
public void insert() {
System.out.println("MySql 對角色表插入數據");
}
public void update() {
System.out.println("Mysql 對角色表更新數據");
}
}
這里增加了一套DAO的實現 (與平時有所不同,如果有10個資料庫就要加上10種不同的實現,比較麻煩呀)
3.定義DAO工廠介面與實現(利用java反射機制生產出你需要的DAO如:userDAO,roleDao)
Java代碼
// DAO工廠
abstract class DaoFactory {
public static DaoFactory getInstance(String classname) {
DaoFactory = null;
try {
= (DaoFactory) Class.forName(classname).newInstance();
} catch (Exception e) {
e.printStackTrace();
}
return ;
}
abstract IuserDao getuser();
abstract IroleDao getrole();
}
// Oralce工廠
class OracleFactory extends DaoFactory {
public IroleDao getrole() {
return new OracleroleDao();
}
public IuserDao getuser() {
return new OracleuserDao();
}
}
// MySql工廠
class MysqlFactory extends DaoFactory {
public IroleDao getrole() {
return new MySqlroleDAO();
}
public IuserDao getuser() {
return new MySqluserDao();
}
}
// DAO工廠
abstract class DaoFactory {
public static DaoFactory getInstance(String classname) {
DaoFactory = null;
try {
= (DaoFactory) Class.forName(classname).newInstance();
} catch (Exception e) {
e.printStackTrace();
}
return ;
}
abstract IuserDao getuser();
abstract IroleDao getrole();
}
// Oralce工廠
class OracleFactory extends DaoFactory {
public IroleDao getrole() {
return new OracleroleDao();
}
public IuserDao getuser() {
return new OracleuserDao();
}
}
// MySql工廠
class MysqlFactory extends DaoFactory {
public IroleDao getrole() {
return new MySqlroleDAO();
}
public IuserDao getuser() {
return new MySqluserDao();
}
}
4. 定義配置文件
Java代碼
class Config {
// Oralce
static final String ORALCE = "org.abc.OracleFactory";
static final String MYSQL = "org.abc.MysqlFactory";
}
class Config {
// Oralce
static final String ORALCE = "org.abc.OracleFactory";
static final String MYSQL = "org.abc.MysqlFactory";
}
配置文件可以定義到XML中去(好處:修改配置項之後不需要對JAVA文件進行編譯.)
5.測試你的輸出的DAO
Java代碼
public class Dao {
public static void main(String[] args) {
DaoFactory.getInstance(Config.ORALCE).getrole().insert();
DaoFactory.getInstance(Config.MYSQL).getrole().insert();
}
}
public class Dao {
public static void main(String[] args) {
DaoFactory.getInstance(Config.ORALCE).getrole().insert();
DaoFactory.getInstance(Config.MYSQL).getrole().insert();
}
}
總結
使用條件：一系列介面有一系列的實現
如上IuserDao、IroleDao等一系列的介面，他們可以有一系列的實現(Oracle方式、MySql方式)
OracleuserDao、OracleroleDao、MySqluserDao、MySqlroleDAO
組成元素(以上面例子)
一系列介面：IuserDao、IroleDao
一系列實現：Oracle系列、MySql系列
系列工廠類：Oracle系列工廠類、MySql系列工廠類(必須繼承抽象工廠類)
抽象工廠類：DaoFactory
7. java中抽象工廠模式和原型模式之間的區別
工廠模式的好處就在於將工廠和產品之間的耦合降低，將具體產品的構造過程放在了具體工廠類裡面。在以後擴展產品的時候方便很多，只需要添加一個工廠類，一個產品類，就能方便的添加產品，而不需要修改原有的代碼。而在簡單工廠中，如果要增加一個產品，則需要修改工廠類，增加if/else分支，或者增加一個case分支，工廠模式符合軟體開發中的OCP原則（open close principle），對擴展開放，對修改關閉。
抽象工廠模式：這個模式我總是感覺和builder模式非常相似。
工廠方法模式提供的是對一個產品的等級模式，，而抽象工廠方法提供的是對多個產品的等級模式，注意，這里的多個具體產品之間是相互耦合的，也就是說這里的抽象工廠提供的產品之間是存在某種聯系的。
有人做如下的比較：
工廠方法模式：一個抽象產品類，可以派生出多個具體產品類。
一個抽象工廠類，可以派生出多個具體工廠類。
每個具體工廠類只能創建一個具體產品類的實例。
抽象工廠模式：多個抽象產品類，每個抽象產品類可以派生出多個具體產品類。
一個抽象工廠類，可以派生出多個具體工廠類。
每個具體工廠類可以創建多個具體產品類的實例。
區別：工廠方法模式只有一個抽象產品類，而抽象工廠模式有多個。
工廠方法模式的具體工廠類只能創建一個具體產品類的實例，而抽象工廠模式可以創建多個。
8. 在java文檔中出現的 「工廠方法」是什麼意思
工廠模式是我們最常用的模式了,著名的Jive論壇 ,就大量使用了工廠模式，工廠模式在Java程序系統可以說是隨處可見。
為什麼工廠模式是如此常用？因為工廠模式就相當於創建實例對象的new，我們經常要根據類Class生成實例對象，如A a=new A() 工廠模式也是用來創建實例對象的，所以以後new時就要多個心眼，是否可以考慮實用工廠模式，雖然這樣做，可能多做一些工作，但會給你系統帶來更大的可擴展性和盡量少的修改量。
我們以類Sample為例， 如果我們要創建Sample的實例對象:
Sample sample=new Sample();
可是，實際情況是，通常我們都要在創建sample實例時做點初始化的工作,比如賦值 查詢資料庫等。
首先，我們想到的是，可以使用Sample的構造函數，這樣生成實例就寫成:
Sample sample=new Sample(參數);
但是，如果創建sample實例時所做的初始化工作不是象賦值這樣簡單的事，可能是很長一段代碼，如果也寫入構造函數中，那你的代碼很難看了（就需要Refactor重整）。
為什麼說代碼很難看，初學者可能沒有這種感覺，我們分析如下，初始化工作如果是很長一段代碼，說明要做的工作很多，將很多工作裝入一個方法中，相當於將很多雞蛋放在一個籃子里，是很危險的，這也是有背於Java面向對象的原則，面向對象的封裝(Encapsulation)和分派(Delegation)告訴我們，盡量將長的代碼分派「切割」成每段，將每段再「封裝」起來(減少段和段之間偶合聯系性)，這樣，就會將風險分散，以後如果需要修改，只要更改每段，不會再發生牽一動百的事情。
在本例中，首先，我們需要將創建實例的工作與使用實例的工作分開, 也就是說，讓創建實例所需要的大量初始化工作從Sample的構造函數中分離出去。
這時我們就需要Factory工廠模式來生成對象了，不能再用上面簡單new Sample(參數)。還有,如果Sample有個繼承如MySample, 按照面向介面編程,我們需要將Sample抽象成一個介面.現在Sample是介面,有兩個子類MySample 和HisSample .我們要實例化他們時,如下:
Sample mysample=new MySample();
Sample hissample=new HisSample();
隨著項目的深入,Sample可能還會"生出很多兒子出來", 那麼我們要對這些兒子一個個實例化,更糟糕的是,可能還要對以前的代碼進行修改:加入後來生出兒子的實例.這在傳統程序中是無法避免的.
但如果你一開始就有意識使用了工廠模式,這些麻煩就沒有了.
工廠方法
你會建立一個專門生產Sample實例的工廠:
public class Factory{
public static Sample creator(int which){
//getClass 產生Sample 一般可使用動態類裝載裝入類。
if (which==1)
return new SampleA();
else if (which==2)
return new SampleB();
}
}
那麼在你的程序中,如果要實例化Sample時.就使用
Sample sampleA=Factory.creator(1);
這樣,在整個就不涉及到Sample的具體子類,達到封裝效果,也就減少錯誤修改的機會,這個原理可以用很通俗的話來比喻:就是具體事情做得越多,越容易范錯誤.這每個做過具體工作的人都深有體會,相反,官做得越高,說出的話越抽象越籠統,范錯誤可能性就越少.好象我們從編程序中也能悟出人生道理?呵呵.
使用工廠方法 要注意幾個角色，首先你要定義產品介面，如上面的Sample,產品介面下有Sample介面的實現類,如SampleA,其次要有一個factory類，用來生成產品Sample，如下圖，最右邊是生產的對象Sample：
進一步稍微復雜一點，就是在工廠類上進行拓展，工廠類也有繼承它的實現類concreteFactory了。
抽象工廠
工廠模式中有: 工廠方法(Factory Method) 抽象工廠(Abstract Factory).
這兩個模式區別在於需要創建對象的復雜程度上。如果我們創建對象的方法變得復雜了,如上面工廠方法中是創建一個對象Sample,如果我們還有新的產品介面Sample2.
這里假設：Sample有兩個concrete類SampleA和SamleB，而Sample2也有兩個concrete類Sample2A和SampleB2
那麼，我們就將上例中Factory變成抽象類,將共同部分封裝在抽象類中,不同部分使用子類實現，下面就是將上例中的Factory拓展成抽象工廠:
public abstract class Factory{
public abstract Sample creator();
public abstract Sample2 creator(String name);
}
public class SimpleFactory extends Factory{
public Sample creator(){
.........
return new SampleA
}
public Sample2 creator(String name){
.........
return new Sample2A
}
}
public class BombFactory extends Factory{
public Sample creator(){
......
return new SampleB
}
public Sample2 creator(String name){
......
return new Sample2B
}
}
從上面看到兩個工廠各自生產出一套Sample和Sample2,也許你會疑問，為什麼我不可以使用兩個工廠方法來分別生產Sample和Sample2?
抽象工廠還有另外一個關鍵要點，是因為 SimpleFactory內，生產Sample和生產Sample2的方法之間有一定聯系，所以才要將這兩個方法捆綁在一個類中，這個工廠類有其本身特徵，也許製造過程是統一的，比如：製造工藝比較簡單，所以名稱叫SimpleFactory。
在實際應用中，工廠方法用得比較多一些，而且是和動態類裝入器組合在一起應用，
舉例
我們以Jive的ForumFactory為例，這個例子在前面的Singleton模式中我們討論過，現在再討論其工廠模式:
public abstract class ForumFactory {
private static Object initLock = new Object();
private static String className = "com.jivesoftware.forum.database.DbForumFactory";
private static ForumFactory factory = null;
public static ForumFactory getInstance(Authorization authorization) {
//If no valid authorization passed in, return null.
if (authorization == null) {
return null;
}
//以下使用了Singleton 單態模式
if (factory == null) {
synchronized(initLock) {
if (factory == null) {
......
try {
//動態轉載類
Class c = Class.forName(className);
factory = (ForumFactory)c.newInstance();
}
catch (Exception e) {
return null;
}
}
}
}
//Now, 返回 proxy.用來限制授權對forum的訪問
return new ForumFactoryProxy(authorization, factory,
factory.getPermissions(authorization));
}
//真正創建forum的方法由繼承forumfactory的子類去完成.
public abstract Forum createForum(String name, String description)
throws UnauthorizedException, ForumAlreadyExistsException;
....
}
因為現在的Jive是通過資料庫系統存放論壇帖子等內容數據,如果希望更改為通過文件系統實現,這個工廠方法ForumFactory就提供了提供動態介面:
private static String className = "com.jivesoftware.forum.database.DbForumFactory";
你可以使用自己開發的創建forum的方法代替com.jivesoftware.forum.database.DbForumFactory就可以.
在上面的一段代碼中一共用了三種模式,除了工廠模式外,還有Singleton單態模式,以及proxy模式,proxy模式主要用來授權用戶對forum的訪問,因為訪問forum有兩種人:一個是注冊用戶 一個是遊客guest,那麼那麼相應的許可權就不一樣,而且這個許可權是貫穿整個系統的,因此建立一個proxy,類似網關的概念,可以很好的達到這個效果.
看看Java寵物店中的CatalogDAOFactory:
public class CatalogDAOFactory {
/**
* 本方法制定一個特別的子類來實現DAO模式。
* 具體子類定義是在J2EE的部署描述器中。
*/
public static CatalogDAO getDAO() throws CatalogDAOSysException {
CatalogDAO catDao = null;
try {
InitialContext ic = new InitialContext();
//動態裝入CATALOG_DAO_CLASS
//可以定義自己的CATALOG_DAO_CLASS，從而在無需變更太多代碼
//的前提下，完成系統的巨大變更。
String className =(String) ic.lookup(JNDINames.CATALOG_DAO_CLASS);
catDao = (CatalogDAO) Class.forName(className).newInstance();
} catch (NamingException ne) {
throw new CatalogDAOSysException("
CatalogDAOFactory.getDAO: NamingException while
getting DAO type : \n" + ne.getMessage());
} catch (Exception se) {
throw new CatalogDAOSysException("
CatalogDAOFactory.getDAO: Exception while getting
DAO type : \n" + se.getMessage());
}
return catDao;
}
}
CatalogDAOFactory是典型的工廠方法，catDao是通過動態類裝入器className獲得CatalogDAOFactory具體實現子類，這個實現子類在Java寵物店是用來操作catalog資料庫，用戶可以根據資料庫的類型不同，定製自己的具體實現子類，將自己的子類名給與CATALOG_DAO_CLASS變數就可以。
由此可見，工廠方法確實為系統結構提供了非常靈活強大的動態擴展機制，只要我們更換一下具體的工廠方法，系統其他地方無需一點變換，就有可能將系統功能進行改頭換面的變化。
9. JAVA抽象工廠模式中，類圖里具體工廠類和具體產品類之間的關系為什麼是依賴關系
是的吧，我感覺就是這么回事，關聯關系不如依賴那麼緊畢竟。A本身沒有B的引用，卻需要B，那麼A必須要有B的引用作為參數。要是A本身有B的引用，那麼B是A的一個組成部分了，在程序中A就不需要B作為參數來提供給A了。
10. java什麼是抽象工廠
抽象工廠模式：提供一個創建一系列相關或相互依賴對象的介面，而無需指定它們具體的類。
舉一個電腦產品的例子吧：
IBM，Dell都是著名的計算機生產廠家，他們採用的主板、硬碟及CPU是不相同的，但是配件間、主板與CPU一定要相互兼容，例如下面例子中的微星MSIK7N2G配AMD的CPU；微星MSI865PE配Intel的CPU。
如圖中所示，ComputerFactory是抽象工廠，Dell和IBM是生產產品的工廠；CPU、HardDisk、MainBoard是抽象產品，CPU的型號又分許多種。具體實現見代碼：
首先，定義CPU的介面：
public interface CPU{
public String getCPU();
}
定義AMD類，實現CPU介面：
public class AMD implements CPU{
public String getCPU(){
return 「Athlon XP 2008+」;
}
定義Intel類，實現CPU介面：
public class Intel implements CPU{
public String getCPU(){
return 「奔騰4 3.2C」;
}
}
定義硬碟介面：
public interface HardDisk{
public String getSize();
}
定義Maxtor類，實現硬碟介面：
public class Maxtor implements HardDisk{
public String getSize(){
return 「MaXLine Plus II 200G」;
}
}
定義WestDigit，實現硬碟介面：
public class WestDigit implements HardDisk{
public String getSize(){
return 「WD2500JD 250G」;
}
}
定義主板的介面，包含參數為CPU的公共方法Attach():
public interface MainBoard{
public void Attach(CPU cpu) throws Exception;
}
主板微星MSI865PE，支持Intel的CPU：
public class MSI865PE implements MainBoard{
public void Attach(CPU cpu) throws Exception{
if(cpu.getClass ().toString ().endsWith(「Intel」)){
System.out.println(「MSI865PE」);
}
else{
throw new Exception(「主板MSI865PE只能配Intel的 CPU」)；
}
}
}
主板微星MSIK7N2G，支持AMD的CPU：
public class MSIK7N2G implements MainBoard{
public void Attach(CPU cpu) throws Exception{
if(cpu.getClass ().toString ().endsWith(「AMD」)){
System.out.println(「MSIK7N2G」);
}
else{
throw new Exception(「主板MSIK7N2G只能配AMD的CPU」);
}
}
}
定義抽象電腦工廠類：
public abstract class ComputerFactory{
CPU cpu;
HardDisk hd;
MainBoard mb;
public void show(){
try{
System.out.println(this.getClass().getName() .toString () + (「生產的電腦配置」);
System.out.println (「CPU:」 + cpu.getCPU ());
System.out.println (「HardDisk:」 + hd.getSize ());
System.out.print (「MainBoard:」);
mb.Attach.(cpu);
}
catch(Exception e){
System.err.println(e.getMessage());
}
}
}
抽象電腦工廠類派生類IBM，定義其返回的系列配件產品：
public class IBM extends ComputerFactory{
IBM(){
cpu = new Intel();
hd = new WestDigit();
mb = new MSI865PE();
}
}
抽象電腦工廠類派生類Dell，定義其返回的系列配件產品：
public class Dell extends ComputerFactory{
Dell(){
cpu = new AMD();
hd = new Maxtor();
mb = new MSIK7N2G();
}
}
客戶程序調用：
Public class Client{
public static void main(String argv[]){
IBM ibm = new IBM();
ibm.show();
Dell dell = new Dell();
dell.show();
}
}
輸出結果為：
Computerworld.IBM生產的電腦配置
CPU:奔騰4 3.2C
HardDisk:WD2500JD 250G
MainBoard:MSI865PE
Computerworld.Dell生產的電腦配置
CPU:Athlon XP 2800+
HardDisk:MaXLine Plus II 200G
MainBoard:MSIK7N2G