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

谁践踏了优雅 2023-06-19 09:57 3阅读 0赞

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

### 文章目录 ###

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