设计模式笔记-简单工厂模式,工厂方法模式,抽象工厂模式
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的实现使用了抽象工厂模式