本文目录
- 工厂模式,简单工厂模式,抽象工厂模式三者有什么区别
- 写一个抽象工厂模式 java实例 出来
- 抽象工厂模式的模式
- Python设计模式之抽象工厂模式
- 抽象工厂模式的简介
- Java 抽象工厂模式
- Java 什么是抽象工厂,请举个例子
- 请编写一个最简单的抽象工厂模式代码C#
- 什么是java抽象工厂模式
- 工厂方法模式与抽象工厂模式的区别
工厂模式,简单工厂模式,抽象工厂模式三者有什么区别
工厂模式，简单工厂模式，抽象工厂模式三者区别如下：
1、首先，三者的创建对象是不相同的。
进行创建对象时，“工厂模式”不使用new创建对象，而是使用Factory模式；“简单工厂模式”则是通过fw模式来建立对象；“抽象工厂模式”使用迭代模式来创建对象。
2、其次，三者的定义变量不同。
“工厂模式”在使用时可以随时设置变量，不用提前进行设置。“简单工厂模式”中需要使用参数或者配置文件等已经定义好的变量，然后才能进行下一步的操作。“抽象工厂模式则”则需要每次增加产品时，进行修改类方法。
3、最后，三者的接口数量不同。“工厂模式”可以使用两个接口以及三个接口，“简单工厂模式”只可以使用一个接口。“抽象工厂模式”则可以使用无限个接口。
扩展资料：
简单工厂模式优缺点
1、优点：工厂类含有必要的判断逻辑，可以决定在什么时候创建哪一个产品类的实例，客户端可以免除直接创建产品对象的责任，而仅仅“消费“产品。简单工厂模式通过这种做法实现了对责任的分割。
当产品有复杂的多层等级结构时，工厂类只有自己，以不变应万变，就是模式的缺点。因为工厂类集中了所有产品创建逻辑，一旦不能正常工作，整个系统都要受到影响。
2、缺点：系统扩展困难，一旦添加新产品就不得不修改工厂逻辑，有可能造成工厂逻辑过于复杂，违背了“开放--封闭“原则(OCP)。另外，简单工厂模式通常使用静态工厂方法，这使得无法由子类继承，造成工厂角色无法形成基于继承的等级结构。
参考资料来源：百度百科-工厂模式
参考资料来源：百度百科-简单工厂模式
参考资料来源：百度百科-抽象工厂模式
写一个抽象工厂模式 java实例 出来
工厂模式java实例如下：
public interface Work { void doWork();}ConcreteProduct 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; } } }
return targetArr;
}
抽象工厂模式的模式
优点：1.它分离了具体的类2.它使得易于交换产品系列3.它有利于产品的一致性缺点：难以支持新种类的产品微型计算机配件，这个系统所需要的产品族有两个，一个系列是PC系列，另一个系列是MAC系列。产品等级结构也有两个，一个是RAM，一个是CPU。//两个抽象产品public interface Cpu{}public interface Ram{}//四个具体产品public class PcCpu implements Cpu{}public class MacCpu implements Cpu{}public class PcRam implements Ram{}public class MacRam implements Ram{}//抽象工厂角色public interface ComputerProducer{Cpu createCpu();Ram createRam();}//两个具体工厂角色public class PcProducer implements ComputerProducer{public Cpu createCpu(){return new PcCpu();}public Ram createRam(){return new PcRam();}}public class MacProducer implements ComputerProducer{public Cpu createCpu(){return new MacCpu();}public Ram createRam(){return new MacRam();}}一般情况下，有多少个抽象产品，就有多少个工厂方法。（比如再增加一个PC与MAC不同的其他计算机配件，例如显卡）。OCP(开放-封闭原则（The Open-Close Principle，简称OCP）)增加产品族。增加产品等级结构。在不改变产品等级结构的情况下，增加产品族就是意味着向每一个产品等级结构中增加一个或者多个新的具体产品角色，这时只需要向工厂等级结构中增加新的元素就可以了，具体的说，只需要增加新的具体工厂类就可以了。在产品族数目不变的情况下，增加产品等级结构，相当于增加一个与现有产品等级结构平行的一个新的产品等级结构，这时需要向修改所有的工厂角色，增加一个新的工厂方法,这是不支持OCP的。ProducerPcProducer MacProducerCPUPcCPU MacCPURAMPcRAM MacCPU在上面的结构中，增加产品族相当于增加一个新的厂商，比如Sun的CPU和RAM,这时，只需要增加一个SunProducer即可。而增加一个新的产品等级结构相当于增加一个显卡，而显卡也有Pc和Mac之分，那么对于所有的Producer，都需要增加一个方法：createCard()
Python设计模式之抽象工厂模式
Python设计模式之抽象工厂模式这篇文章主要为大家详细介绍了Python设计模式之抽象工厂模式，感兴趣的小伙伴们可以参考一下python面向对象编程入门，我们需要不断学习进步“““抽象工厂模式的实现“““ import randomclass PetShop: “““宠物商店“““ def __init__(self, animal_factory=None): “““宠物工厂是我们的抽象工厂。我们可以随意设置。“““ self.pet_factory = animal_factory def show_pet(self): “““使用抽象工厂创建并显示一个宠物“““ pet = self.pet_factory.get_pet() print(“我们有一个可爱的 {}“.format(pet)) print(“它说 {}“.format(pet.speak())) print(“我们还有 {}“.format(self.pet_factory.get_food()))# 工厂生产的事物 class Dog: def speak(self): return “汪“ def __str__(self): return “Dog“class Cat: def speak(self): return “喵“ def __str__(self): return “Cat“# Factory classes class DogFactory: def get_pet(self): return Dog() def get_food(self): return “狗食“class CatFactory: def get_pet(self): return Cat() def get_food(self): return “猫粮“# 随机创建合适的工厂def get_factory(): “““让我们动起来！“““ return random.choice([DogFactory, CatFactory])()# 多个工厂显示宠物if __name__ == “__main__“: for i in range(4): shop = PetShop(get_factory()) shop.show_pet() print(“=“ * 20)以上就是本文的全部内容，希望对大家的学习有所帮助
抽象工厂模式的简介
当每个抽象产品都有多于一个的具体子类的时候，工厂角色怎么知道实例化哪一个子类呢？比如每个抽象产品 角色都有两个具体产品。抽象工厂模式提供两个具体工厂角色，分别对应于这两个具体产品角色，每一个具体工厂角色只负责某一个产品角色的实例化。每一个具体工厂类只负责创建抽象产品的某一个具体子类的实例。每一个模式都是针对一定问题的解决方案，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式针对的是多个产品等级结构。
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
请编写一个最简单的抽象工厂模式代码C#
举个动物的例子，动物可以分为食草动物和食肉动物。每个大陆都有食草动物和食肉动物。如非洲大陆，美洲大陆。假设大陆为抽象工厂：ContinentFacotry，那么派生工厂就是AfricaFactory和AmeriacFactory。动物分为食草动物Herbivore和食肉动物Carnivore。代码如下：//抽象大陆工厂abstract class ContinentFactory{ abstract public Herbivore CreateHerbivore(); abstract public Carnivore CreateCarnivore();}//食草动物abstract class Herbivore{}abstract class Carnivoe{ abstract pubic void Eat(Herbivore h);}然后具体动物代码我不写了，非洲的可以有狮子和羚羊，美洲的可以有美洲虎和牛。那么具体的大陆工厂代码如下:class AfricalFactory:ContinentFactory{ override public Herbivore CreateHerbivore() { return new 羚羊 } override public Carnivoe CreateCarnivoe() { return new 狮子 }}美洲工厂同理，不写了。每个具体动物继承下动物抽象类，如狮子继承食肉动物类，具有Eat的函数，羚羊继承食草动物类。 现在来完成核心的动物食物链代码：class AnimalWorld{ private Herbivore herbivore; private Carnivore carnivore; public AnimalWorld(ContinentFactory factory) { herbivore = factory.CreateHerbivore (); carnivore= factory.CreateCarnivore (); } //运行食物链 public void RunFoodChain() { carnivore.Eat(herbivore ); }}那么具体使用抽象工厂时，可以这样用：ContinentFacotry africa = new AfricaFactory();AnimalWorld world = new AnimalWorld(africa);world.RunFoodChain();//这样抽象工厂很好的封装了具体实现过程，并且具有方法通用性，在这个例子中，适合各个大陆的动物，另外很好的隔离了具体对象，可以看到用户并不知道具体什么动物被创建了，最后只是运行了食物链才能看到谁吃了谁。
什么是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
工厂方法模式与抽象工厂模式的区别
工厂方法模式：一个抽象产品类，可以派生出多个具体产品类。 一个抽象工厂类，可以派生出多个具体工厂类。 每个具体工厂类只能创建一个具体产品类的实例。抽象工厂模式：多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。 一个抽象工厂类，可以派生出多个具体工厂类。 每个具体工厂类可以创建多个具体产品类的实例。 区别：工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。 工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。