一,抽象工厂
抽象工厂进一步对工厂进行了抽象,是围绕一个超级工厂创建其他工厂,创建出来的工厂再创建具体的产品。该超级工厂又称为其他工厂的工厂。
抽象工厂模式的组成:
- 抽象工厂:抽象工厂模式的核心,是对简单工厂的进一步升级和抽象,抽象工厂创建具体工厂。
- 具体工厂:每个具体工厂可以直接提供对应的具体产品类的实例对象
- 抽象产品:这是对一系列产品的抽象,不提供具体的业务逻辑
- 具体产品:是抽象产品的具体化,负责具体业务逻辑的实现
下面以电脑和手机为例子进行说明:
二,抽象工厂的实现
1,编写抽象产品接口
//抽象产品类
interface Computer
{
void work();
}
//抽象产品类CellPhone
interface CellPhone
{
void call();
}
2,编写具体产品类
//实现类Asus
class Asus implements Computer
{
@Override
public void work()
{
System.out.println("this is a computer of "+this.getClass().getName()+" which is running!");
}
}
//实现类Lenovo
class Lenovo implements Computer
{
@Override
public void work()
{
System.out.println("this is a computer of "+this.getClass().getName()+" which is running!");
}
}
//实现类Acer
class Acer implements Computer
{
@Override
public void work()
{
System.out.println("this is a computer of "+this.getClass().getName()+" which is running!");
}
}
//实现类Iphone
class Iphone implements CellPhone
{
@Override
public void call()
{
System.out.println("i am using this phone "+this.getClass().getName()+" for calling!");
}
}
//实现类Nokia
class Nokia implements CellPhone
{
@Override
public void call()
{
System.out.println("i am using this phone "+this.getClass().getName()+" for calling!");
}
}
//实现类Vivo
class Vivo implements CellPhone
{
@Override
public void call()
{
System.out.println("i am using this phone "+this.getClass().getName()+" for calling!");
}
}
3,实现抽象工厂类
//创建抽象工厂
abstract class AbstractFactory
{
//生产电脑的方法,具体实现由具体的电脑工厂完成
public abstract <T extends Computer> T createComputer(Class<T> computerName);
//生产手机的方法,具体实现由具体的手机工厂完成
public abstract <T extends CellPhone> T createCellPhone(Class<T> phoneName);
}
4,创建具体工厂,并实现抽象工厂中的抽象方法
//编写具体工厂类
class ComputerFactory extends AbstractFactory
{
@SuppressWarnings("unchecked")
public <T extends Computer> T createComputer(Class<T> computerName)
{
T computer = null;
try {
computer = (T)Class.forName(computerName.getName()).newInstance();
} catch (Exception e) {
System.out.println("你要创建的实例:"+computerName+"不存在");
throw new RuntimeException(e);
}
return computer;
}
@Override
public <T extends CellPhone> T createCellPhone(Class<T> phoneName) {
// TODO Auto-generated method stub
return null;
}
}
//编写具体工厂类
class CellPhoneFactory extends AbstractFactory
{
@SuppressWarnings("unchecked")
public <T extends CellPhone> T createCellPhone(Class<T> phoneName)
{
T phone = null;
try {
phone = (T)Class.forName(phoneName.getName()).newInstance();
} catch (Exception e) {
System.out.println("你要创建的实例:"+phoneName+"不存在");
throw new RuntimeException(e);
}
return phone;
}
@Override
public <T extends Computer> T createComputer(Class<T> computerName) {
// TODO Auto-generated method stub
return null;
}
}
5,编写测试方法
public static void testAbstractFactory()
{
//创建两个具体工厂对象
AbstractFactory factory1 = new ComputerFactory();
AbstractFactory factory2 = new CellPhoneFactory();
//由具体工厂对象创建具体产品实例
Asus asus = factory1.createComputer(Asus.class);
Acer acer = factory1.createComputer(Acer.class);
//调用产品方法
asus.work();
acer.work();
//由具体工厂对象创建具体产品实例
Iphone iphone = factory2.createCellPhone(Iphone.class);
Nokia nokia = factory2.createCellPhone(Nokia.class);
//调用产品方法
iphone.call();
nokia.call();
}
6,方法调用
public static void main(String[] args)
{
testAbstractFactory();
}
7,运行结果
this is a computer of designpattern.Asus which is running!
this is a computer of designpattern.Acer which is running!
i am using this phone designpattern.Iphone for calling!
i am using this phone designpattern.Nokia for calling!
8,抽象工厂的优缺点
优点:还是提供了扩展性,降低了程序间的耦合性
缺点:如果日后要增加其他产品的话,我们需要在抽象工厂中增加一个生产该产品的方法,并且要提供一个该产品的具体工厂继承抽象工厂,再在该工厂中提供生产该产品的方法。另外不知道有没有人注意到,在抽象工厂中,针对每种产品都提供了一个生产该产品的抽象方法,由其子类实现,但是如果每个具体工厂只负责生产对应的单一产品的话,它不仅需要实现生产自己产品的方法,还要实现生产其他产品的方法,尽管那些方法可以只提供空实现,即方法体为空。但是在具体工厂的类体中无疑增添了许多冗余无用的代码。
//创建抽象工厂
abstract class AbstractFactory
{
//生产电脑的方法,具体实现由具体的电脑工厂完成
public abstract <T extends Computer> T createComputer(Class<T> computerName);
//生产手机的方法,具体实现由具体的手机工厂完成
public abstract <T extends CellPhone> T createCellPhone(Class<T> phoneName);
}
//编写具体工厂类
class CellPhoneFactory extends AbstractFactory
{
@SuppressWarnings("unchecked")
public <T extends CellPhone> T createCellPhone(Class<T> phoneName)
{
T phone = null;
try {
phone = (T)Class.forName(phoneName.getName()).newInstance();
} catch (Exception e) {
System.out.println("你要创建的实例:"+phoneName+"不存在");
throw new RuntimeException(e);
}
return phone;
}
@Override
public <T extends Computer> T createComputer(Class<T> computerName) {
//尽管我不生产电脑,可以我也要实现这个方法,因为这个方法在父类中是抽象方法
//设想要是有成千上万个产品,父类提供那么多对应的方法,即使我只生产一种产品,
//却要实现所有抽象方法,实在是太痛苦,代码也不优雅
return null;
}
}
三,抽象工厂模式和工厂模式的区别
抽象工厂模式与工厂模式的区别:
工厂模式:定义一个用于创建对象的借口,让子类决定实例化哪一个类
抽象工厂模式:为创建一组相关或相互依赖的对象提供一个接口,而且无需指定他们的具体类
我自己的理解是工厂模式一般针对单一的产品,如果产品不多用工厂模式即可,如果产品很多,那么我们需要对每种产品建立生产对应产品的工厂,这样我们就需要向上抽象一个工厂来对这些工厂进行管理,这样就形成了抽象工厂模式。
注:抽象工厂还是比较难理解的,自己感觉理解得也不是很到位,如果有错的地方望提醒包涵,欢迎打扰讨论。
参考链接:
http://www.runoob.com/design-pattern/abstract-factory-pattern.html
https://blog.csdn.net/seu_calvin/article/details/52268027
http://blog.csdn.net/ipqxiang/article/details/1955677