工厂模式

简单工厂：

非GOF23种设计模式,是指由一个工厂对象决定创建出哪一种产品类的实例.

简单工厂适用 于工厂类负责创建的对象较少的场景，且客户端只需要传入工厂类的参数，对于如何创 建对象的逻辑不需要关心。

Video：

public abstract class Video {
    public abstract void produce();
}

JavaVideo：

public class JavaVideo extends Video {
    @Override
    public void produce() {
        System.out.println("java课程");
    }
}

PythonVideo：

public class PythonVideo extends Video {
    @Override
    public void produce() {
        System.out.println("Python课程");
    }
}

VideoFactory：

public class VideoFactory {
    // 1
//    public static Video getVideo(String type){
//        if ("java".equalsIgnoreCase(type)){
//            return new JavaVideo();
//        }else if ("python".equalsIgnoreCase(type)){
//            return new PythonVideo();
//        }else{
//            return null;
//        }
//
//    }
    // 2
    //利用反射
    public static Video getVideo(Class clazz){
        Video video = null;
        try {
            video = (Video) Class.forName(clazz.getName()).newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return video;
    }
/**

public static Video getVideo(Class<? extends Video> clazz){
    Video video = null;
    try {
        video = clazz.newInstance();
    } catch (Exception e) {
        e.printStackTrace();
    }
    return video;
}
*/

}

Test：

public class Test {
    public static void main(String[] args){
        //1
//        Video video = VideoFactory.getVideo("java");
//        if (video!=null){
//            video.produce();
//        }

        //2
        Video video = VideoFactory.getVideo(PythonVideo.class);
        if (video!=null){
            video.produce();
        }
    }
}

简单工厂缺点:工厂类的职责相对过重，不易于扩展过于复杂的产品结构

-----------------------------------------------------------------------------------------------------------------

工厂方法模式：

工厂方法模式(Fatory Method Pattern)是指定义一个创建对象的接口，但让实现这个 接口的类来决定实例化哪个类，工厂方法让类的实例化推迟到子类中进行。在工厂方法 模式中用户只需要关心所需产品对应的工厂，无须关心创建细节，而且加入新的产品符 合开闭原则

public interface Factory {
    Video getVideo();
}

JavaVideoFactory：

import factorys.JavaVideo;
import factorys.Video;

public class JavaVideoFactory implements Factory {
    @Override
    public Video getVideo() {
        return new JavaVideo();
    }
}

PythonVideoFactory：

import factorys.PythonVideo;
import factorys.Video;


public class PythonVideoFactory implements Factory{
    @Override
    public Video getVideo() {
        return new PythonVideo();
    }
}

Test:

/**
 * 工厂方法模式
 */
public class Test {
    public static void main(String[] args){
        Factory factory = new JavaVideoFactory();
        factory.getVideo().produce();

        factory = new PythonVideoFactory();
        factory.getVideo().produce();
    }
}

工厂方法适用于以下场景:
1、创建对象需要大量重复的代码。

2、客户端(应用层)不依赖于产品类实例如何被创建、实现等细节。 3、一个类通过其子类来指定创建哪个对象。
工厂方法也有缺点:
1、类的个数容易过多，增加复杂度。
2、增加了系统的抽象性和理解难度

----------------------------------------------------------------------------

抽象工厂:

抽象工厂模式(Abastract Factory Pattern)是指提供一个创建一系列相关或相互依赖

对象的接口，无须指定他们具体的类。客户端(应用层)不依赖于产品类实例如何被创建、实现等细节，强调的是一系列相关的产品对象(属于同一产品族)一起使用创建对 象需要大量重复的代码。需要提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现。

JavaVideoFactory:

import factorys.JavaVideo;
import factorys.Video;
import factorys.func.Factory;


public class JavaVideoFactory extends AbstractFactory {
    @Override
    public Video getVideo() {
        return new JavaVideo();
    }
}

PythonVideoFactory:

import factorys.PythonVideo;
import factorys.Video;
import factorys.func.Factory;


public class PythonVideoFactory extends AbstractFactory {
    @Override
    public Video getVideo() {
        return new PythonVideo();
    }
}

AbstractFactory:

import factorys.Video;

public abstract class AbstractFactory {
    protected abstract Video getVideo();

    public Video getVideo(Class clazz){
        Video video = null;
        try {
            video = (Video) clazz.forName(clazz.getName()).newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return video;
    }
}

DefaultFactory:

import factorys.Video;


public class DefaultFactory extends AbstractFactory {
    private JavaVideoFactory def = new JavaVideoFactory();
    @Override
    protected Video getVideo() {
        return def.getVideo();
    }
}

Test:

import factorys.PythonVideo;

/**
 * 抽象工厂
 */
public class Test {
    public static void main(String[] args) {
        AbstractFactory factory = new DefaultFactory();
        factory.getVideo().produce();

        factory.getVideo(PythonVideo.class).produce();
    }
}

---------------------------------------------------------------------------------

抽象工厂案例二：

public interface INode {
    void edit();
}

public interface IVideo {
    void record();
}

//创建一个抽象工厂 CourseFactory 类

public interface CourseFactory {
    INode createNode();
    IVideo createVideo();
}

//创建 Java 产品族，，Java 视频 JavaVideo 类

public class JavaNode implements INode {
    @Override
    public void edit() {
        System.out.println("edit java");
    }
}

public class JavaVideo implements IVideo {
    @Override
    public void record() {
        System.out.println("record java");
    }
}

public class JavaCourseFactory implements CourseFactory {
    @Override
    public INode createNode() {
        return new JavaNode();
    }

    @Override
    public IVideo createVideo() {
        return new JavaVideo();
    }
}

测试

public class Test {
    public static void main(String[] args){
        CourseFactory factory = new JavaCourseFactory();
        factory.createNode().edit();
        factory.createVideo().record();
    }
}

抽象工厂缺点:

1、规定了所有可能被创建的产品集合，产品族中扩展新的产品困难，需要修改抽象工厂的接口。

2、增加了系统的抽象性和理解难度。