工厂模式

1，简单工厂模式

核心：将产品抽象出来，使用工厂创建产品 （创建型模式，依赖倒置，开闭原则）

 

public class Test {
        public static void main(String[] args) throws IOException {
            Factory factory = new Factory();
            Clothes cls = factory.create("pants");
            cls.show();

        }
}
//创建一个工厂类负责创建实体对象
class Factory{

    public Clothes create(String name){

        switch(name){

            case "shirt":
                return new Shirt();
            case "Sweater":
                return new Sweater();
            case "pants":
                return new Pants();
            default:
                return null;

        }


    }
}
//定义抽象接口
interface Clothes{
    void show();
}
class Shirt implements Clothes{
    @Override
    public void show(){
        System.out.println("this is a shirt");
    }
}
class Sweater implements Clothes{
    @Override
    public void show(){
        System.out.println("this is a sweater");
    }
}
class Pants implements Clothes{
    @Override
    public void show(){
        System.out.println("this is a pants");
    }
}

2，抽象工厂模式

核心：简单工厂模式的工厂是具体的，就意味着你这个工厂只能生产特定类型的产品，而我现在需要不同类型的产品就需要不同类型的工厂，抽象工厂便横空出世--（依赖倒置，开闭原则）

public class Test {
        public static void main(String[] args) throws IOException {
            Factory fc = new ColorFactory();
            Color color = fc.getColor("red");
            Factory fs = new ClothersFactory();
            Clothes clothes = fs.getClothes("shirt");

            color.show();
            clothes.show();

        }
}

//定义抽象工厂
abstract class Factory{
    public abstract Clothes getClothes(String clothes);
    public abstract Color getColor(String color);
}

class ClothersFactory extends Factory{
    @Override
    public Clothes getClothes(String clothes){

        switch(clothes){

            case "shirt":
                return new Shirt();
            case "Sweater":
                return new Sweater();
            case "pants":
                return new Pants();
            default:
                return null;

        }

    }

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


}
class ColorFactory extends Factory{

    @Override
    public Clothes getClothes(String clothes) {
        return null;
    }

    @Override
    public Color getColor(String color) {
        switch(color){

            case "red":
                return new Red();
            case "Blue":
                return new Blue();
            case "Green":
                return new Green();
            default:
                return null;

        }
    }
}
//定义衣服接口
interface Clothes{
    void show();
}
class Shirt implements Clothes{
    @Override
    public void show(){
        System.out.println("this is a shirt");
    }
}
class Sweater implements Clothes{
    @Override
    public void show(){
        System.out.println("this is a sweater");
    }
}
class Pants implements Clothes{
    @Override
    public void show(){
        System.out.println("this is a pants");
    }
}
//定义颜色接口
interface Color{
    void show();
}
class Red implements Color{
    public void show(){
        System.out.println("red");
    }
}
class Blue implements Color{
    public void show(){
        System.out.println("Blue");
    }
}
class Green implements Color{
    public void show(){
        System.out.println("Green");
    }
}