Java设计模式(二)---工厂模式

/**
 * 抽象产品类 水果
 */
public interface Fruit {
    void show();
}

/**
 * 具体产品类
 * 苹果  实现了水果接口
 * @author illusoryCloud
 */
public class Apple implements Fruit {
    @Override
    public void show() {
        System.out.println("This is Apple");
    }
}
/**
 * 具体产品类
 * 橘子 实现了水果接口
 * @author illusoryCloud
 */
public class Orange implements Fruit {
    @Override
    public void show() {
        System.out.println("This is Orange");
    }
}
/**
 * 工厂类   水果工厂
 * 负责生产各种产品
 *
 * @author illusoryCloud
 */
public class FruitFactory {
    public static final String FRUIT_APPLE = "Apple";
    public static final String FRUIT_ORANGE = "Orange";

    public static Fruit creatFruit(String fruit) {
        if (FRUIT_APPLE.equals(fruit)) {
            return new Apple();
        } else if (FRUIT_ORANGE.equals(fruit)) {
            return new Orange();
        } else {
            System.out.println("error unknown fruit ~");
            return null;
        }
    }
}



/**
 * 简单工厂模式 测试
 *
 * @author illusoryCloud
 *
 */
public class EasyFactoryTest {
    @Test
    public void testEasyFactory() {
        Fruit apple = FruitFactory.creatFruit(FruitFactory.FRUIT_APPLE);
        if (apple != null) {
            apple.show();
        }
        Fruit orange = FruitFactory.creatFruit(FruitFactory.FRUIT_ORANGE);
        if (orange != null) {
            orange.show();
        }
    }
}

/**
 *  抽象产品工厂类
 * @author illusoryCloud
 */
public interface FruitFactory {
    Fruit create();
}
/**
 * 具体产品工厂 实现接口
 * 苹果工厂
 * @author illusoryCloud
 */
public class AppleFactory implements FruitFactory {
    @Override
    public Fruit create() {
        return new Apple();
    }
}
/**
 * 具体产品工厂 实现接口
 * 苹果工厂
 * @author illusoryCloud
 */
public class AppleFactory implements FruitFactory {
    @Override
    public Fruit create() {
        return new Apple();
    }
}
/**
 * 工厂方法模式 测试类
 *
 * @author illusoryCloud
 */
public class FactoryMethodTest {
    @Test
    public void factoryMethodTest() {
        Fruit apple = new AppleFactory().create();
        apple.show();
        Fruit orange = new OrangeFactory().create();
        orange.show();
    }
}

/**
 * 抽象产品类 果汁
 *
 * @author illusoryCloud
 */
public interface Juice {
    void show();
}
/**
 * 具体产品类
 * 苹果汁
 *
 * @author illusoryCloud
 */
public class AppleJuice implements Juice {
    @Override
    public void show() {
        System.out.println("AppleJuice");
    }
}

/**
 * 具体产品类
 * 橘子汁
 *
 * @author illusoryCloud
 */
public class OrangeJuice implements Juice {
    @Override
    public void show() {
        System.out.println("OrangeJuice");
    }
}

/**
 * 抽象工厂类
 *
 * @author illusoryCloud
 */
public interface AbstractFactory {
    /**
     * 创建水果
     *
     * @return 水果
     */
    Fruit createFruit();

    /**
     * 创建果汁
     *
     * @return 果汁
     */
    Juice createJuice();
}

/**
 * 具体工厂类
 * 苹果工厂 生产苹果和苹果汁
 *
 * @author illusoryCloud
 */
public class AppleFactory implements AbstractFactory {
    @Override
    public Fruit createFruit() {
        return new Apple();
    }

    @Override
    public Juice createJuice() {
        return new AppleJuice();
    }
}

/**
 * 具体工厂类
 * 橘子工厂 生产橘子和橘子汁
 *
 * @author illusoryCloud
 */
public class OrangeFactory implements AbstractFactory {
    @Override
    public Fruit createFruit() {
        return new Orange();
    }

    @Override
    public Juice createJuice() {
        return new OrangeJuice();
    }
}

/**
 * 抽象工厂模式 测试类
 *
 * @author illusoryCloud
 */
public class AbstractFactoryTest {
    @Test
    public void abstractFactoryTest() {
        //苹果产品簇
        AbstractFactory appleFactory = new AppleFactory();
        Fruit apple = appleFactory.createFruit();
        Juice appleJuice = appleFactory.createJuice();
        //橘子产品簇
        AbstractFactory orangeFactory = new OrangeFactory();
        Fruit orange = orangeFactory.createFruit();
        Juice orangeJuice = orangeFactory.createJuice();

        apple.show();
        appleJuice.show();
        orange.show();
        orangeJuice.show();
    }

}

public interface ThreadFactory {

    /**
     * Constructs a new {@code Thread}.  Implementations may also initialize
     * priority, name, daemon status, {@code ThreadGroup}, etc.
     *
     * @param r a runnable to be executed by new thread instance
     * @return constructed thread, or {@code null} if the request to
     *         create a thread is rejected
     */
    Thread newThread(Runnable r);
}