通过 new 创建对象，会使得程序面向实现编程，先举个例子，某个果园里现在有两种水果，一种是苹果，一种是香蕉，有客户想采摘园子里的水果，要求用get()方法表示即可
一般情况下，最直接的写法为：
public class Apple { public void get() { System.out.println("得到苹果"); } } public class Banana { public void get() { System.out.println("得到香蕉"); } } // 客户端 public static void one() { // 实例化一个apple Apple apple = new Apple(); // 实例化一个banana Banana banana = new Banana(); apple.get(); banana.get(); }
如上代码，一堆的水果类，必须等到运行时才能知道实例化哪一个。一旦水果类有变化或者扩展，还要重新修改客户端类，一旦代码量多了，或者系统复杂了，修改的成本是很大的。
那么可以用一种方法替代，就是工厂模式——把实例化的具体代码从应用中抽离，或者封装。工厂模式的变形比较多，本文只引申简单工厂模式。
教科书的定义：
简单工厂模式属于类的创建型模式，也叫静态工厂方法模式。它通过专门定义一个类来负责创建其他类的实例，目的是为了隐藏具体类的对象的创建过程，既不耽误对象的创建，也隐藏了创建过程，被创建的实例通常都具有共同父类
继续看水果的例子，后来果园有了新需求——用采摘到的水果做果汁，要求使用 doJuice(对应的水果)生产果汁。水果类的代码可以保持不变，客户端新加的其他代码如下：
// 客户端 private static void doJuice(Apple apple) { apple.get(); System.out.println("做成果汁"); } private static void doJuice(Banana banana) { banana.get(); System.out.println("做成果汁"); } public static void one() { // 实例化一个apple Apple apple = new Apple(); // 实例化一个banana Banana banana = new Banana(); doJuice(apple); doJuice(banana); }
随着业务发展，后来果园又引进了大量新水果，比如橘子，西瓜，柿子，荔枝，葡萄，哈密瓜，火龙果等。如果继续用之前的代码，那么除了必须新加水果类之外，在客户端里还要分别为每一类水果添加对应的doJuice（水果）方法，然而水果那么多……使得代码的维护性，稳定性变差
为了增加程序的灵活性，可以做一些抽象，即把各个具体的水果都抽象化，可以选择抽象类或者接口去实现，现在要创建不带任何方法定义和成员变量的抽象化的类，首选的应该是接口
如图1所示，接口有扩展能力，也就是旧的接口能 extends 新接口，从而使得代码的扩展行为是可行的
使用接口的另一个原因和抽象类一样，都是为了避免某个类被实例化，可以告诉编译器，以及一起协作开发的程序员，这个类不需要实例化，它只是为了对某些行为做出规范，谁想用，谁就去遵守这个规则即可。
public interface Fruit { void get(); } public class AppleA implements Fruit { @Override public void get() { System.out.println("苹果"); } } public class BananaA implements Fruit { @Override public void get() { System.out.println("香蕉"); } } // 客户端 private static void doJuiceB(Fruit fruit) { // Fruit 是接口，只需要一个方法 doJuiceB fruit.get(); System.out.println("做成果汁"); } private static void two() { // 使用接口的引用指向子类的对象，向上转型过程，用到了多态 Fruit apple = new AppleA(); Fruit banana = new BananaA(); Fruit orange = new OrangeA(); doJuiceB(apple); doJuiceB(banana); doJuiceB(orange); }
综上，接口的作用可以概括为两个：
1、避免客户端去实例化某个类
2、向上转型的使用（多态）
继续看这个例子，客户只是想把果园采摘的水果做出果汁，客户作为调用者，只需要水果去做出果汁，而水果具体怎么得到的，其实客户不需要也没必要关心，调用者没必要为了喝果汁还花代价去亲自采摘水果……
之前的设计，客户端有一个传入接口类型参数的 doJuiceB(Fruit fruit); 方法。客户端调用该方法可以动态的做出不同水果的果汁，现在把采集水果的代码单独放到一个类里，隐藏起来，分离变化的部分，我们叫它工厂类，下面是代码实现。
// 工厂生产水果 // 对于客户端来说，不再直接简单粗暴的 new 一个水果的实例，而是把生成水果的实例的过程放到一个单独的类，把这个实例化的过程隐藏了起来……我们叫它工厂类 public class FruitFactory { public static FruitC getApple() { return new AppleC(); } public static FruitC getBanana() { return new BananaC(); } } // 客户端 private static void doJuice(FruitC fruit) { fruit.get(); System.out.println("做成果汁"); } private static void three() { FruitC apple = FruitFactory.getApple(); FruitC banana = FruitFactory.getBanana(); doJuice(apple); doJuice(banana); }
简单工厂模式解决的问题是如何去实例化一个合适的对象，简单工厂模式的核心思想就是有一个专门的类来负责创建实例。具体来说，把产品看为是一系列的类的集合，这些类由某个抽象类或者接口派生出一个对象树，工厂类产生一个合适的对象来满足客户的要求，从而把对象的创建过程进行封装
如果简单工厂模式所涉及到的具体产品之间没有共同的逻辑，那么就可以使用接口来扮演抽象产品的角色，如果具体产品之间有逻辑上的联系，就把这些共同的东西提取出来，放在一个抽象类中，然后让具体产品继承抽象类，以实现代码复用，如图2所示。借用高斯林（Java之父）所说：
共同的东西总是应该抽象出来。在实际的的使用中，抽象产品和具体产品之间往往是多层次的产品结构
上面的设计，对于客户端来说，不再直接简单粗暴的 new 一个水果的实例，而是把生成水果的实例的过程放到一个单独的类，把这个实例化的过程隐藏了起来……我们叫它工厂类，这个设计也叫简单工厂模式——它解决的问题是如何去实例化一个合适的对象。
简单工厂模式的核心思想就是：有一个专门的类来负责创建实例。具体来说，把产品看着是一系列的类的集合，这些类是由某个抽象类或者接口派生出来的一个对象树，而工厂类用来产生一个合适的对象来满足客户的要求，从而把对象的创建过程进行封装，如果简单工厂模式所涉及到的具体产品之间没有共同的逻辑，那么我们就可以使用接口来扮演抽象产品的角色，如果具体产品之间有逻辑上的联系，我们就把这些共同的东西提取出来，放在一个抽象类中，然后让具体产品继承抽象类，为实现更好复用的目的，共同的东西总是应该抽象出来的。在实际的的使用中，抽象产品和具体产品之间往往是多层次的产品结构，如图：
下面看看教科书的定义：简单工厂模式属于类的创建型模式，也叫静态工厂方法模式，通过专门定义一个类来负责创建其他类的实例，目的是为了隐藏具体类的对象的创建过程，既不耽误对象的创建，也隐藏了创建过程。被创建的实例通常都具有共同父类
本例子里，苹果和香蕉都有一个共同的父类——水果，此时我们专门定义一个类，负责创建其他类的实例，这个类叫简单工厂类，它有三个角色：
1、工厂（Creator）角色 ：简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类可以被外界直接调用，创建所需的产品对象。
2、抽象产品（Product）角色： 简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口，或者抽象类。
3.具体产品（Concrete Product）角色： 简单工厂模式所创建的具体实例对象，这些对象去继承或者实现抽象角色
不过，细细体味下，在工厂类里针对每一个水果都有一个对应的获取水果的操作，这是一种很粗糙的设计，还可以更好，就是把每个get方法抽象为一个公用的get方法，代码如下：
public interface FruitD { void get(); } ////////////////////////////// public class AppleD implements FruitD { @Override public void get() { System.out.println("苹果"); } } /////////////////////////////// public class BananaD implements FruitD { @Override public void get() { System.out.println("香蕉"); } } ////////////////////////////// public class FruitFactoryFour { public static FruitD getFruit(String type) { if ("apple".equalsIgnoreCase(type)) { return new AppleD(); } else if ("banana".equalsIgnoreCase(type)) { return new BananaD(); } else { System.out.print("error!"); } return null; } }
这样稍微好了点儿，把每个水果对应的get方法抽象为一个公用的get方法，工厂类里根据传入的参数，去判断应该生成哪个水果的对象，并把这个对象返回（依然是向上转型的使用），客户端只需简单的进行调用即可。
非常方便，也隐藏了具体产品的实例化过程，完美的完成了客户和水果厂的需求。
可以认为简单工厂模式的核心是工厂类，这个类含有必要的逻辑判断（if-else），可以决定在什么时候创建哪一个类的实例，而调用者则可以免除直接创建对象的责任。简单工厂模式通过这种做法实现了对责任的分割，当系统引入新的产品的时候无需修改调用者。
虽然简单工厂模式分离了产品的创建者和消费者，有利于软件系统结构的优化，但是由于一切产品创建的业务逻辑都集中在一个工厂类中，导致了没有很高的内聚性，同时也违背了开闭原则。另外，简单工厂模式的方法一般都是静态的，而静态工厂方法让子类继承是可能被隐藏的，因此，简单工厂模式无法形成基于基类的继承树结构。
到了这里，其实又要想，不要过度的优化，不要为了使用设计模式而使用设计模式，如果是业务比较简单的场景，这样的简单工厂模式还是非常好用的。但无论如何，繁琐的if-else判断还是不太好，一旦判断条件稍微多点儿，if-else写起来就非常繁琐。
观察一些开源框架实现类似场景的代码，发现它们使用了 Java 的反射机制省去了判断的步骤，比之前的繁琐的 if-else 判断要好一些，如下代码。
public interface FruitE { void get(); } public class BananaE implements FruitE { @Override public void get() { System.out.println("香蕉"); } } public class AppleE implements FruitE { @Override public void get() { System.out.println("苹果"); } } // 新的工厂类 public class FruitFactoryFive { public static FruitE getFruit(String type) throws ClassNotFoundException, IllegalAccessException, InstantiationException { Class fruit = Class.forName(type); return (FruitE) fruit.newInstance(); } } // 客户端 private static void five() throws IllegalAccessException, InstantiationException, ClassNotFoundException { FruitE apple = FruitFactoryFive.getFruit("simpleFactory.five.AppleE"); FruitE banana = FruitFactoryFive.getFruit("simpleFactory.five.BananaE"); apple.get(); banana.get(); }
如此一来，使得工厂的扩展性变强了。
从 JVM 的角度看，使用 new 的时候，这个要 new 的类可以没有被 JVM 加载，但是使用 newInstance，就必须保证这个类已经加载且这个类已经链接，而完成这两个步骤的正是 Class 的静态方法 forName(......)，该方法调用了启动类加载器（bootstrap加载器）去加载类（不初始化）。
Class 类的对象方法 newInstance 与静态方法 forName 实际上是把 new 关键字做的事情分解为了两步：
1、加载某个类
2、初始化
这样分步调用构造器的好处是显而易见的，因为它的粒度更细，所以程序可以在实例化类的时候获得更好的灵活性，催生一些降耦手段。
事实上，Class 类的 newinstance 方法经常被各种框架使用，它是解耦合的利器之一，比如设计模式中最最常见的工厂模式。
当然，一些知名的开源框架使用了更高级的asm等字节码框架，能使反射操作的性能非常高效，并且还能修改已经编译的字节码，使得程序的灵活性变得很强。
但是依然不完美—客户端缺少调用的灵活性，客户端必须传入严格对应类名的字符串，甚至还要包含完整的包名，才能实例化对应的类，稍微差一点儿，都会失败。故还是前面说的，简单的业务一般使用if-else的方式传入字符串即可，而稍微复杂的，可以变为反射的方式实现，而反射实现工厂类，对于客户端又显得调用上不方便。一些开源框架使用了配置文件或者注解解决了该问题，现在Java世界的主流是约定优于配置，注解是主流。
String className = readConfig(); // 从配置文件中获得类的句柄 Class c = Class.forName(className); factory = (FruitE)c.newInstance();
利用配置文件消灭了写死的产品类名称，无论产品怎么变化，代码不会再修改，甚至可以更换类的子类，只要他们继承该类（实现接口）就可以。
当然进一步就是自定义注解处理器，实现自己系统的注解
JDBC是SUN公司提供的一套数据库编程接口。它能提供简单、一致的方式访问各种关系型数据库。Java通过JDBC可以执行SQL语句，并能对获取的数据进行处理，将变化了的数据存回数据库。用JDBC进行数据库访问时，要使用数据库厂商提供的驱动程序接口与DBMS进行交互。客户端要使用使用数据时，只需要和工厂交互即可，这就是典型的简单工厂模式的应用。使得程序员的代码量得到极大的简化。
操作步骤按照顺序依次为：
1、注册并加载数据库驱动，一般使用Class.forName();
2、创建与数据库的链接Connection对象
3、创建SQL语句对象preparedStatement(sql)；
4、提交SQL语句，根据实际情况使用executeQuery()或者executeUpdate()；
5、显示相应的结果
6、关闭数据库
工厂类是整个模式的关键所在，它包含必要的判断逻辑，能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象。
用户在使用时可以直接根据工厂类去创建所需的实例，而无需了解这些对象是如何创建以及如何组织的，有利于整个软件体系结构的优化
由于工厂类集中了所有实例的创建逻辑，这就直接导致一旦这个工厂出了问题，所有的客户端都会受到牵连；
由于简单工厂模式的产品基于一个共同的抽象类或者接口，这样一来，产品的种类增加的时候，即有不同的产品接口或者抽象类的时候，工厂类就需要判断何时创建何种种类的产品，这就和创建何种种类产品的产品相互混淆在了一起，违背了单一职责，导致系统丧失灵活性和可维护性。
简单工厂模式违背了“开放封闭原则”，因为当新增加一个产品的时候必须修改工厂类，相应的工厂类就需要重新编译一遍。
一句话：虽然简单工厂模式分离产品的创建者和消费者，有利于软件系统结构的优化，但由于一切逻辑都集中在一个工厂类中，导致了没有很高的内聚性，同时也违背了“开放封闭原则”。另外，简单工厂模式的方法一般都是静态的，而静态工厂方法是无法让子类继承的，因此，简单工厂模式无法形成基于基类的继承树结构
Java中有5类创建对象的方式
1、new
2、反射，Class.newInstance()或Contructor.newInstance()，其本质是一样的，都采用了反射机制
3、clone方法
4、反序列化
5、JNI
原文：https://www.cnblogs.com/kubixuesheng/p/10344427.html