##工厂
简单工厂模式：
这种类型的设计模式属于创建型模式，他提供了一种创建对象的最佳方式。
实例化对象的时候不再使用new Object()形式，可以根据用户的选择条件来实例化相关的类。对于客户端来说，去除了具体的类的依赖，只需要给出具体实例的描述给工厂
，工厂就会自动返回具体的实例对象
package gongchang;
//定义一个接口：
public interface ICourse {
public double getResult(double numberA,double numberB)throws Exception;
}
package gongchang;
//定义聚体的操作类
public class PythonCourse implements ICourse{
public double getResult(double numberA,double numberB){
return numberA+numberB;
}
}
package gongchang;
//定义具体的操作类
public class JavaCourse implements ICourse{
public double getResult(double numberA,double numberB){
return numberA-numberB;
}
}
package gongchang;
/*public class ICourseFactory {
//简单工厂,根据字符串创建相应的对象
public static ICourse createICourse(String name){
ICourse a=null;
switch(name){
case "+":
a=new PythonCourse();
break;
case "-":
a=new JavaCourse();
break;
}
return a;
}
}*/
public class ICourseFactory{
private static ICourse a=null;
private static ICourse add(){
System.out.println("加法运算");
return new PythonCourse();
}
private static ICourse sub(){
System.out.println("减法运算");
return new JavaCourse();
}
//简单工厂，根据字符串创建相应的对象
public static ICourse createICourse(String name){
switch(name){
case "+":
a=add();
break;
case "-":
a=sub();
break;
}
return a;
}
}
这样做的优点：我们可以对创建的对象进行一些“加工”，而且用户端并不知道，因为工厂隐藏了这些细节。如果没有工厂的话，那我们是不是
就得自己在客户端写这些代码，这就好比本来可以在工厂的生产的东西，拿来自己手工制作，不仅麻烦以后还不好维护
这样做的缺点：如果需要在方法里写很多与对象创建有关的业务代码，而且需要的创建对象还不少的话，我们要在这个简单的工厂类编写很多方法，每个方法
里都得写很多相应的业务代码，而每次增加子类或者删除子类对象的创建都需要打开这简单工厂类来进行修改。这会导致这个简单的工厂类很庞大、耦合性高，而且
增加、删除某个子类对象的创建都需要打开简单工厂类来进行修改代码也违反了开闭原则
package gongchang;
//用户端代码
public class Client {
public static void main(String[] args)throws Exception{
ICourse PythonCourse=ICourseFactory.createICourse("+");
ICourse JavaCourse=ICourseFactory.createICourse("-");
System.out.println(PythonCourse.getResult(1,1));
System.out.println(JavaCourse.getResult(1,2));
}
}
我们无需提供具体的子类类名，只需要提供一个字符串即可得到相应的实例对象。这样的话，当子类的类名更换或者增加子类时我们都无需修改
客户端代码，只需要在简单工厂类上增加一个分支判断代码即可。
使用这种模式，我们在生成工厂的时候可以加一些业务代码，如日志、判断业务等，这时候可以直接在switch case中加上去就行
工厂模式：
package com.gongchang01;
//定义一个接口
import gongchang.ICourse;
public interface Factory {
public ICourse createICourse();
}
package com.gongchang01;
import gongchang.ICourse;
import gongchang.JavaCourse;
import gongchang.PythonCourse;
//加法工厂
public class AddFactory implements Factory{
public ICourse createICourse(){
System.out.println("加法运算");
return new PythonCourse();
}
}
package com.gongchang01;
import gongchang.ICourse;
import gongchang.JavaCourse;
public class SubFactory implements Factory{//减法工厂
public ICourse createICourse(){
System.out.println("减法运算");
return new JavaCourse();
}
}
package com.gongchang01;
import gongchang.ICourse;
public class Client {
public static void main(String[] args)throws Exception{
//使用反射机制实例化工厂对象，因为字符串可以通过变量改变
Factory addFactory=(Factory) Class.forName("com.gongchang01.AddFactor").newInstance();
Factory subFactory=(Factory) Class.forName("com.gongchang01.SubFactory").newInstance();
//通过工厂对象创建相应的实例对象
ICourse add=addFactory.createICourse();
ICourse sub=subFactory.createICourse();
System.out.println(add.getResult(1,1));
System.out.println(sub.getResult(1,2));
}
}
比较
工厂模式中，要增加产品类时也要相应地增加工厂类，客户端的代码也增加不少。工厂方法把简单工厂的内部逻辑判断转移到了客户端代码来进行
你想要加功能，本来是改工厂类的，而现在是修改客户端。而且各个不同的功能的实例对象的创建代码，也没有耦合在同一个工厂类里，这也是工厂方法模式对简单
工厂模式解耦的一个体现。工厂方法模式克服了简单工厂会违背开闭原则的缺点，又保持了封装对象创建过程的优点。
但是工厂方法模式的缺点是每增加一个产品类，就需要增加一个对应的工厂类，增加了额外的开发量。
