java设计模式:三个工厂模式对比
简单工厂模式
实现一个基础工厂类,根据这个工厂类的不同入参,匹配到不同的具体产品类。代码如下
public class AnimalFactory {
public Animal getAnimal(String name)
{
switch(name.toLowerCase())
{
case "cow":
return new Cow();
case "horse":
return new Horse();
case "dog":
return new Dog();
}
return null;
}
public static void main(String args[])
{
AnimalFactory f = new AnimalFactory();
Animal c = f.getAnimal("cow");
Animal h = f.getAnimal("horse");
Dog d = (Dog)f.getAnimal("dog");
c.eat();
h.eat();
d.eat();
#### 特点:
1. 新增一个产品需要的步骤
* 增加一个具体产品类继承抽象产品类
* 产品工厂类需要新增加一个case,来匹配新增的产品
好处:客户端在引用的时候,不需要改动,只需要知道新增产品的name就可以
- 具体产品新增一个业务的步骤(改动有点麻烦):
- 如果不改变抽象类或者接口的情况下:1.在具体实现类加上新方法,客户端实现需要把抽象对象强制转换为具体对象类
- 改动抽象类或接口:1.所有继承该类或接口的具体实现类都要加上这个方法,违背初衷
工厂方法模式
写一个工厂抽象类或接口,在由具体的业务工厂去继承,
业务变动直接在业务工厂里修改,分散了父类接口的压力。
代码如下:
public interface AnimalFactory1 {
public Animal getAnimal();
}
public class DogFactory implements AnimalFactory1{
@Override
public Dog getAnimal() {
return new Dog();
}
}
public static void main(String[] args) {
DogFactory dogFactory = new DogFactory();
Dog d = dogFactory.getAnimal();
d.eat();
}
#### 特点:
1. 新增一个产品需要的步骤
* 增加一个具体产品类继承抽象产品类
* 增加一个具体工厂类继承抽象工厂类
* 客户端引用:实例化新工厂类,然后调用对应的方法
具体产品新增一个业务的步骤(简单):
- 直接在对应产品实现类下 增加新业务方法即可
增加一个别的类型的工厂:比如Color
- 实现Color抽象类,以及下面具体的压颜色类
- 增加一个ColorFactory,然后在DogFactory里继承ColorFactory这个接口,
反正接口可以继承多个 - 然后在通过DogFactory去分别实现两个产品的get就可以了
如果是直接实例化业务工厂类的话,为什么不直接实例化产品类?
- 解耦,客户端只需要关注工厂的方法的结果,不用关心后面的业务实现,
可以保障在业务更新的时候,不影响适用方的改动
- 解耦,客户端只需要关注工厂的方法的结果,不用关心后面的业务实现,
抽象工厂模式
个人理解,抽象工厂和工厂方法模式差不多,这里就写一下两个模式的对比。
抽象工厂是为了解决一个对象存在多个属性工厂的情况。
下面我就以Pet为例子,Pet有不同的种类,包括dog,cat等,Pet还有不同的颜色,包括黑,白,灰。
- 工厂方法模式
public interface PetFactory {
public Pet getAnimal();
}
public interface ColorFactory {
public Color getColor();
}
public class DogFactory implements PetFactory,ColorFactory{
@Override
public Dog getAnimal() {
return new Dog();
}
@Override
public Color getColor() {
return new Red();
}
}
public class MainApp {
public static void main(String[] args) {
DogFactory dogFactory = new DogFactory();
Dog d = dogFactory.getAnimal();
d.eat();
Color color = dogFactory.getColor();
color.color();
}
}
- 抽象工厂模式
public interface AbstractFactory {
public Pet getPet();
public Color getColor();
}
public class DogFactory implements AbstractFactory {
@Override
public Pet getPet() {
return new Dog();
}
@Override
public Color getColor() {
return new Red();
}
}
public class MainApp {
public static void main(String[] args) {
DogFactory dogFactory = new DogFactory();
Dog d = dogFactory.getPet();
d.eat();
Color c = dogFactory.getColor();
c.color();
}
}
区别应该很明显,工厂方法是业务实现工厂继承多个抽象工厂,每个抽象工厂里生产一类对象。
而抽象工厂方法是一个总的抽象工厂,然后有多个抽象方法,一个方法对应一类对象,然后业务实现工厂去实现这些方法。
- 举的例子不知道对不对,是不是工厂方法模式继承两个抽象类就是抽象工厂模式了?感觉两个模式差不多~