01.DesignParttern设计模式，简单工厂，工厂方法，抽象工厂三大工厂的区别与联系

           　　　　　　　　　　　　　　　　　　　　　　工厂用来生产对象，对象具有方法和属性。

简单工厂的缺点（简单工厂并不是23中设计模式）：

工厂类的职责相对过重，增加新的产品，需要修改工厂类的判断逻辑，违背开闭原则；

JDK源码中使用的简单工厂类：

Calendar;

改进方法：能够直接通过反射去改进简单工厂的开闭原则（对扩展开放，对修改关闭）；

工厂方法：

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

适用场景：

1）：创建对象需要大量的重复代码

2）：客户端不依赖于产品类实力如何被创建，实现等细节。

3）：一个类通过子类来制定创建哪一个对象

工厂方法-优点：

用户只需要关心产品对应的工厂无需关心创建细节。

加入新产品符合开闭原则，提高可扩展性

工厂方法-缺点：

类的个数容易过多，增加复杂度。

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

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

}

public abstract class VideoFactory {

    public abstract Video getVideo();

//    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 class PythonVideoFactory extends VideoFactory {
    @Override
    public Video getVideo()
    {
        return new PythonVideo();
    }
}

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

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 class Test {
    public static void main(String[] args) {
        VideoFactory videoFactory = new PythonVideoFactory();
        VideoFactory videoFactory2 = new JavaVideoFactory();
        VideoFactory videoFactory3 = new FEVideoFactory();
        Video video = videoFactory.getVideo();
        video.produce();
    }

}

抽象工厂模式：

抽象工厂模式提供了一个创建一系列相关或者相互依赖对象的接口。

无需指定具体的类

适用场景：

客户端不依赖于产品类实例如何被创建实现等细节。

强调一系列相关的产品对象（属于同一产品族）一起使用创建对象需要大量重复代码。

提供一个产品类的库，所有产品以同样的接口出现，从而使客户端不依赖于具体实现。

抽象工厂-优点：

具体产品在应用层代码隔离，无需关心创建细节。

将一个一系列产品族统一到一起创建。

抽象工厂-缺点：

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

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

总结：

抽象工厂平时开发产品的时候要去找产品等级相对固定的。

抽象工厂模式对应的是产品族。

工厂方法模式对应的是产品等级结构。

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

}

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

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

}

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

    @Override
    public Article getArticle()

    {
        return new JavaArticle();
    }
}

public class JavaArticle extends Article {
    @Override
    public void produce()
    {
        System.out.println("编写Java课程手记");
    }
}

public class JavaArticle extends Article {
    @Override
    public void produce()
    {
        System.out.println("编写Java课程手记");
    }
}

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

    @Override
    public Article getArticle()

    {
        return new PythonArticle();
    }
}

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

public class PythonArticle extends Article {
    @Override
    public void produce()

    {
        System.out.println("编写Python课程手记");
    }
}