「抽象工厂方法java」抽象工厂方法模式符合开闭原则吗?

今天给各位分享抽象工厂方法java的知识，其中也会对抽象工厂方法模式符合开闭原则吗?进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

• 1、什么是java抽象工厂模式？
• 2、java 抽象工厂和工厂方法模式的区别
• 3、JAVA设计模式中，抽象工厂与工厂方法的区别是什么，两者有什么不同吗？
• 4、java抽象工厂的使用意图是什么?
• 5、Java 什么是抽象工厂,请举个例子
• 6、java中抽象工厂模式和原型模式之间的区别

什么是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 dao = null;

try {

dao = (DaoFactory) Class.forName(classname).newInstance();

} catch (Exception e) {

e.printStackTrace();

}

return dao;

}

abstract IuserDao getuserdao();

abstract IroleDao getroledao();

}

// Oralce工厂

class OracleFactory extends DaoFactory {

public IroleDao getroledao() {

return new OracleroleDao();

}

public IuserDao getuserdao() {

return new OracleuserDao();

}

}

// MySql工厂

class MysqlFactory extends DaoFactory {

public IroleDao getroledao() {

return new MySqlroleDAO();

}

public IuserDao getuserdao() {

return new MySqluserDao();

}

}

// DAO工厂

abstract class DaoFactory {

public static DaoFactory getInstance(String classname) {

DaoFactory dao = null;

try {

dao = (DaoFactory) Class.forName(classname).newInstance();

} catch (Exception e) {

e.printStackTrace();

}

return dao;

}

abstract IuserDao getuserdao();

abstract IroleDao getroledao();

}

// Oralce工厂

class OracleFactory extends DaoFactory {

public IroleDao getroledao() {

return new OracleroleDao();

}

public IuserDao getuserdao() {

return new OracleuserDao();

}

}

// MySql工厂

class MysqlFactory extends DaoFactory {

public IroleDao getroledao() {

return new MySqlroleDAO();

}

public IuserDao getuserdao() {

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).getroledao().insert();

DaoFactory.getInstance(Config.MYSQL).getroledao().insert();

}

}

public class Dao {

public static void main(String[] args) {

DaoFactory.getInstance(Config.ORALCE).getroledao().insert();

DaoFactory.getInstance(Config.MYSQL).getroledao().insert();

}

}

总结

使用条件：一系列接口有一系列的实现

如上IuserDao、IroleDao等一系列的接口，他们可以有一系列的实现(Oracle方式、MySql方式)

OracleuserDao、OracleroleDao、MySqluserDao、MySqlroleDAO

组成元素(以上面例子)

一系列接口：IuserDao、IroleDao

一系列实现：Oracle系列、MySql系列

系列工厂类：Oracle系列工厂类、MySql系列工厂类(必须继承抽象工厂类)

抽象工厂类：DaoFactory

java 抽象工厂和工厂方法模式的区别

工厂方法模式：一个抽象产品类，可以派生出多个具体产品类。

一个抽象工厂类，可以派生出多个具体工厂类。

每个具体工厂类只能创建一个具体产品类的实例。

抽象工厂模式：多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。

一个抽象工厂类，可以派生出多个具体工厂类。

每个具体工厂类可以创建多个具体产品类的实例。

JAVA设计模式中，抽象工厂与工厂方法的区别是什么，两者有什么不同吗？

抽象工厂的方法经常以工厂方法的方式实现，两者很容易混淆。他们的工作都是负责创建对象。不同的是工厂方法用的方法是继承过来的，而抽象工厂是通过对象组合。其实整个工厂方法模式，只不过就是通过子类来创建对象。只需知道超类型就可以了，具体的类型由子类负责。在这一点上，抽象工厂表示毫无压力，但是做法不同。抽象工厂提供一个用来创建一个产品家族的抽象类型，这个类型的子类定义了产品被产生的方法。要想使用这个工厂，必须先实例化它（产品家族的抽象类型，通过组合而来）。它的优点是可以把一群相关的产品集合起来，缺点是如果有新产品加入需要修改接口代码，这会涉及到所有子类接口的更改，是一个很繁琐的工作。而工厂方法有点相反，它只是创建一个产品，不需要很大的接口，一个方法就可以了。如果你目前还不知道将来需要实例化哪些类时，也可以使用工厂方法，只要继承它，实现工厂方法就可以了。

举一个例子：如果你有一个超市，只买一种物品，建议用工厂方法。如果有很多物品，就使用抽象工厂。当然，各有各的特点，最终都是学以致用，解决实际问题。很多问题都是结合各种办法解决的。

java抽象工厂的使用意图是什么?

工厂模式按照《Java与模式》中的提法分为三类： 1. 简单工厂模式(Simple Factory) 2. 工厂方法模式(Factory Method) 3. 抽象工厂模式(Abstract Factory) 这三种模式从上到下逐步抽象，并且更具一般性。所以我建议在这种情况下使用简单工厂模式与工厂方法模式相结合的方式来减少工厂类：即对于产品树上类似的种类（一般是树的叶子中互为兄弟的）使用简单工厂模式来实现。来看看抽象工厂模式的各个角色（和工厂方法的如出一辙）： 抽象工厂角色：这是工厂方法模式的核心，它与应用程序无关。

工厂模式有三个参与者，抽象产品(Product)、工厂(Creator)和具体产品(ConcreteProduct)。客户只会看到工厂和抽象产品。

public interface Product{

public String getName();

}

public class ConcreteProduct implements Product{

public String getName(){

return "产品1";

}

}

public class Creator{

public static Product create1(){

return new ConcreteProduct();

}

}

工厂模式的作用在于将创建具体产品的方法由工厂类控制，客户只需要知道产品的抽象类型

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中抽象工厂模式和原型模式之间的区别

工厂模式的好处就在于将工厂和产品之间的耦合降低，将具体产品的构造过程放在了具体工厂类里面。在以后扩展产品的时候方便很多，只需要添加一个工厂类，一个产品类，就能方便的添加产品，而不需要修改原有的代码。而在简单工厂中，如果要增加一个产品，则需要修改工厂类，增加if/else分支，或者增加一个case分支，工厂模式符合软件开发中的OCP原则（open close principle），对扩展开放，对修改关闭。

抽象工厂模式：这个模式我总是感觉和builder模式非常相似。

工厂方法模式提供的是对一个产品的等级模式，，而抽象工厂方法提供的是对多个产品的等级模式，注意，这里的多个具体产品之间是相互耦合的，也就是说这里的抽象工厂提供的产品之间是存在某种联系的。

有人做如下的比较：

工厂方法模式：一个抽象产品类，可以派生出多个具体产品类。

一个抽象工厂类，可以派生出多个具体工厂类。

每个具体工厂类只能创建一个具体产品类的实例。

抽象工厂模式：多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。

一个抽象工厂类，可以派生出多个具体工厂类。

每个具体工厂类可以创建多个具体产品类的实例。

区别：工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。

工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。

关于抽象工厂方法java和抽象工厂方法模式符合开闭原则吗?的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。