工厂模式

工厂模式：
多态：（1）继承或实现（2）覆盖夫类方法（3）父类接口指向子类引用
工厂模式实现类图：

class FruitFacotry {
    static Fruit  getFruit(String name){
        if ("apple".equals(name.toLowerCase())){
            return new Apple();
        } else if ("banana".equals(name.toLowerCase())){
            return new Banana();
        } else if ("orange".equals(name.toLowerCase())){
            return new Orange();
        }else{
            System.out.println("工厂不能打包此类产品");
            return null;
        }
    }
}
class TestDemo{
    public static void main(String[] args) {
        Fruit apple = FruitFacotry.getFruit("apple");
        Fruit banana = FruitFacotry.getFruit("banana");
        Fruit orange = FruitFacotry.getFruit("orange");
        apple.wapper();
        banana.wapper();
        orange.wapper();
    }
}


interface Fruit{
    void wapper();
}
class Apple implements Fruit{
    @Override
    public void wapper() {
        System.out.println("打包一个苹果并且卖出");
    }
}
class Banana implements Fruit{

    @Override
    public void wapper() {
        System.out.println("打包一个香蕉并且卖出");
    }
}
class Orange implements Fruit{

    @Override
    public void wapper() {
        System.out.println("打包一个橘子并且卖出");
    }
}

抽象工厂：创建工厂的工厂，类图如下所示：

public class AbstractFactoryBestPractice {
    public static void main(String[] args) {
        Color color = FactoryBuilder.getFactory("color").getColor("red");
        color.fill();
        Shape shape = FactoryBuilder.getFactory("shape").getShape("circle");
        shape.draw();


    }
}

class FactoryBuilder{
    public static AbstractFactory getFactory(String factory){
        if ("color".equalsIgnoreCase(factory)){
            return new ColorFactory();
        }else if ("shape".equalsIgnoreCase(factory)){
            return new ShapeFactory();
        }else
            return null;
    }
}


class ColorFactory extends AbstractFactory{

    @Override
    Color getColor(String color) {
        if ("red".equals(color)){
            return new Red();
        }else if ("green".equals(color)){
            return new Green();
        }else if ("yellow".equals(color)){
            return new Yellow();
        }else
            return null;
    }

    @Override
    Shape getShape(String shape) {
        return null;
    }
}


class ShapeFactory extends AbstractFactory{

    @Override
    Color getColor(String color) {
        return null;
    }

    @Override
    Shape getShape(String shape) {
        if ("circle".equals(shape)){
            return new Circle();
        }else if ("square".equals(shape)){
            return new Square();
        }else if ("rectangle".equals(shape)){
            return new Rectangle();
        }else
            return null;
    }
}


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

interface Color{
    void fill();
}
interface Shape{
    void draw();
}

class Circle implements Shape{

    @Override
    public void draw() {
        System.out.println("创建一个圆形");
    }
}
class Square implements  Shape{

    @Override
    public void draw() {
        System.out.println("创建一个正方形");
    }
}
class Rectangle implements Shape{

    @Override
    public void draw() {
        System.out.println("创建一个三角形");
    }
}

class Red implements Color{

    @Override
    public void fill() {
        System.out.println("填充红颜色");
    }
}
class Green implements Color{

    @Override
    public void fill() {
        System.out.println("填充绿颜色");
    }
}
class Yellow implements Color{

    @Override
    public void fill() {
        System.out.println("填充黄颜色");
    }
}