java抽象工廠工廠

㈠ java 抽象工廠和工廠方法模式的區別

工廠方法模式：一個抽象產品類，可以派生出多個具體產品類。
一個抽象工廠類，可以派生出多個具體工廠類。
每個具體工廠類只能創建一個具體產品類的實例。
抽象工廠模式：多個抽象產品類，每個抽象產品類可以派生出多個具體產品類。
一個抽象工廠類，可以派生出多個具體工廠類。
每個具體工廠類可以創建多個具體產品類的實例。

㈡ JAVA設計模式中，抽象工廠與工廠方法的區別是什麼，兩者有什麼不同嗎

抽象工廠的方法經常以工廠方法的方式實現，兩者很容易混淆。他們的工作都是負責創建對象。不同的是工廠方法用的方法是繼承過來的，而抽象工廠是通過對象組合。其實整個工廠方法模式，只不過就是通過子類來創建對象。只需知道超類型就可以了，具體的類型由子類負責。在這一點上，抽象工廠表示毫無壓力，但是做法不同。抽象工廠提供一個用來創建一個產品家族的抽象類型，這個類型的子類定義了產品被產生的方法。要想使用這個工廠，必須先實例化它（產品家族的抽象類型，通過組合而來）。它的優點是可以把一群相關的產品集合起來，缺點是如果有新產品加入需要修改介面代碼，這會涉及到所有子類介面的更改，是一個很繁瑣的工作。而工廠方法有點相反，它只是創建一個產品，不需要很大的介面，一個方法就可以了。如果你目前還不知道將來需要實例化哪些類時，也可以使用工廠方法，只要繼承它，實現工廠方法就可以了。
舉一個例子：如果你有一個超市，只買一種物品，建議用工廠方法。如果有很多物品，就使用抽象工廠。當然，各有各的特點，最終都是學以致用，解決實際問題。很多問題都是結合各種辦法解決的。

㈢ Java 什麼是抽象工廠,請舉個例子

抽象工廠模式：提供一個創建一系列相關或相互依賴對象的介面，而無需指定它們具體的類。

舉一個電腦產品的例子吧：

IBM，Dell都是著名的計算機生產廠家，他們採用的主板、硬碟及CPU是不相同的，但是配件間、主板與CPU一定要相互兼容，例如下面例子中的微星MSIK7N2G配AMD的CPU；微星MSI865PE配Intel的CPU。

如圖中所示，ComputerFactory是抽象工廠，Dell和IBM是生產產品的工廠；CPU、HardDisk、MainBoard是抽象產品，CPU的型號又分許多種。具體實現見代碼：

首先，定義CPU的介面：

publicinterfaceCPU{

publicStringgetCPU();

}

定義AMD類，實現CPU介面：

publicclassAMDimplementsCPU{

publicStringgetCPU(){

return「AthlonXP2008+」;

}

定義Intel類，實現CPU介面：

publicclassIntelimplementsCPU{

publicStringgetCPU(){

return「奔騰43.2C」;

}

}

定義硬碟介面：

publicinterfaceHardDisk{

publicStringgetSize();

}

定義Maxtor類，實現硬碟介面：

{

publicStringgetSize(){

return「MaXLinePlusII200G」;

}

}

定義WestDigit，實現硬碟介面：

{

publicStringgetSize(){

return「WD2500JD250G」;

}

}

定義主板的介面，包含參數為CPU的公共方法Attach():

publicinterfaceMainBoard{

publicvoidAttach(CPUcpu)throwsException;

}

主板微星MSI865PE，支持Intel的CPU：

{

publicvoidAttach(CPUcpu)throwsException{

if(cpu.getClass().toString().endsWith(「Intel」)){

System.out.println(「MSI865PE」);

}

else{

thrownewException(「主板MSI865PE只能配Intel的CPU」)；

}

}

}

主板微星MSIK7N2G，支持AMD的CPU：

{

publicvoidAttach(CPUcpu)throwsException{

if(cpu.getClass().toString().endsWith(「AMD」)){

System.out.println(「MSIK7N2G」);

}

else{

thrownewException(「主板MSIK7N2G只能配AMD的CPU」);

}

}

}

定義抽象電腦工廠類：

{

CPUcpu;

HardDiskhd;

MainBoardmb;

publicvoidshow(){

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(Exceptione){

System.err.println(e.getMessage());

}

}

}

抽象電腦工廠類派生類IBM，定義其返回的系列配件產品：

{

IBM(){

cpu=newIntel();

hd=newWestDigit();

mb=newMSI865PE();

}

}

抽象電腦工廠類派生類Dell，定義其返回的系列配件產品：

{

Dell(){

cpu=newAMD();

hd=newMaxtor();

mb=newMSIK7N2G();

}

}

客戶程序調用：

PublicclassClient{

publicstaticvoidmain(Stringargv[]){

IBMibm=newIBM();

ibm.show();

Delldell=newDell();

dell.show();

}

}

輸出結果為：

Computerworld.IBM生產的電腦配置

CPU:奔騰43.2C

HardDisk:WD2500JD250G

MainBoard:MSI865PE

Computerworld.Dell生產的電腦配置

CPU:AthlonXP2800+

HardDisk:MaXLinePlusII200G

MainBoard:MSIK7N2G

㈣ 什麼是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

㈤ 工廠模式,簡單工廠模式,抽象工廠模式三者有什麼區別

工廠模式、簡單工廠模式、抽象工廠模式三者的區別：

1、創建對象不同。創建對象時，「工廠模式」使用Factory模式替代使用new創建對象；「簡單工廠模式」使用fw模式建立對象；「抽象工廠模式」則使用迭代模式創建對象。

(5)java抽象工廠工廠擴展閱讀

編程使用「工廠模式」的優缺點：

1、優點：

方便擴展演算法，比如增加一個開根號的功能，我們只要繼續繼承運算類就行了，同時客戶端也就是使用者不知道具體的實現細節，只要給出相關標示符，工廠函數就馬上給他創建一個他想要的實體就行了。減少了使用者和功能開發者之間的耦合度。

2、缺點：

在進行擴展的時候，我們要更改工廠函數裡面的那個分支語句Switch，這樣便破壞了OCP，而且當有多級結構繼承的時候，簡單工廠就會因為只能對應平行一層記得繼承，不得不使得好多類繼承同一個介面，然後得到A*B這么多的工廠實體可能，工廠函數很難維護。

㈥ java中，什麼叫抽象工廠方法

抽象工廠方法是設計模式的一種，我有本電子書是專門講設計模式的，其中就有抽象工廠方法模式，裡面的例子寫的也挺好的，如果需要我發給你。

㈦ Java 抽象工廠模式

題目中的Collocation就相當於一個抽象工廠，在下面的Windows，Unix，Linux 三個類中實現這個介面，這三個類就相當於具體工廠，在這三個類中實現介面中的三個方法。
然後在客戶端使用的時候只需要實例化一個具體工廠，就可以得到具體的產品，如下所示：

Collocation collocation = new Windows() 或者 new Unix() 或者 new Linux()

最後用collocation 調用那三個方法，便可以得到具體的產品了。

㈧ 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

㈨ Java的幾個工廠方法解析

Java工廠模式可分為三種：
1.靜態工廠模式
2.工廠方法模式
3.抽象工廠模式
一、靜態工廠模式：用靜態的方法實現，其創建的對象具有一定的特性
舉例如下：
Vehicle類：
public abstract class Vehicle
{
private String name;

public Vehicle (){
super();
}
public Vehicle (String name){
super();
this.name=name;
}
public abstract void run();
public String getName(){
return name;
}
public void setName(String name){
this.name=name;
}
}

Bus類：
public class Bus extends Vehicle
{
private String name;

public Bus(){}
public Bus(String name){
super(name);
}
@Override
public abstract void run(){
System.out.println("Bus is running");
}
}

Car類：
public class Car extends Vehicle
{
private String name;

public Car(){}
public Car(String name){
super(name);
}
@Override
public abstract void run(){
System.out.println("Car is running");
}
}

靜態工廠類：
（靜態工廠創建一個對象，
靜態工廠創建的對象一般都有一個共同的特性，
繼承自某一個類，
或者引用一個介面）

public class StaticFactory{
public static Object getInstance(String className){
Object instance=null;
try{
Class c=Class.forName(className);
instance=c.newInstance();
}catch(Exception e){}
return instance;
}

public static Object getInstance(String className,Object ...args){
Class c=null;
try{
c=Class.forName(className);
}catch(Exception e){}
Constructor[] cons=c.getConstructors();
Object instance=null;
for(Constructor con:cons){
Class<?>[] cs=con.getParmeterTypes();
if(cs.length>0){
boolean isConstructor=true;
for(int i=0;i<cs.length;i++){
Class t=cs[i];
if(!t.isInstance(args[i])){
isConstructor=false;
}
}
if(isConstructor){
try{
instance=con.newInstance(args);
break;
}catch(Exception e){}
}else{
continue;
}
}
}
return instance;
}
}

二、工廠方法模式：主要是對各類東西分類生產，但分類生產的對象仍然具有某一特性。
如果說靜態工廠是一個綜合的交通工具建造工廠，
那麼工廠方法模式就是具體分工，分成Bus與Car的工廠，
各自生產各自的產品，但是造出來的還是交通工具。

交通工具製造介面：
public interface VehicleMake{
/**製造交通工具**/
public Vehicle make();
}

Bus製造類：
public class BusMake implements VehicleMake{
@Override
public Vehicle make(){
Vehicle bus=new Bus();
System.out.println("Bus工廠製造了一輛Bus");
return bus;
}
}

Car製造類：
public class CarMake implements VehicleMake{
@Override
public Vehicle make(){
Vehicle car=new Car();
System.out.println("Car工廠製造了一輛Car");
return car;
}
}

三、抽象工廠模式：抽象工廠生產的對象可能是沒有共同特性的。比如，一個製造工廠BusMake不僅能製造Bus還能生產輪胎wheel等配件，Bus是交通工具，wheel是配件（代碼中有部分類沒具體寫出來只給了類名）

總工廠（抽象工廠總介面）：
public interface WheelVehicleMake extends VehicleMake{
/**製造輪胎**/
public Wheel makeWheel();
}

輪子BusMake：
public class WheelBusMake implements WheelVehicleMake{
@Override
public Vehicle make(){
Vehicle bus=new Bus();
System.out.println("WheelBusMake生產了一輛Bus");
return bus;
}
@Override
public Wheel makeWheel(){
Wheel busWheel=new BusWheel();
System.out.println("WheelBusMake生產了一個Bus輪子");
return busWheel;
}
}

輪子CarMake：
public class WheelCarMake implements WheelVehicleMake{
@Override
public Vehicle make(){
Vehicle car=new Car();
System.out.println("WheelCarMake生產了一輛Car");
return car;
}
@Override
public Wheel makeWheel(){
Wheel carWheel=new CarWheel();
System.out.println("WheelCarMake生產了一個Car輪子");
return carWheel;
}
}