设计模式 工厂模式/抽象工厂模式

工厂模式

创建对象时不会对客户暴露创建逻辑，并且通过使用一个共同的接口来指向创建的对象。

Sept1 创建一个公共接口，将要对外开放的方法在这里定义。

Sept2 创建实现接口的类，用即实现对外开放的类的方法

Sept3 创建工厂，提供一个get方法，这个方法提供返回实现类的对象（创建选择）

Sept4 使用，创建工厂对象，使用工厂中的对象，来获取对外开放的方法（使用选择）

 

 Sept1

/*
* @author: xuandc
* @Time : 2020-03-27
* @see: 工厂模式
* */
public interface Shape {
    void draw();
}

 

 Sept 2

       实现类1

/*
 * @author: xuandc
 * @Time : 2020-03-27
 * @see: 工厂模式
 * */
public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("工厂模式测试实现类，Circle");
    }
    public  void dd(){
        System.out.println("接口中没有的方法，即不能外开发");
    }
}

      实现类2

/*
* @author：xuandc
* @time :2020-03-27
* @see: 接口实现类 Square
* */
public class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("工厂模式测试实现类，Square");
    }
}

 

  实现类3

/*
* @author : xuandc
* @Time: 2020-03-27
* @see：工厂模式实现类
* */
public class Rectangie implements Shape {
    @Override
    public void draw() {
        System.out.println("工厂模式测试实现类，Rectangie");
    }
}

 

Sept 3  

   工厂类

/*
* @author :xuandc
* @time :2020-03-27
* @see: 创建一个shape工厂类
* */
public class ShapeFactory {
    //使用get方法获取接口实现类的对象
    public Shape getShape(String shapeType){
        if (shapeType ==null){
            return null;
        }
        if (shapeType.equalsIgnoreCase("Circle")){
            return (new Circle());
        }else if (shapeType.equalsIgnoreCase("Rectangie")){
            return (new Rectangie());
        }else if (shapeType.equalsIgnoreCase("Square")){
            return (new Square());
        }
        return null;
    }
}

 

Sept4

工厂使用

/*
* @author: xuandc
* @time : 2020-03-27
*/
public class FactoryPatternDemo {
    public static void main(String[] args) {
        ShapeFactory shapeFactory = new ShapeFactory();
        //获取circle的对象
        Shape shape1 = shapeFactory.getShape("Circle");
        shape1.draw();
        //
        Shape shape2 = shapeFactory.getShape("Rectangie");
        shape2.draw();
        //
        Shape shap3 = shapeFactory.getShape("Square");
        shap3.draw();
    }
}

 

 

 

抽象工厂模式（Abstract Factory Pattern）

      抽象工厂模式是围绕一个超级工厂创建其它工厂。是其它工厂的工厂；

       在抽象工厂模式中，接口负责创建相关对象的工厂，而不是明确指定它们的类。每个工厂可以按照工厂模式提供对象。

 

         即将每个工厂抽象到一个抽象类（相当于工厂中的接口）中

        然后在创建一个工厂创造，即返回实例化工厂类的（工厂模式中是实例化实现类）。

       调用，创建抽象工厂类型的生产工厂器对象，获取相应工厂对象（工厂对象选择）

 

 

Sept1 创建接口（2个接口）

public interface Shape { void draw();}  //形状接口

public interface Color {void fill();}         //颜色接口

 

Sept2 创建接口实现类（4个实现类）

public class Circle implements Shape {
    @Override
    public void draw() { System.out.println("工厂模式测试实现类，Circle"); }
    public  void dd(){System.out.println("接口中没有的方法，即不能外开发"); }
}

 

public class Square implements Shape {
    @Override
    public void draw() { System.out.println("工厂模式测试实现类，Square");}
}

 

 

public class Red implements Color {
    @Override
    public void fill() {System.out.println("工厂实现类：RED");}
}

 

public class Blue implements Color {
    @Override
    public void fill() {System.out.println("工厂实现类：Blue"); }
}

 

Sept 3   创建工厂（2个工厂）

 工厂1    颜色工厂

public class ColorFactory extends AbstractFactory {
    @Override
    public Color getColor(String color) {
        if (color == null){return null; }
        if (color.equalsIgnoreCase("RED")){return new Red();
        }else if (color.equalsIgnoreCase("GREEN")){return new Green();
        }else if (color.equalsIgnoreCase("BLUE")){return new Blue();
        }
        return null;}
    @Override
    public Shape getShape(String shape) {return null;}
}

 

工厂2   形状工厂

public class ShapeFactory extends AbstractFactory {
    @Override
    public Color getColor(String color) {return null;}
    @Override
    public Shape getShape(String shapeType) {
        if (shapeType ==null){return null; }
        if (shapeType.equalsIgnoreCase("Circle")){ return (new Circle());
        }else if (shapeType.equalsIgnoreCase("Rectangle")){

return (new Rectangle());

}else if (shapeType.equalsIgnoreCase("Square")){return new Square();
        }
        return null;
    }
}

 

Sept 4 将工厂抽象出来（工厂抽象类）

public abstract class AbstractFactory {
    public abstract Color getColor(String color);
    public abstract Shape getShape(String shape);
}

 

Sept 5 创建超级工厂生产器（即产生工厂对象的工厂）

public class FactoryProducer {
    public static AbstractFactory getFactory(String choice){
        if (choice.equalsIgnoreCase("SHAPE")){
            return new ShapeFactory();
        }else if (choice.equalsIgnoreCase("COLOR")){
            return new ColorFactory();
        }
        return null;
    }
}

 

Sept 6 使用超级工厂

public class AbstractFactoryDemo {
    public static void main(String[] args) {
        //获取形状工厂
        AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");
        Shape shape1 = shapeFactory.getShape("CIRCLE");
        shape1.draw();
        Shape shape2 = shapeFactory.getShape("RECTANGLE");
        shape2.draw();

        //获取颜色工厂
        AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");
        Color color1 = colorFactory.getColor("RED");
        color1.fill();
        Color color2 = colorFactory.getColor("GREEN");
        color2.fill();
    }
}