工厂模式

作为常见的设计模式，工厂模式可以分为三类。简单工厂、工厂方法以及抽象工厂模式。下面我将以代码示例来解释。

简单工厂

最简单的一种工厂模式，概括起来就是有一个工厂类，客户端需要什么，此工厂就生产什么。

//商品接口


public interface Products {

}

//商品A
public class ProductsA implements Products {

    public ProductsA(){
        System.out.println("生产产品A");
    }
}

//商品B
public class ProductsB implements Products {

    public ProductsB(){
        System.out.println("生产产品B");
    }
}

//简单工厂类
public class Factory {

    public Products creProducts(String type){
        if(type.equalsIgnoreCase("ProductsA"))
            return new ProductsA();
        if (type.equalsIgnoreCase("ProductsB")) {
            return new ProductsB();
        }
        return null;
    }
}

//客户端
public class Client {
    public static void main(String[] args) {
        Factory factory = new Factory();
        //你需要什么，工厂就给你什么
        factory.creProducts("ProductsA");
        factory.creProducts("ProductsB");
    }
}

简单工厂其实就是简单的将创建实例的代码和客户端代码分开放置而已。

工厂方法

每一个工厂都只能生产一种类型的商品(这里并不是说一个)，你需要某个商品，就让对应的那个工厂来帮你生产。

//工厂接口
public interface Factory {

    public Products create();
}

//生产A的工厂
public class FactoryA implements Factory {

    @Override
    public Products create() {
        return new ProductsA();
    }
}

//生产B的工厂
public class FactoryB implements Factory {

    @Override
    public Products create() {
        return new ProductsB();
    }

}

//客户端代码
public class Client {

    public static void main(String[] args) {
        //需要哪种商品就让这种工厂来生产
        Factory factory = new FactoryA();
        factory.create();
        factory = new FactoryB();
        factory.create();
    }

}

抽象工厂

此时，工厂不仅仅生产一种产品了，而是生产一种系列的产品。就好像这个工厂可以生产不同牌子的PC以及对应适配的鼠标。

//定一个一个抽象的工厂
public interface AbstarctFacroty {

    //生产产品
    public Products create();
    //产生一个对应的质检员
    public Check check();
}

//工厂实现A
public class FactoryA implements AbstarctFacroty {

    @Override
    public Products create() {
        // TODO Auto-generated method stub
        return new ProductsA();
    }

    @Override
    public Check check() {
        return new CheckB() ;
    }

}

//工厂实现B
public class FactoryB implements AbstarctFacroty {

    @Override
    public Products create() {
        // TODO Auto-generated method stub
        return new ProductsB();
    }

    @Override
    public Check check() {
        return new CheckC() ;
    }

}

//C
public class FactoryC implements AbstarctFacroty {

    @Override
    public Products create() {
        // TODO Auto-generated method stub
        return new ProductsC();
    }

    @Override
    public Check check() {
        return new CheckA() ;
    }

}

//三位质检员
public interface Check {

    public void check();
}
public class CheckA implements Check {

    public CheckA() {
        System.out.println("张全蛋检查产品");

    }

    @Override
    public void check() {
    }
}
public class CheckB implements Check {

    public CheckB() {
        System.out.println("赵铁柱检查产品");
    }

    @Override
    public void check() {

    }
}
public class CheckC implements Check {

    public CheckC() {
        System.out.println("李翠花检查产品");
    }

    @Override
    public void check() {

    }
}

//客户端
public class Client {

    public static void main(String[] args) {
        AbstarctFacroty facroty = new FactoryA();
        facroty.create();
        facroty.check();
        facroty = new FactoryB();
        facroty.create();
        facroty.check();
        facroty = new FactoryC();
        facroty.create();
        facroty.check();
    }

}