设计模式-JAVA-创建模式-工厂方法模式

工厂方法模式

不使用工厂模式版本

优点：简单明了。
缺点：对同一产品的创建代码散布整个项目，当产品变更或替换时，缺少统一管理的方法。
解决方法：简单工厂模式

package cn.com.cj.designMode.createMode.noFactory;

/**
 * 不使用工厂模式的版本
 */
public class Main {
    public static void main(String[] args) {
        Animal dog = new Dog();
        Animal cat = new Cat();
    }
}

interface Animal{
    /**
     * 叫
     */
    void say();
}

class Dog implements Animal{
    @Override
    public void say() {
        System.out.println("Dog say");
    }
}

class Cat implements Animal{
    @Override
    public void say() {
        System.out.println("Cat say");
    }
}

简单工厂模式

特点：创建一个工厂类，工厂类实现对同一个接口的实现类进行实例的创建。
优点：相比不使用工厂模式，简单工厂模式提供了对创建产品代码的统一管理的方法。
	当产品发生变化或变更的时候，仅需要修改工厂类即可。
缺点：
	1.工厂类内部判断逻辑多且复杂，不利于增加或变更产品时的修改。
	2.产品在创建时会有附加的业务代码，所有产品的业务代码都集中在工厂类中，造成了工厂类的臃肿。
解决方法：工厂方法模式

package cn.com.cj.designMode.createMode.esayFactory;

/**
 * 动物
 */
public interface Animal {
    /**
     * 叫
     */
    void say();
}

package cn.com.cj.designMode.createMode.esayFactory;

public class Cat implements Animal {
    @Override
    public void say() {
        System.out.println("Cat say");
    }
}

package cn.com.cj.designMode.createMode.esayFactory;

public class Dog implements Animal {
    @Override
    public void say() {
        System.out.println("Dog say");
    }
}

package cn.com.cj.designMode.createMode.esayFactory;

/**
 * 动物工厂类
 */
public class AnimalFactory {
    public static Animal createAnimal( String type ) {
        if( "Dog".equals(type) ){
            return new Dog();
        }else if( "Cat".equals(type) ){
            return new Cat();
        }
        return null;
    }
}

package cn.com.cj.designMode.createMode.esayFactory;

public class Main {
    public static void main(String[] args) {
        //使用创建工厂类创建动物对象
        Animal dogAnimal = AnimalFactory.createAnimal("Dog");
        Animal catAnimal = AnimalFactory.createAnimal("Cat");
        dogAnimal.say();
        catAnimal.say();
    }
}

工厂方法模式（简称工厂模式）

工厂方法模式是简单工厂模式的一种延伸。
特点：创建一个工厂类接口，并为每种产品都创建一个工厂实现类。新增产品同时新增工厂类。将对产品工厂的选择权交给了客户端。
优点：一个产品对应一个工厂类，不同工厂类中编写不同产品特有的附加代码，改善了简单工厂模式的缺点。
缺点：将工厂选择权交给了客户端，当产品大批量的更换时，需要客户端大量变更代码。
解决方法：抽象工厂模式

package cn.com.cj.designMode.createMode.methedFactory;

/**
 * 产品接口
 */
public interface Product {
    /**
     * 产品功能描述
     */
    void desc();
}

package cn.com.cj.designMode.createMode.methedFactory;

public class ProductA implements Product {
    @Override
    public void desc() {
        System.out.println("A类型产品");
    }
}

package cn.com.cj.designMode.createMode.methedFactory;

public class ProductB implements Product {
    @Override
    public void desc() {
        System.out.println("B类型产品");
    }
}

package cn.com.cj.designMode.createMode.methedFactory;

public class ProductAFactory implements ProductFactory {
    @Override
    public Product createProduct() {
        return new ProductA();
    }
}

package cn.com.cj.designMode.createMode.methedFactory;

public class ProductAFactory implements ProductFactory {
    @Override
    public Product createProduct() {
        return new ProductA();
    }
}

package cn.com.cj.designMode.createMode.methedFactory;

public class ProductBFactory implements ProductFactory {
    @Override
    public Product createProduct() {
        return new ProductB();
    }
}

package cn.com.cj.designMode.createMode.methedFactory;

public class Main {
    public static void main(String[] args) {
        //通过A产品工厂类创建A产品对象
        ProductFactory productAFactory = new ProductAFactory();
        Product productA = productAFactory.createProduct();
        productA.desc();
        //通过B产品工厂类创建B产品对象
        ProductFactory productBFactory = new ProductBFactory();
        Product productB = productBFactory.createProduct();
        productB.desc();
    }
}

抽象工厂模式

特点：抽象工厂模式基于工厂方法模式。可以批量的更换所有产品工厂。
优点：抽象工厂模式中的工厂类可以产生一系列的产品对象，而工厂方法模式中的工厂类仅能创建一个产品对象。
当增加一个产品系列时，需要创建一个工厂实现类，以及新系列的所有的产品实现类。
缺点：当增加一个产品时，需要修改工厂接口，并调整所有工厂实现类。

package cn.com.cj.designMode.createMode.absFactory;

import cn.com.cj.designMode.createMode.absFactory.factory.AFacotry;
import cn.com.cj.designMode.createMode.absFactory.factory.BFacotry;
import cn.com.cj.designMode.createMode.absFactory.factory.IFactory;
import cn.com.cj.designMode.createMode.absFactory.product.IDisplay;
import cn.com.cj.designMode.createMode.absFactory.product.IMovie;

/**
 * 抽象工厂设计模式演示
 */
public class Main {
    public static void main(String[] args) {

        IFactory factory = null;
        //使用三星显示器观看电影
//        IFactory factory = new AFacotry();
        //使用AOC显示器观看电影
//        IFactory factory = new BFacotry();
        IDisplay iDisplay = factory.getDisplay();
        IMovie iMovie = factory.getMovie();
        iDisplay.open();
        iDisplay.show(iMovie);
        iDisplay.close();
    }
}

package cn.com.cj.designMode.createMode.absFactory.product;

/**
 * 电影产品接口
 */
public interface IMovie {
    /**
     * 描述电影内容
     */
    void desc();
}

package cn.com.cj.designMode.createMode.absFactory.product;

/**
 * 显示器产品接口
 */
public interface IDisplay {
    /**
     * 开机
     */
    void open();

    /**
     * 关机
     */
    void close();

    /**
     * 显示
     */
    void show(IMovie iMovie);
}

package cn.com.cj.designMode.createMode.absFactory.product;
/**
* A电影实现类
*/
public class AMovie implements IMovie {
    @Override
    public void desc() {
        System.out.println("A电影描述");
    }
}

package cn.com.cj.designMode.createMode.absFactory.product;
/**
* B电影实现类
*/
public class BMovie implements IMovie {
    @Override
    public void desc() {
        System.out.println("B电影描述");
    }
}

package cn.com.cj.designMode.createMode.absFactory.product;
/**
* 三星显示器实现类
*/
public class SamsungDisplay implements IDisplay {
    @Override
    public void open() {
        System.out.println("三星显示器开机");
    }

    @Override
    public void close() {
        System.out.println("三星显示器关机");
    }

    @Override
    public void show( IMovie movie ) {
        System.out.println("三星显示器显示内容");
        movie.desc();
    }
}

package cn.com.cj.designMode.createMode.absFactory.product;
/**
* AOC显示器实现类
*/
public class AOCDisplay implements IDisplay{
    @Override
    public void open() {
        System.out.println("AOC显示器开机");
    }

    @Override
    public void close() {
        System.out.println("AOC显示器关机");
    }

    @Override
    public void show( IMovie movie ) {
        System.out.println("AOC显示器显示");
        movie.desc();
    }
}

package cn.com.cj.designMode.createMode.absFactory.factory;

import cn.com.cj.designMode.createMode.absFactory.product.IDisplay;
import cn.com.cj.designMode.createMode.absFactory.product.IMovie;

/**
 * 抽象工厂接口
 * 抽象工厂的实现类要实现可以生成一系列产品的工厂对象
 */
public interface IFactory {
    /**
     * 获取显示器
     * @return
     */
    IDisplay getDisplay();

    /**
     * 获取电影
     * @return
     */
    IMovie getMovie();
}

package cn.com.cj.designMode.createMode.absFactory.factory;

import cn.com.cj.designMode.createMode.absFactory.product.AMovie;
import cn.com.cj.designMode.createMode.absFactory.product.IDisplay;
import cn.com.cj.designMode.createMode.absFactory.product.IMovie;
import cn.com.cj.designMode.createMode.absFactory.product.SamsungDisplay;

/**
 * A播放方案实现类
 */
public class AFacotry implements IFactory {
    @Override
    public IDisplay getDisplay() {
        return new SamsungDisplay();
    }

    @Override
    public IMovie getMovie() {
        return new AMovie();
    }
}

package cn.com.cj.designMode.createMode.absFactory.factory;

import cn.com.cj.designMode.createMode.absFactory.product.AOCDisplay;
import cn.com.cj.designMode.createMode.absFactory.product.BMovie;
import cn.com.cj.designMode.createMode.absFactory.product.IDisplay;
import cn.com.cj.designMode.createMode.absFactory.product.IMovie;

/**
 * B播放方案实现类
 */
public class BFacotry implements IFactory {
    @Override
    public IDisplay getDisplay() {
        return new AOCDisplay();
    }

    @Override
    public IMovie getMovie() {
        return new BMovie();
    }
}