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;
}
}