Java 设计模式之工厂模式

工厂模式分为普通工厂模式、多工厂模式、静态工厂模式以及抽象工厂模式，下面对各种模式进行理解解释

工厂模式就是为了解决同一接口而进行实例化的模式

普通工厂模式：

如：我要买东西

public interface IUser {

    public void buy();
}

然后你要去买苹果 实现如下

public class BuyApple implements IUser {

    @Override
    public void buy() {
        System.out.println("我要买苹果");
    }

}

再然后你再去买橙子 实现如下

public class BuyOrange implements IUser {

    @Override
    public void buy() {
        System.out.println("我要买橙子");
    }

}

工厂类：买啥new 啥

public class BuyFactory {

    
    public IUser buy(String buyWhat){
        if("apple".equals(buyWhat)){
            return new BuyApple();
        }else if("orange".equals(buyWhat)){
            return new BuyOrange();
        }
        return null;
        
    }
    主函数 买个苹果
    public static void main(String[] args) {
        BuyFactory buyFactory = new BuyFactory();
        IUser user = buyFactory.buy("apple");
        user.buy();
    }

}
 

总结 : 买苹果和买橙子都是需要买的动作，买成为一个一样的接口，但是这个会有一个问题 传入苹果橙子都不会有什么问题，但是如果传入是香蕉，那就会报错，于是我们用多工厂模式

多工厂模式：对上面BuyFactory改造如下：

public class BuyFactory {

    
//    public IUser buy(String buyWhat){
//        if("apple".equals(buyWhat)){
//            return new BuyApple();
//        }else if("orange".equals(buyWhat)){
//            return new BuyOrange();
//        }
//        return null;
//        
//    }
//    买苹果
    public IUser buyApple(){
        return new BuyApple();
    }
//    买橙子
    public IUser buyOrange(){
        return new BuyOrange();
    }
    
    public static void main(String[] args) {
//        BuyFactory buyFactory = new BuyFactory();
//        IUser user = buyFactory.buy("apple");
//        user.buy();
        BuyFactory buyFactory = new BuyFactory();
        IUser user = buyFactory.buyApple();
        user.buy();
    }

}

总结：多工厂模式跟普通工厂对比，对每次示例都多了一个方法，但是每次都必须new 工厂，于是我们引入静态工厂模式

静态工厂模式：继续对上面BuyFactory编写

public class BuyFactory {

    public static IUser buyApple(){
        return new BuyApple();
    }
    
    public static IUser buyOrange(){
        return new BuyOrange();
    }

    public static void main(String[] args) {
    
        IUser user = BuyFactory.buyApple();
        user.buy();
    }

}

总结：就是对方法进行static，不需要new了。另外还有抽象工厂模式。上面我们想买水果，那么我们还需要拿走水果，如下

public interface IToke {

    public void toke();
}

public class ManToken implements IToke {
    @Override
    public void toke() {
        System.out.println("男人拿走");
    }
}

和工厂模式同理

我们把买和拿走工厂抽象

public abstract class AbstractFactory {
    public abstract IUser buy();
    public abstract IToke toke();
}

改造BuyFactory

public class BuyFactory extends AbstractFactory{
    @Override
    public IUser buy() {
        return new BuyOrange();
    }
    @Override
    public IToke toke() {
        return null;
    }
}

同理

public class TokenFactory extends AbstractFactory{
    public IToke toke(){
        return new ManToken();
    }
    @Override
    public IUser buy() {
        // TODO Auto-generated method stub
        return null;
    }
}

生产工厂如下：

public class ProviceFactory {

    public static AbstractFactory getFactory(String factory){
        if("buy".equals(factory)){
            return new BuyFactory();
        }else if("toke".equals(factory)){
            return new TokenFactory();
        }
        return null;
    }
}

测试

public static void main(String[] args) {
        AbstractFactory o = ProviceFactory.getFactory("buy");
        IUser iuser = o.buy();
        iuser.buy();
    }

抽象工厂不改变原有的工厂内部的代码，新的需求生产建造新的工厂，实现开闭原则

完。。