1.简单工厂模式

interface Product {
    public void setName();
}
class ProductA implements Product {
    @Override
    public void setName() {
        System.out.println("set name ProductA");
    }
}
class ProductB implements Product {
    @Override
    public void setName() {
        System.out.println("set name ProductB");
    }
}
class ProductFactory{
    public static Product createProduct(String type){
        if(type.equals("A")){
            return new ProductA();
        }
        else if(type.equals("B")){
            return new ProductB();
        }
        else{
            return null;
        }
    }
}
public class FactoryTest {
    public static void main(String[] args) {
        Product product = ProductFactory.createProduct("A");
        product.setName();
    }
}

2.工厂方法模式，让一个类的实例化延迟到子类

abstract class AbsProduct{
    abstract Product productCreat();
}
class ConCreateProductA extends AbsProduct{
    @Override
    Product productCreat() {
        return new ProductA();
    }
}
class ConCreateProductB extends AbsProduct{
    @Override
    Product productCreat() {
        return new ProductB();
    }
}
public class FactoryTest {
    public static void main(String[] args) {
        Product product = ProductFactory.createProduct("A");
        product.setName();
        AbsProduct absProduct = new ConCreateProductA();
        Product product1 = absProduct.productCreat();
        product1.setName();
    }
}

应用场景
1.当你不知道改使用对象的确切类型的时候
2.当你希望为库或框架提供扩展其内部组件的方法时

主要优点：
1.将具体产品和创建者解耦
2.符合单一职责原则
3.符合开闭原则

源码中的应用：
1//javaapi
2//静态工厂方法
3Calendar.getInstance()
4java.text.NumberFormat.getInstance()
5java.util.ResourceBundle.getBundle()
6//工厂方法
7java.net.URLStreamHandlerFactory10javax.xml.bind.JAXBContext.createMarshaller

3.抽象工厂模式

抽象工厂模式定义:提供一个创建一系列相关或互相依赖对象的接口，而无需指定它们具体的类，注意，千万别误以为抽象工厂就必须要和abstract抽象类有关系。
其实就是定义一组接口由不同的产品去实现。如下面定义了三个接口，由mysql和oracle分别去实现。
开发需求：开发一个数据库的连接组件

interface IConnection{
    void connect();
}
interface ICommand{
    void command();
}
interface IDataBaseUtil{
    IConnection getConnection();
    ICommand getCommand();
}
class MysqlConnection implements IConnection{
    @Override
    public void connect() {
        System.out.println("Mysql connected");
    }
}
class MysqlCommand implements ICommand{
    @Override
    public void command() {
        System.out.println("Mysql command");
    }
}
class MysqlDataBaseUtil implements IDataBaseUtil{
    @Override
    public IConnection getConnection() {
        return new MysqlConnection();
    }
    @Override
    public ICommand getCommand() {
        return new MysqlCommand();
    }
}
class OracleConnection implements IConnection{
    @Override
    public void connect() {
        System.out.println("Oracle connected");
    }
}
class OracleCommand implements ICommand{
    @Override
    public void command() {
        System.out.println("Oracle command");
    }
}
class OracleDataBaseUtil implements IDataBaseUtil{
    @Override
    public IConnection getConnection() {
        return new OracleConnection();
    }
    @Override
    public ICommand getCommand() {
        return new OracleCommand();
    }
}
public class AbstractFactoryTest {
    public static void main(String[] args) {
        IDataBaseUtil iDataBaseUtil = new OracleDataBaseUtil();
        IConnection connection = iDataBaseUtil.getConnection();
        connection.connect();
        ICommand command = iDataBaseUtil.getCommand();
        command.command();
    }
}

应用场景:
程序需要处理不同系列的相关产品，但是您不希望它依赖于这些产品的具体类时，可以使用抽象工厂

优点:
1.可以确信你从工厂得到的产品彼此是兼容的。
2.可以避免具体产品和客户端代码之间的紧密耦合。
3.符合单一职责原则
4.符合开闭原则

JDK源码中的应用:
1java.sql.Connection
2java.sql.Driver