Java中的三种工厂模式

/**
 * 设计模式之工厂模式，用户创建对象的，通过工厂模式来降低代码的耦合度
 * @author
 */

//简单工厂模式

public class SimpleFactory{
    
    /**
     * 根据不过的String参数 name返回不同的汽车对象name
     * @param name
     * @return
     */
    public Car getCar(String name){
        
        /*
         * 利用equals()方法的特性：对于任何非空引用值x，x.equals(null)
         * 都应返回false
         * "name"是一个非空的String对象，也就是任何一个非空引用值x
         */
        if(name.equals("BenZ")){
            return new BenZ();
        }else if(name.equals("QQ")){
            return new QQ();
        }else{
            System.out.println("工厂没有这种车型");
            return null;
        }
        
    }
}

public interface Car {
    //汽车接口   用来实现
    String getName();
}

public class BenZ implements Car {
    //实现汽车接口
    @Override
    public String getName(){
        return "BenZ";
    }
}

public class BWM implements Car{    
    //实现汽车接口
    @Override
    public String getName(){
        return "BWM";
    }
}

public class SimpleFactoryTest {
    public static void main(String[] args){
        //简单工厂的测试类
        SimpleFactory simpleFactory = new SimpleFactory();
        Car car = simpleFactory.getCar("BenZ");
        System.out.println(car.getName());    //BenZ
                
    }
}

//工厂方法

工厂方法使用一个抽象工厂角色作为核心来代替在简单工厂模式中使用具体类作为核心。虽然使用工厂方法模式足以应付我们可能遇到的大部分业务需求。但是当产品种类非常多时，就会出现大量的与之对应的工厂类，这不应该是我们所希望的。

最好就是使用简单工厂模式与工厂方法模式相结合的方式来减少工厂类：即对于产品树上类似的种类（一般是树的叶子中互为兄弟的）使用简单工厂模式来实现。

在某些时候对于系统中存在不同的产品树，而且产品树上存在产品族，那么这种情况下就可能可以使用抽象工厂模式了。

//定义一个工厂类的接口 接口就是生产汽车 其他负责调用
public interface Factory{
    Car getCar();
}

public interface Car {
    //汽车接口   用来实现
    String getName();
}

public class BWMFactory implements Factory{    
    //实现汽车接口
    @Override
    public Car getCar(){
        return new BWM();
    }
}

public  class BenZFactory implements Factory {
    //实现工厂接口
    @Override
    public Car getCar(){
        return new BenZ();
    }
}

public  class BenZ implements Car{
　　//实现汽车接口
    public String getName() {
        return "BenZ";
    }
}

public  class BWM implements Car{
    //实现汽车接口
    public String getName() {
        return "BWM";
    }
}

public class FactoryTest {
    public static void main(String[] args){
        //工厂的测试类
        Factory bwmFactory = new BWMFactory();
        System.out.println(bwmFactory.getCar().getName());   //BWM
        Factory benzFactory = new BenZFactory();
        System.out.println(benzFactory.getCar().getName());     //BenZ                
    }
}

//抽象工厂

//定义一个抽象工厂类的接口
public abstract class AbstractFactory{
    protected abstract Car getCar();    
    //动态配置
    public Car getCar(String name){
        if("BWM".equals(name)){
            return new BWMFactory().getCar();
        }else if("BenZ".equals(name)){
            return new BenZFactory().getCar();
        }else{
            System.out.println("工厂生产不了这种车型");
            return null;
        }
    }    
}

public interface Car {
    //汽车接口   用来实现
    String getName();
}

public  class BWM implements Car{
    //实现汽车接口
    public String getName() {
        return "BWM";
    }
}

public  class BenZ implements Car{

    public String getName() {
        return "BenZ";
    }
}

public class BWMFactory extends AbstractFactory{    
    //实现汽车接口
    @Override
    public Car getCar(){
        return new BWM();
    }
}

public  class BenZFactory extends AbstractFactory {
    //实现工厂接口
    @Override
    public Car getCar(){
        return new BenZ();
    }
}

public class DefaultFactory extends AbstractFactory {
    private AudiFactory defaultFactory = new AudiFactory();    
    public Car getCar(){
        return defaultFactory.getCar();
    }
}

public class AbstractFactoryTest {
    public static void main(String[] args){
        //工厂的测试类
        DefaultFactory factory = new DefaultFactory();
        System.out.println(factory.getCar("BWM").getName());   //BWM
    }
}