Java设计模式--工厂模式

1.简单工厂模式

实例化对象的时候不再使用 new Object()形式，可以根据用户的选择条件来实例化相关的类。

设计类图：

相关代码:

Shape.java

public interface Shape {

    void draw();
}  

Rectangle.java

public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Rectangle:: draw");
    }
}

Circle.java

public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Circle:: draw");
    }
}

ShapeFactory.java

public class ShapeFactory {
    public Shape getShape(String shape){
        switch (shape){
            case "Circle":
                return new Circle();

            case "Rectangle":
                return new Rectangle();

            default:
                return null;

        }
    }
}

Demo.java

public class Demo {
    public static void main(String[] args) {
        ShapeFactory shapeFactory = new ShapeFactory();
        Shape shape = shapeFactory.getShape("Circle");
        shape.draw();
        shape = shapeFactory.getShape("Rectangle");
        shape.draw();
    }
}

缺点:增加、删除某个子类对象的创建都需要打开简单工厂类来进行修改代码也违反了开-闭原则。

2.工厂模式

工厂方法模式中是一个子类对应一个工厂类，而这些工厂类都实现于一个抽象接口。这相当于是把原本会因为业务代码而庞大的简单工厂类，拆分成了一个个的工厂类，这样代码就不会都耦合在同一个类里了。

设计类图：

相关代码:

ShapeFactory.java

public interface ShapeFactory {

    public Shape getShape();
}

CircleFactory.java

public class CircleFactory implements ShapeFactory {
    @Override
    public Shape getShape() {
        System.out.println("getShape --> Circle");
        return new Circle();
    }
}

RectangleFactory.java

public class RectangleFactory implements ShapeFactory {
    @Override
    public Shape getShape() {
        System.out.println("getShape --> Rectangle");
        return new Circle();
    }
}

其他类和简单工厂一样

Demo.java

public class Demo {
    public static void main(String[] args) {
        ShapeFactory circleFactory = new CircleFactory();
        Shape cilcle = circleFactory.getShape();
        cilcle.draw();

        ShapeFactory rectangleFactory = new RectangleFactory();
        Shape rectangle = rectangleFactory.getShape();
        rectangle.draw();

    }
}

缺点:每增加一个产品类，就需要增加一个对应的工厂类，增加了额外的开发量。

3.抽象工厂模式

抽象工厂与工厂方法模式的区别在于：抽象工厂是可以生产多个产品的
###设计类图：

###相关代码:

Mouse.java

public interface Mouse {
    void sayHi();
}

HPMouse.java

public class HPMouse implements Mouse {
    @Override
    public void sayHi() {
        System.out.println("This is HPMouse! ");
    }
}

DellMouse.java

public class DellMouse implements Mouse {
    @Override
    public void sayHi() {
        System.out.println("This is DellMouse!");
    }
}

Keybord.java

public interface Keybord {
    void sayHi();
}

HPKeybord.java

public class HPKeybord implements Keybord {
    @Override
    public void sayHi() {
        System.out.println("This is HPKeybord!");
    }
}

DellKeybord.java

public class DellKeybord implements Keybord {
    @Override
    public void sayHi() {
        System.out.println("This is DellKeybord!");
    }
}

IFactory.java

public interface IFactory {
    Mouse createMouse();
    Keybord createKeybord();
}

DellFactory.java

public class DellFactory implements IFactory {
    @Override
    public Mouse createMouse() {
        System.out.println("createMouse :: Dell");
        return new DellMouse();
    }

    @Override
    public Keybord createKeybord() {
        System.out.println("createKeybord :: Dell");
        return new DellKeybord();
    }
}

HPFactory.java

public class HPFactory implements IFactory {
    @Override
    public Mouse createMouse() {
        System.out.println("createMouse :: HP");
        return new HPMouse();
    }

    @Override
    public Keybord createKeybord() {
        System.out.println("createKeybord :: HP");
        return new HPKeybord();
    }
}

Demo.java

public class Demo {
    public static void main(String[] args) {
        IFactory dellFactory = new DellFactory();
        dellFactory.createKeybord();
        dellFactory.createMouse();

        IFactory hpFactory = new HPFactory();
        hpFactory.createMouse();
        hpFactory.createKeybord();
    }
}