工厂模式

工厂模式

简单工厂模式

抽象角色（所有角色的父类）

public interface Fruit {
    //采集
    void get();
}

具体产品角色

public class Apple implements Fruit{
    public void get(){
        System.out.println("采集苹果");
    }
}

public class Banana implements Fruit{
    public void get(){
        System.out.println("采集香蕉");
    }
}

工厂对象

public class FruitFactory {
   public static Fruit getFruit(String type){
        if (type==null){
            return null;
        }
        if (type.equalsIgnoreCase("apple")){
            return new Apple();
        }else if(type.equalsIgnoreCase("banana")){
            return new Banana();
        }
            return null;
    }
}

测试类

public class MainClass {
    public static void main(String[] args) {
        //实例化Apple
        Fruit apple =  FruitFactory.getFruit("apple");
        //实例化banana
        Fruit banana =  FruitFactory.getFruit("BAnana");
        apple.get();
        banana.get();
    }
}

工厂方法模式

遵守了“开放-封闭”原则

抽象角色

public interface Fruit {
    //采集
    void get();
}

抽象工厂角色

public interface FruitFactory {
    Fruit getFruit();
}

具体产品角色

public class Apple implements Fruit {
    public void get(){
        System.out.println("采集苹果");
    }
}

public class Banana implements Fruit {
    public void get(){
        System.out.println("采集香蕉");
    }
}

具体工厂角色

public class AppleFactory implements FruitFactory {
    @Override
    public Fruit getFruit() {
        return new Apple();
    }
}

public class BananaFactory implements FruitFactory {
    @Override
    public Fruit getFruit() {
        return new Banana();
    }
}

测试类

public class MainClass {
    public static void main(String[] args) {
        //获得苹果工厂
        FruitFactory appleFactory = new AppleFactory();
        //获得苹果对象
        Fruit apple = appleFactory.getFruit();
        apple.get();
        //获得香蕉工厂
        BananaFactory bananaFactory = new BananaFactory();
        //获得香蕉对象
        Fruit banana = bananaFactory.getFruit();
        banana.get();

    }
}

抽象工厂模式

抽象角色

public interface Fruit {
    //采集
    void get();
}

public abstract class Apple implements Fruit {
    public abstract void get();
}

public abstract class Banana implements Fruit {
    public abstract void get();
}

具体产品角色

public class NorthApple extends Apple {
    @Override
    public void get() {
        System.out.println("采集北方苹果");
    }
}

public class SouthApple extends Apple {
    @Override
    public void get() {
        System.out.println("采集南方苹果");
    }
}

public class NorthBanana extends Banana {
    @Override
    public void get() {
        System.out.println("采集北方香蕉");
    }
}

public class SouthBanana extends Banana {
    @Override
    public void get() {
        System.out.println("采集南方香蕉");
    }
}

抽象工厂角色

public interface FruitFactory {
    //实例化苹果
    Fruit getApple();
    //实例化香蕉
    Fruit getBanana();
}

具体工厂角色

public class NorthFruitFactory implements FruitFactory {
    @Override
    public Fruit getApple() {
        return new NorthApple();
    }

    @Override
    public Fruit getBanana() {
        return new NorthBanana();
    }
}

public class SouthFruitFactory implements FruitFactory {
    @Override
    public Fruit getApple() {
        return new SouthApple();
    }

    @Override
    public Fruit getBanana() {
        return new SouthBanana();
    }
}

测试类

public class MainClass {
    public static void main(String[] args) {
        NorthFruitFactory nff = new NorthFruitFactory();
        SouthFruitFactory sff = new SouthFruitFactory();
        Fruit napple = nff.getApple();
        napple.get();
        Fruit nbanana = nff.getBanana();
        nbanana.get();
        Fruit sapple = sff.getApple();
        sapple.get();
        Fruit sbanana = sff.getBanana();
        sbanana.get();

    }
}