关闭

Java工厂模式浅谈

标签: 工厂模式实例对象java
164人阅读 评论(0) 收藏 举报
分类:

工厂模式的简介

工厂模式简单来说就是定义一个用于创建对象的接口,让子类决定实例化那个类。在生成复杂对象的地方,都可以使用。将大量有共同接口的类进行实例化。工厂模式突出了职责单一原则和开闭原则。一般分为三种:简单工厂,工厂方法和抽象工厂。

简单工厂示例:


/**
 * 产品的抽象类
 * 由具体的产品类实现
 */
public abstract class Fruits {
    public abstract  void  method();

}

/**
 * 具体的产品类
 */
public class Banana extends Fruits {
    @Override
    public void method() {
        System.out.println("我是香蕉");
    }
}
/**
 * 具体的产品类
 */
public class Apple extends Fruits {
    @Override
    public void method() {
        System.out.println("我是苹果");
    }
}

/**
 * 工厂类
 */
public class MyFactory {
    public static Fruits createFruit(String type) throws Exception {
        if ("A".equals(type)) {
            return new Banana();
        } else {
            return new Apple();

        }
    }}
/**
 * 测试
 */
public class MyClass {
    public static void main(String arg[]) {
        Fruits fruits = MyFactory.createFruit("B");
        fruits.method();
    }
}

简单工厂的角色:

1.抽象产品角色:对具体的产品类的抽象。是工厂模式创建角色的父类或者它们共同拥有同样的接口。
2.具体产品角色:对抽象产品的实现。
3.工厂角色:工厂模式的核心所在,用于创建产品对象。

总结

把对象的创建放到工厂类中,通过不同的参数选择不同的创建类。非常的方便,也是用到最多的方式。
缺点就是每添一个对象,就需要对工厂类进行修改。违反开闭原则。

工厂方法示例:


/**
 * 工厂的抽象类
 */
public abstract class Factory {
   public abstract  Fruits createFruit();

}
/**
 * 具体的工厂类
 */
public class BaFactory extends  Factory {
    @Override
    public Fruits createFruit() {
        return new Banana();
    }
}
public class ApFactory extends  Factory {
    @Override
    public Fruits createFruit() {
        return new Apple();
    }
}
/**
 * 测试
 */
public class MyClass {
    public static void main(String arg[]) throws Exception {
        Factory factory = new BaFactory();
        factory.createFruit().method();
        Factory afactory = new ApFactory();
        afactory.createFruit().method();


    }
}

工厂方法的角色:

1.抽象产品角色:对具体的产品类的抽象。是工厂模式创建角色的父类或者它们共同拥有同样的接口。
2.具体产品角色:对抽象产品的实现。
3.抽象工厂角色:工厂模式的核心所在,所有工厂的抽象。
4.具体工厂角色:具体工厂的创建对象,必须实现或者继承抽象工厂

总结

每种产品由一种工厂来创建,一个工厂保存一个产品的创建。符合开闭原则。

抽象工厂示例:


//抽象工厂类
public abstract class Factory {
    public abstract Vegetable createVegetable();
    public abstract Fruit createFruit();
    public abstract Noodles createNoodles();
}
//具体工厂类,其中Vegetable, Fruit,Noodles是抽象类,
public class DefaultFactory extends Factory{
    @Override
    public Fruit createFruit {
        return new Apple();
    }
    @Override
    public Vegetable createVegetable {
        return new Cabbage();
    }
    @Override
    public Noodles createNoodles() {
        return new Lamian();
    }
}
//测试类
public class Test {
    public static void main(String[] args) {
        Factory f = new DefaultFactory();
        Vegetable v = f.createVegetable();
        v.run();
        Fruit w = f.createFruit();
        w.shoot();
        Noodles a = f.createNoodles();
        a.printName();
    }
}

总结

其实就是工厂方法的复杂化,在一个工厂中同事创建多个类。
关于工厂方法其实还有更简单的方法,可以利用Java中的反射来完成示例如下:


/**
 * 工厂的抽象类
 */
public abstract class Factory {

   public abstract <T extends Fruits >T createFruit(Class<T> cls) throws ClassNotFoundException;

}

/**
 * 具体的工厂
 */
public class MyFactory extends  Factory{

    @Override
    public <T extends Fruits> T createFruit(Class<T> cls) {
        Fruits fruits = null;
        try {
            fruits = (Fruits) Class.forName(cls.getName()).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return (T) fruits;

    }

}
/**
 * 测试
 */
public class MyClass {
    public  static void main(String arg[]) throws ClassNotFoundException {
      Factory factory = new MyFactory();
       Fruits  fruits =  factory.createFruit(Banana.class);
        fruits.method();
    }
}

最后的总结

三种的无论那种都是工厂模式,其最终的目的就是为了解耦而存在。在开发过程中没有必要纠结过深。根据你的业务逻辑产品需求来灵活运用,切勿生搬硬套。最终达到降低耦合度的目的即可。

0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:376次
    • 积分:28
    • 等级:
    • 排名:千里之外
    • 原创:2篇
    • 转载:0篇
    • 译文:0篇
    • 评论:0条
    文章分类
    文章存档