java简单工厂模式,工厂模式与,抽象工厂解析与实例

简单工程方法 与抽象工厂的理解与实现

定义与类型
定义:
定义一个创建对象的接口
但让实现这个接口的类来决定实例化哪个类
工厂方法让类的实例化推迟到子类中进行
类型:创建型
适用场景
创建对象需要大量重复的代码
客户端(应用层)不依赖于产品突奕到如何被创建、实现等细节
一个类通过其子类来指定创建哪个对象
优点
用户只需要关心所需产品对应的工厂,无须关心创建细节
加入新产品符合开闭原则,提高可扩展性
缺点
类的个数容易过多,增加复杂度
增加了系统的抽象性和理解难度

几个概念词 抽象工厂 —> 抽象产品 具体工厂---->具体产品

一个最简单的例子 录制一个课程 录制一个java课程

public class JavaVideo  {
    public void produce() {
        System.out.println("录制Java课程视频");
    }
}

使用层(相当于我Controller层的使用)

   public static void main(String[] args) {

        JavaVideo video = new JavaVideo();
        video.produce();

    }

这样我们就可以录制啦,但是我要录制其他的课程呢?写一个抽象类

public abstract class Video {
    /**
     * 生产视频的方法
     */
    public abstract void produce();

}

代码更改

public class JavaVideo extends Video {
    @Override
    public void produce() {
        System.out.println("录制Java课程视频");
    }
}
public class PythonVideo extends Video {
    @Override
    public void produce() {
        System.out.println("录制Python课程视频");
    }
}

让后写两个工厂方法

public class VideoFactory {
    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;
    }


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

}
//使用类 
 public static void main(String[] args) {
        VideoFactory videoFactory = new VideoFactory();
        Video video = videoFactory.getVideo("java");
        if (video == null) {
            return;
        }
        video.produce();
//
//        VideoFactory videoFactory = new VideoFactory();
//        Video video = videoFactory.getVideo(JavaVideo.class);
//        if(video == null){
//            return;
//        }
//        video.produce();

    }

这里使用了两种生产的方法一个是通过反射,另一个是通过判断

原来的应用层直接依赖javaVideo ,现在具体的生产过程都在VideoFactory里面,我只需要告诉它我要什么类型的视频即可,不需要关注具体得 细节
我们看看JDK 里面 也有类似的方法 如图

这里获取实例 也用过了类似的判断

工厂模式

我们在学习完简单工厂模式后继续看工厂模式
关键词: 定义一个创建对象的接口
但让实现这个接口的类来决定实例化哪个类
工厂方法让类的实例化推迟到子类中进行 工厂:创建方法用的 ,方法:通过子类实现创建的对象
接着我们上面的业务,当我们需要录制java课程的时候它有很多种类,比如说基础的,比如说框架等等,而上面py课程和java课程都在一个工厂类中创建的.所以我们把这个工厂进行细化,也就是说 ,java课程 有特殊的java工厂,而对应的py课程也有具体的工厂 ,
所以我们需要抽象的工厂方法, 为什么是抽象的? 因为某些属性是已知的，所以他这里边有可能除了抽象方法，还有一些已知的实现，那么用抽象类就是比较合适的了，如果这里边全是未知的，我们完全可以使用接口来定义。

看看UML类图

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

}
public abstract class VideoFactory {

    public abstract Video getVideo();
}
public class JavaVideoFactory extends VideoFactory {
    @Override
    public Video getVideo() {
        return new JavaVideo();
    }
}
public class JavaVideo extends Video {
    @Override
    public void produce() {
        System.out.println("录制Java课程视频");
    }
} 
 public static void main(String[] args) {
        VideoFactory videoFactory = new PythonVideoFactory();
        VideoFactory videoFactory2 = new JavaVideoFactory();
        VideoFactory videoFactory3 = new FEVideoFactory();
        Video video = videoFactory.getVideo();
        video.produce();

    }

这样如果我们如果加入新的算法课程,只需要创建新的工厂和具体的实现类即刻,不需要修改之前之前的代码
工厂方法在JDK里面具体的体现 最熟悉的 Connection工厂我们都知道他是一个 抽象的类

1 Collection -----> 对应着我们VideoFactory 抽象的工厂
2 ArrayList ---->> 对应着我们 的javaVideoFactory 具体的实现的工厂
3 Itr --> javaVideo 实际的生产的产品
4 iterator --> Voieo 抽象产品

抽象工厂

**对应关键字 产品族,产品等级结构 **

定义与类型
定义:抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口
无须指定它们具体的类
类型:创建型
适用场景
客户端(应用层)不依赖于产品类实例如何被创建、实现等细节
强调一系列相关的产品对象(属于同一产品族)一起使用创建对
象需要大量重复的代码
提供一个产品类的库,所有的产品以同样的接口出现
从而使客户端不依赖于具体实现
优点
具体产品在应用层代码隔离,无须关心创建细节
将一个系列的产品族统一到一起创建
缺点
规定了所有可能被创建的产品集合,产品族中扩展新的产品困难.
需要修改抽象工厂的接口
增加了系统的抽象性和理解难度
工厂方法针对的是产品等级结构 , 抽象工厂针对的产品族

具体的概念移步这里去加深理解

新需求 : 每一个课程不仅仅要有视频，还要有对应的手记，那如果按照。工厂方法的一个方式来扩展的话，我们想象一下，首先呢，前端手记。Java手记，不同课程的手记他们之间呢也是各具特色，那如果按照工厂方法现在的扩展要求来说，我们要创建 每个前端的手记类Java的手记类，前端手记的工厂，Java手记的工厂，同时呢，我们还要创建手记的抽象类，还有手记抽象工厂，那在工厂方法中，如果我们的业务场景发生了比较大的扩展，很容易发生类爆炸。 原来一个视频就是一个课程。而现在一个视频加一个手记是一个课程。
我们来分析一下Java视频,前端视频，他们属于同一产品等级都是视频，
前端手记Java手记 他们处于同一产品等级,
手记Java视频和Java手记他们处于同一产品族
具体需求出来的我们写代码

	/**
 * 产品族类
 * @return
 */
public interface CourseFactory {

    //获取视频
    Video getVideo();
    //获取手记
    Article getArticle();

}
/**
 * 手记类 
 */
public abstract class Article {
    /**
     * 生产手记
     */
    public abstract void produce();
}
 /**
 * 视频类
 */
public abstract class Video {
    /**
     * 生产视频
     */
    public abstract void produce();

}
/**
 * java手记类 
 */
public class JavaArticle extends Article {
    @Override
    public void produce() {
        System.out.println("编写Java课程手记");
    }
}
public class JavaCourseFactory implements CourseFactory {

    @Override
    public Video getVideo() {
        return new JavaVideo();
    }

    @Override
    public Article getArticle() {
        return new JavaArticle();
    }
} 
/**
 * java视频类 
 */
public class JavaVideo extends Video {
    @Override
    public void produce() {
        System.out.println("录制Java课程视频");
    }
}
test 
 public static void main(String[] args) {
        CourseFactory courseFactory = new JavaCourseFactory();
        Video video = courseFactory.getVideo();
        Article article = courseFactory.getArticle();
        video.produce();
        article.produce();
    }
 

我们应用层不关心具体的什么视频,手记之类,我只关心我从哪个工厂里边拿它对应的产品就可以了，我从Java课程工厂里面获取到一整个产品族就ok
我们看一下类图


总结 : 工厂方法关注产品等级结构，抽象工厂关注产品。是这两个设计模式最大的一个区别，
那抽象工厂呢还是非常有威力的，它能帮助我们针对抽象编程，而不是针对具体的类来变成那抽象工厂
如果碰到频繁改动，不适用于抽象工厂，比如说,课程里边再加一个源码。明天还要加个东西，后天还要加个东西，那这个呢真的是太频繁了，那这个类要经常经常改这些抽象工厂相关的类，我们平时找相对固定的