抽象工廠模式java
1. 這是java的抽象工廠模式么我寫的代碼對么
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
2. java抽象工廠的使用意圖是什麼
工廠模式按照《Java與模式》中的提法分為三類： 1. 簡單工廠模式(Simple Factory) 2. 工廠方法模式(Factory Method) 3. 抽象工廠模式(Abstract Factory) 這三種模式從上到下逐步抽象，並且更具一般性。所以我建議在這種情況下使用簡單工廠模式與工廠方法模式相結合的方式來減少工廠類：即對於產品樹上類似的種類（一般是樹的葉子中互為兄弟的）使用簡單工廠模式來實現。來看看抽象工廠模式的各個角色（和工廠方法的如出一轍）： 抽象工廠角色：這是工廠方法模式的核心，它與應用程序無關。
工廠模式有三個參與者，抽象產品(Proct)、工廠(Creator)和具體產品(ConcreteProct)。客戶只會看到工廠和抽象產品。
public interface Proct{
public String getName();
}
public class ConcreteProct implements Proct{
public String getName(){
return "產品1";
}
}
public class Creator{
public static Proct create1(){
return new ConcreteProct();
}
}
工廠模式的作用在於將創建具體產品的方法由工廠類控制，客戶只需要知道產品的抽象類型
3. Java 抽象工廠模式
題目中的Collocation就相當於一個抽象工廠，在下面的Windows，Unix，Linux 三個類中實現這個介面，這三個類就相當於具體工廠，在這三個類中實現介面中的三個方法。
然後在客戶端使用的時候只需要實例化一個具體工廠，就可以得到具體的產品，如下所示：
Collocation collocation = new Windows() 或者 new Unix() 或者 new Linux()
最後用collocation 調用那三個方法，便可以得到具體的產品了。
4. 寫一個抽象工廠模式 java實例 出來
工廠模式java實例如下：
public interface Work {
void doWork();
}
ConcreteProct
public class StudentWork implements Work {
public void doWork() {
System.out.println("學生做作業!");
}
}
public class TeacherWork implements Work {
public void doWork() {
System.out.println("老師審批作業!");
}
}
生產者
public interface IWorkFactory {
Work getWork();
}
ConcreteCreator
public class StudentWorkFactory implements IWorkFactory {
public Work getWork() {
return new StudentWork();
}
}
public class TeacherWorkFactory implements IWorkFactory {
public Work getWork() {
return new TeacherWork();
}
}
Test
public class Test {
public static void main(String[] args) {
IWorkFactory studentWorkFactory = new StudentWorkFactory();
studentWorkFactory.getWork().doWork();
IWorkFactory teacherWorkFactory = new TeacherWorkFactory();
teacherWorkFactory.getWork().doWork();
}
}字元串反轉如下：
public String getReverseStr(String str)
{
String reverseStr = "";
if (null != str && !str.equals(""))
{
for (int i = 1 ; i < =str.length(); i++){
reverseStr += str.charAt(str.length() - i);
// 依次按與原字元串相反的順序拼裝字元串，內部會自動進行類型轉換
//str.length() - i剛好是str的下標，因為i是從1開始
}
}
return reverseStr;
}
冒泡排序演算法，從小到大
public int[] sortArr(int[] targetArr){
//小到大的排序
int temp = 0;
for(int i = 0;i<targetArr.length;i++){
for(int j = i;j<targetArr.length;j++){
if(targetArr[i]>targetArr[j]){
temp = targetArr[i];
targetArr[i] = targetArr[j];
targetArr[j] = temp;
}
}
}returntargetArr;
}
5. 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
6. 什麼是Java的工廠模式
factory模式不需要建立什麼包，完全得靠你對factory模式的理解，工廠模式基本上應該是體現了一個多態的概念，用戶只關心結果，而不需要關心其具體過程...
工廠模式有三個參與者，抽象產品(Proct)、工廠(Creator)和具體產品(ConcreteProct)。客戶只會看到工廠和抽象產品。
public interface Proct{
public String getName();
}
public class ConcreteProct implements Proct{
public String getName(){
return "產品1";
}
}
public class Creator{
public static Proct create1(){
return new ConcreteProct();
}
}
工廠模式的作用在於將創建具體產品的方法由工廠類控制，客戶只需要知道產品的抽象類型
7. java中抽象工廠模式和原型模式之間的區別
工廠模式的好處就在於將工廠和產品之間的耦合降低，將具體產品的構造過程放在了具體工廠類裡面。在以後擴展產品的時候方便很多，只需要添加一個工廠類，一個產品類，就能方便的添加產品，而不需要修改原有的代碼。而在簡單工廠中，如果要增加一個產品，則需要修改工廠類，增加if/else分支，或者增加一個case分支，工廠模式符合軟體開發中的OCP原則（open close principle），對擴展開放，對修改關閉。
抽象工廠模式：這個模式我總是感覺和builder模式非常相似。
工廠方法模式提供的是對一個產品的等級模式，，而抽象工廠方法提供的是對多個產品的等級模式，注意，這里的多個具體產品之間是相互耦合的，也就是說這里的抽象工廠提供的產品之間是存在某種聯系的。
有人做如下的比較：
工廠方法模式：一個抽象產品類，可以派生出多個具體產品類。
一個抽象工廠類，可以派生出多個具體工廠類。
每個具體工廠類只能創建一個具體產品類的實例。
抽象工廠模式：多個抽象產品類，每個抽象產品類可以派生出多個具體產品類。
一個抽象工廠類，可以派生出多個具體工廠類。
每個具體工廠類可以創建多個具體產品類的實例。
區別：工廠方法模式只有一個抽象產品類，而抽象工廠模式有多個。
工廠方法模式的具體工廠類只能創建一個具體產品類的實例，而抽象工廠模式可以創建多個。
8. JAVA設計模式中，抽象工廠與工廠方法的區別是什麼，兩者有什麼不同嗎
抽象工廠的方法經常以工廠方法的方式實現，兩者很容易混淆。他們的工作都是負責創建對象。不同的是工廠方法用的方法是繼承過來的，而抽象工廠是通過對象組合。其實整個工廠方法模式，只不過就是通過子類來創建對象。只需知道超類型就可以了，具體的類型由子類負責。在這一點上，抽象工廠表示毫無壓力，但是做法不同。抽象工廠提供一個用來創建一個產品家族的抽象類型，這個類型的子類定義了產品被產生的方法。要想使用這個工廠，必須先實例化它（產品家族的抽象類型，通過組合而來）。它的優點是可以把一群相關的產品集合起來，缺點是如果有新產品加入需要修改介面代碼，這會涉及到所有子類介面的更改，是一個很繁瑣的工作。而工廠方法有點相反，它只是創建一個產品，不需要很大的介面，一個方法就可以了。如果你目前還不知道將來需要實例化哪些類時，也可以使用工廠方法，只要繼承它，實現工廠方法就可以了。
舉一個例子：如果你有一個超市，只買一種物品，建議用工廠方法。如果有很多物品，就使用抽象工廠。當然，各有各的特點，最終都是學以致用，解決實際問題。很多問題都是結合各種辦法解決的。
9. 什麼是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