23种设计模式之工厂模式：以工厂买车和动物为例子

简单工厂模式

/**
 * およそ神
 */
public class Wuling implements Car {
    @Override
    public void name() {
        System.out.println("五菱宏光！");
    }
}

/**
 * およそ神
 */
public class Tesla implements Car {
    @Override
    public void name() {
        System.out.println("特斯拉！");
    }
}

/**
 * およそ神
 */
public class Dazhong implements Car {
    @Override
    public void name() {
        System.out.println("大众");
    }
}

/**
 * およそ神
 * 车工厂拿车的效果
 * 开闭原则
 * (简单)静态工厂模式,不修改代码，做不到
 */
public class CarFactory {
    //方法一
    public static Car getcar(String car) {
        if (car.equals("五菱")) {
            return new Wuling();
        } else if (car.equals("特斯拉")) {
            return new Tesla();
        } else {
            return null;
        }
    }
    //方法二
    public static Car getWuling() {
        return new Wuling() ;
    }

    public static Car getTesla() {
        return new Tesla();
    }
}

/**
 * およそ神
 */
public interface Car {
    void name();
}

/**
 * およそ神
 * 测试类
 */
public class Consumer {
    public static void main(String[] args) {
        //1.接口和所有的实现类!工厂
        //Car c1 = new Wuling();
        //Car c2 = new Tesla();

        //2.使用工厂创建
        Car c1 = CarFactory.getcar("五菱");
        Car c2 = CarFactory.getcar("特斯拉");
        c1.name();
        c2.name();
    }
}

工厂方法模式

package Month4.day4_20.method;

/**
 * およそ神
 */
public class MoBai implements Car {
    @Override
    public void name() {
        System.out.println("摩拜单车");
    }
}

package Month4.day4_20.method;

/**
 * およそ神
 */
public class MoBaiFactory implements CarFactory {
    @Override
    public Car getCar() {
        return new MoBai();
    }
}

package Month4.day4_20.method;

/**
 * およそ神
 */
public class Tesla implements Car {
    @Override
    public void name() {
        System.out.println("特斯拉！");
    }
}

package Month4.day4_20.method;

/**
 * およそ神
 */
public class TeslaFactory implements CarFactory {
    @Override
    public Car getCar() {
        return new Tesla();
    }
}

package Month4.day4_20.method;

/**
 * およそ神
 */
public class Wuling implements Car {
    @Override
    public void name() {
        System.out.println("五菱宏光！");
    }
}

package Month4.day4_20.method;

/**
 * およそ神
 */
public class WulingFactory implements CarFactory {
    @Override
    public Car getCar() {
        return new Wuling();
    }
}

package Month4.day4_20.method;

/**
 * およそ神
 */
public interface Car {
    void name();
}

package Month4.day4_20.method;

/**
 * およそ神
 * 工厂方法模式(创建多个工厂实现多个接口)更满足开闭原则
 */
public interface CarFactory {
    Car getCar();
}

抽象工厂模式

package Month4.day4_24.TestAbstractFactory;

/**
 * およそ神
 * 选择宠物品种
 */
public interface Kind {
    Dog dog();

    Cat cat();
}

package Month4.day4_24.TestAbstractFactory;

/**
 * およそ神
 * 狗接口
 */
public interface Dog {
    //狗看家
    void lookhome();
    //狗可以微笑
    void smile();
}

package Month4.day4_24.TestAbstractFactory;

/**
 * およそ神
 * 猫接口
 */
public interface Cat {
    //猫爬树
    void climb();

    //猫吃鱼
    void eatfish();
}

package Month4.day4_24.TestAbstractFactory;

/**
 * およそ神
 * 宠物类实现宠物品种接口
 */
public class Pet implements Kind {
    @Override
    public Dog dog() {
        return new CaiDog();
    }

    @Override
    public Cat cat() {
        return new BlueCat();
    }
}

package Month4.day4_24.TestAbstractFactory;

/**
 * およそ神
 * 狗类
 */
public class CaiDog implements Dog{

    @Override
    public void lookhome() {
        System.out.println("柴犬不会看家！");
    }

    @Override
    public void smile() {
        System.out.println("柴犬一边喝水，一边微笑！");
    }
}

package Month4.day4_24.TestAbstractFactory;

/**
 * およそ神
 * 猫类
 */
public class BlueCat implements Cat {
    @Override
    public void climb() {
        System.out.println("英短猫咪爬树！");
    }

    @Override
    public void eatfish() {
        System.out.println("英短吃水里的鱼");
    }
}

package Month4.day4_24.TestAbstractFactory;

/**
 * およそ神
 * 测试类
 */
public class Test {
    public static void main(String[] args) {
        System.out.println("=========英短猫咪========");
        //获取宠物
        Pet pet = new Pet();
        //获取宠物中的猫咪
        Cat cat = pet.cat();
        cat.climb();
        cat.eatfish();
        System.out.println("=========柴犬========");
        Pet pet1 = new Pet();
        Dog dog = pet1.dog();
        dog.lookhome();
        dog.smile();
    }
}

定义：抽象工厂模式提供了一个创建一系列相关或者相互依赖对象的接口，无需指定他们的具体的类！
实用场景：1.客户端应用层不依赖于产品实例如何被创建，实现等细节2.强调一些列相关的产品对象，一起使用创建对象需要大量的重复代码3.提供一个产品类的库，所有产品以相同的接口出现，从而使得客户端不依赖于具体的实现！
优点：具体产品在应用层的代码隔离，无需关心创建的细节，将一个系列的产品统一到一起创建
缺点：规定了所有可能被创建的产品集合，产品族中扩展新的产品困难，增加了系统的抽象性和理解难度