java设计模式----factory

最新推荐文章于 2024-09-26 16:41:53 发布

huwei1991

最新推荐文章于 2024-09-26 16:41:53 发布

阅读量505

点赞数

分类专栏：设计模式文章标签：设计模式 factory 工厂模式

设计模式专栏收录该内容

22 篇文章 0 订阅

订阅专栏

工厂模式一共分为三种，分别是：简单工厂模式，工厂方法模式和抽象工厂模式。

先来说说简单工厂模式，简单工厂模式一般不在实际中是用，因为它的扩展性不好，这里的扩展性，是指我们可以添加新的类，而不是去更改现有的类，这样做的好处显而易见，如果为了一个新需求去更改原有类的代码，那么就有可能引入新的bug，如果是新加一个类，这就可以非常有效地降低引入新bug的风险，因此，扩展性是非常重要的。下面是一个简单工厂模式的例子：

[java] view plain copy print ?

public interface Fruit{
}
public class Apple implements Fruit{
}
public class Grape implements Fruit{
}
public class Strawberry implements Fruit{
}
public class FruitGardener
{
public static Fruit factory(String whichFruit)
{
if (which.equalsIgnoreCase("apple"))
{
return new Apple();
}
else if (which.equalsIgnoreCase("strawberry"))
{
return new Strawberry();
}
else if (which.equalsIgnoreCase("grape"))
{
return new Grape();
}
else
{
return new null;
}
}
}

上面的代码很容易看懂，想要得到一个Apple，用Apple apple = FruitGardener.factory("apple");这句话就行了。这样看来，上面的代码已经实现了工厂模式，事实也的确如此，但是问题就在于先前所提到的扩展性，当我们想要这个果园能生产香蕉的时候，必须做下面两件事情，第一，写一个Banana类，它实现了接口Fruit，然后再更改FruitGardener，让其能够生产Banana，如下：

[java] view plain copy print ?

public class Banana implements Fruit{
}
public class FruitGardener
{
public static Fruit factory(String whichFruit)
{
if (which.equalsIgnoreCase("apple"))
{
return new Apple();
}
else if (which.equalsIgnoreCase("strawberry"))
{
return new Strawberry();
}
else if (which.equalsIgnoreCase("grape"))
{
return new Grape();
}
else if (which.equalsIgnoreCase("banana"))
{
return new Banana();
}
else
{
return new null;
}
}
}

这样就违背了我们先前说的只能新加类，不能修改现有类的原则，因此，简单工厂模式只能做一个教学演示而已。

下面是第二个，叫工厂方法模式，这个方法有效地解决了简单工厂模式扩展性差的问题，想要进行扩展，只需要新加类就行，不需要更改原油类，下面是一个例子：

[java] view plain copy print ?

public interface Mobile {
}
public class Motorola implements Mobile {
}
public class Nokia implements Mobile {
}
public interface MobileFactory {
public Mobile produceMobile();
}
public class NokiaFactory implements MobileFactory {
@Override
public Mobile produceMobile() {
return new Nokia();
}
}
public class MotorolaFactory implements MobileFactory {
@Override
public Mobile produceMobile() {
return new Motorola();
}
}
public class Client {
public static void main(String[] args){
MobileFactory mf;
Mobile m;
mf = new MotorolaFactory();
m = mf.produceMobile();
//这时，m是Motorola的手机
mf = new NokiaFactory();
m = mf.produceMobile();
//这时，m是Nokia的手机
}
}

如果想要生产HTC的手机，只需要新加一个HTC类，实现Mobile接口，再新加一个HTCFactory，实现MobileFactory接口就行了，新加的代码如下：

[java] view plain copy print ?

public class HTC implements Mobile {
}
public class HTCFactory implements MobileFactory {
@Override
public Mobile produceMobile() {
return new HTC();
}
}

这样就实现了新加一个这个工厂产的产品，但是不会更改原有类的要求，但是，这还会有问题。在工厂方法模式中，到底生产什么，是写进了代码里（我们俗称硬代码），假如客户这次想要Nokia，下次又想要Motorola了怎么办，总不可能他提一次需求我们就改一次代码吧，这样显然是不行的，因此，下面又有了抽象工厂模式。先是一个例子：

[java] view plain copy print ?

interface Dao {
}
class OracleDao implements Dao {
}
class MySqlDao implements Dao {
}
abstract class DaoFactory {
abstract Dao getDao();
public static DaoFactory getInstance(String classname) {
DaoFactory dao = null;
try {
dao = (DaoFactory) Class.forName(classname).newInstance();
} catch (Exception e) {
e.printStackTrace();
}
return dao;
}
}
class OracleFactory extends DaoFactory {
@Override
Dao getDao() {
// TODO Auto-generated method stub
return new OracleDao();
}
}
class MysqlFactory extends DaoFactory {
@Override
public Dao getDao() {
// TODO Auto-generated method stub
return new MySqlDao();
}
}
class Config {
static final String FACTORYNAME = "OracleFactory";
}
public class Test {
public static void main(String[] args) {
Dao dao = null;
dao = DaoFactory.getInstance(Config.FACTORYNAME).getDao();
System.out.println(dao.getClass().getName());
//打印的结果是OracleDao
}
}

上面的代码中，想要生产什么，是写在配置文件里的，Config这个类实际上可以写成一个properties文件，用户想要生产什么，按照要求改这个文件就可以了，不需要改代码。再回头看看这个抽象工厂模式满不满足可扩展性，如果想要生产SqlServer的数据库访问对象（DAO，Data Access Object），需要新加一个SqlServerDao类来实现DAO接口，再新增一个SqlServerFactory实现DaoFactory，另外，需要告诉客户现在的系统已经能够生产SqlServer数据访问对象了，你只需要在配置文件里加上类似static final String MYSQL = "org.abc.SqlServerFactory"; 的话（按照配置文件的格式来写）就行了。

上面就介绍完了工厂模式，下期预告，Builder模式。