工厂方法

简单工厂

简单工厂的定义与类型

• 定义：由一个工厂对象决定创建出哪一种产品类的实例
• 类型：创建型，但不属于GOF23种设计模式

简单工厂的适用场景

工厂类负责创建的对象比较少
客户端只知道传入工厂类的参数，对于如何创建对象不关心

简单工厂的优点

只需要传入一个正确的参数，就可以获得你需要的对象而无需知道其创建细节

简单工厂缺点

工厂类的职责相对过重，增加新的产品需要修改工厂类的判断逻辑，违背开闭原则
请看如下代码：

package design.creational.simpleFactory;

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

package design.creational.simpleFactory;

public class JavaVideo extends Video {

    @Override
    public void produde() {
        System.out.println("java视频");
    }
}

package design.creational.simpleFactory;

public class PythonVideo extends Video{
    @Override
    public void produde() {
        System.out.println("python视频");
    }
}

package design.creational.simpleFactory;

import com.sun.org.apache.regexp.internal.RE;

public class ViedoFactory {
//    public Video getVideo(String type){
//        if ("java".equals(type)){
//            return new JavaVideo();
//        }else if ("python".equals(type)){
//            return new PythonVideo();
//        }else {
//            return null;
//        }
//    }


    //使用反射
    public Video getVideo(Class c){
        Video video = null;
        try {
            video = (Video) Class.forName(c.getName()).newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return video;
    }
}

package design.creational.simpleFactory;

public class Test {
    public static void main(String[] args) {
        //v1
//        Video video = new JavaVideo();
//        video.produde();

        //v2
//        ViedoFactory viedoFactory = new ViedoFactory();
//        Video video = viedoFactory.getVideo("java");
//        if (video == null){
//            return;
//        }
//        video.produde();

        //使用反射
        ViedoFactory viedoFactory = new ViedoFactory();
        Video video = viedoFactory.getVideo(JavaVideo.class);
        if (video == null){
            return;
        }
        video.produde();

    }
}

工厂方法

工厂的定义与类型

• 定义：定义一个创建对象的接口，但让实现这个接口的类来决定实例化哪个类，工厂方法让类的实例化推迟到子类中进行。
• 创建型

适应场景

• 创建对象需要大量重复的代码
• 客户端不依赖于产品类实例如何被创建、实现等细节
• 一个类通过其子类来指定创建哪个对象

优点

用户只需关心所需产品对应的工厂，无需关心创建细节
加入新产品符合开闭原则，提高可扩展性

缺点

类的个数容易过多，增加复杂度
增加了系统的抽象性和理解难度
下面看下面的代码：

package design.creational.factoryMethod;

public class JavaVideo extends Video {

    @Override
    public void produde() {
        System.out.println("java视频");
    }
}

package design.creational.factoryMethod;

public abstract class VideoFactory {

    public abstract Video getVideo();

}

package design.creational.factoryMethod;

public class PythonVideo extends Video {
    @Override
    public void produde() {
        System.out.println("python视频");
    }
}

package design.creational.factoryMethod;

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

package design.creational.factoryMethod;

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

package design.creational.factoryMethod;

public class FEVideoFactory extends VideoFactory {
    @Override
    public Video getVideo() {
        return new FEVideo();
    }
}

抽象工厂

抽象工厂的定义与类型

• 定义：提供一个创建一系列相关或相互依赖对象的接口
• 无需指定他们具体的类
• 类型：创建型

适用场景

• 客户端不依赖于产品类实例如何被创建、实现等细节
• 强调一系列相关的产品对象一起使用需要创建大量重复的代码
• 提供一个产品类库，所有的产品以相同的接口出现，从而使客户端不依赖于具体实现

优点

• 具体产品在应用层代码隔离，无需关系细节
• 将一个系列的产品统一到一起创建

缺点

• 规定了所有可能被创建的产品集合，产品族中扩展新的产品困难，需要修改抽象工厂的接口
• 增加了系统的抽象性和理解难度

下面看代码：

package design.creational.abstractFactory;

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

package design.creational.abstractFactory;

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

package design.creational.abstractFactory;

public interface CourseFactory {
    Video getVideo();
    Article getArticle();
}

package design.creational.abstractFactory;

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

package design.creational.abstractFactory;

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

package design.creational.abstractFactory;

public class JavaCourseFactory implements CourseFactory {
    @Override
    public Video getVideo() {
        return new JavaVideo();
    }

    @Override
    public Article getArticle() {
        return new JavaAritcle();
    }
}

package design.creational.abstractFactory;

public class PythonCourseFactory implements CourseFactory {
    @Override
    public Video getVideo() {
        return new PythonVideo();
    }

    @Override
    public Article getArticle() {
        return new PythonArticle();
    }
}

package design.creational.abstractFactory;

public class Test {
    public static void main(String[] args) {
        CourseFactory courseFactory = new JavaCourseFactory();
        Video video = courseFactory.getVideo();
        Article article = courseFactory.getArticle();
        video.produce();
        article.produce();

    }
}