设计模式笔记-简单工厂模式，工厂方法模式，抽象工厂模式

设计模式笔记-简单工厂模式，工厂方法模式，抽象工厂模式

1.区别

简单工厂模式：根据接收的参数不同来确定返回对象实例，要增加一个新的类别必须要修改代码；简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类

工厂方法模式：是有一组实现了相同接口的工厂类（会增加新的类来扩展，看情况而定，实际上在项目开发中通常还是用简单工厂比较多），一个具体工厂只生产一类具体产品

抽象工厂模式：抽象工厂类；一个具体工厂类可以生产多种具体产品

2.常见写法

简单工厂模式：

public interface Shoe {
    public String getShoeName();
}

public class ManShoe implements Shoe {
    @Override
    public String getShoeName() {
        return "man shoe";
    }
}

public class WomanShoe implements Shoe {
    @Override
    public String getShoeName() {
        return "woman shoe";
    }
}

public class SimpleFactoty {
    public  Shoe getShoe(String type){
        if("man".equals(type)){
            return new ManShoe();
        }
       else if("woman".equals(type)){
            return new WomanShoe();
        }
        else{
            return null;
        }
    }
}

public class TestSimpleFactoty {
    public static void main(String[] args) {
        SimpleFactoty simpleFactoty=new SimpleFactoty();
        System.out.println(simpleFactoty.getShoe("man").getShoeName());
        System.out.println(simpleFactoty.getShoe("woman").getShoeName());
    }
}

工厂方法模式:

public interface Shoe {
    public String getShoeName();
}
public class ManShoe implements Shoe {
    @Override
    public String getShoeName() {
        return "man shoe";
    }
}
public class WomanShoe implements Shoe {
    @Override
    public String getShoeName() {
        return "woman shoe";
    }
}
public interface AbstractFactoty {
    public Shoe getShoe();
}
public class ManShoeFactory implements AbstractFactoty {

    @Override
    public Shoe getShoe() {
        return new ManShoe();
    }
}
public class WoManShoeFactory implements AbstractFactoty {
    @Override
    public Shoe getShoe() {
        return new WomanShoe();
    }
}

public class TestFactory {
    public static void main(String[] args) {
        AbstractFactoty manFactory=new ManShoeFactory();
        System.out.println(manFactory.getShoe().getShoeName());
        AbstractFactoty womanFactory=new WoManShoeFactory();
        System.out.println(womanFactory.getShoe().getShoeName());
    }
}

抽象工厂模式：

public interface Shoe {
    public String getShoeName();
}

public class ManWorkShoe implements Shoe {
    @Override
    public String getShoeName() {
        return "ManWorkShoe";
    }
}

public class ManRunShoe implements Shoe {
    @Override
    public String getShoeName() {
        return "ManRunShoe";
    }
}

public class WomanRunShoe implements Shoe {
    @Override
    public String getShoeName() {
        return "WomanRunShoe";
    }
}

public class WomanWorkShoe implements Shoe {
    @Override
    public String getShoeName() {
        return "WomanWorkShoe";
    }
}

public interface ShoeFactory {
    public Shoe getRunShoe();
    public Shoe getWorkShoe();
}

public class ManShoeFactory implements ShoeFactory {
    @Override
    public Shoe getRunShoe() {
        return new ManRunShoe();
    }

    @Override
    public Shoe getWorkShoe() {
        return new ManWorkShoe();
    }
}

public class WomanShoeFactory implements ShoeFactory {
    @Override
    public Shoe getRunShoe() {
        return new WomanRunShoe();
    }

    @Override
    public Shoe getWorkShoe() {
        return new WomanWorkShoe();
    }
}

public class Test {
    public static void main(String[] args) {
        ShoeFactory manShoeFactor=new ManShoeFactory();
        System.out.println(manShoeFactor.getRunShoe().getShoeName());
        System.out.println(manShoeFactor.getWorkShoe().getShoeName());
        ShoeFactory womanShoeFactor=new WomanShoeFactory();
        System.out.println(womanShoeFactor.getRunShoe().getShoeName());
        System.out.println(womanShoeFactor.getWorkShoe().getShoeName());
    }
}

3.常见框架中的策略模式

1.Spring中的FactoryBean就是典型的工厂方法模式

2.dubbo中的RegistryFactory工厂方法模式

3.netty中的ByteBufAllocator的实现使用了抽象工厂模式