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

Posted 2023-02-18 SingleOneMan

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

文章目录

• 设计模式笔记-简单工厂模式，工厂方法模式，抽象工厂模式
• • 1.区别
  • 2.常见写法
  • 3.常见框架中的策略模式

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的实现使用了抽象工厂模式