java设计模式之工厂模式 java 工厂设计模式

声明：此笔记为B站up主“程序员大表哥”所授课程【23种java设计模式】个人学习笔记，仅供学习，不做他用。

二.工厂模式

工厂模式：https://www.runoob.com/design-pattern/factory-pattern.html

简介：

工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

1.工厂方法模式

模式定义:
定义一个用于创建对象的接口，让子类决定实例化哪-一个类。Factory Method使得一个类的实例化延迟到子类

应用场景
1.当你不知道改使用对象的确切类型的时候
2.当你希望为库或框架提供扩展其内部组件的方法时
主要优点:
1.将具体产品和创建者解耦
2.符合单一职责原则
3.符合开闭原则
源码中的应用:

// java api
//静态工厂方法
Calendar.getInstance()
java.text.NumberFormat.getInstance()
java.util.ResourceBundle.getBundle()
//工厂方法
java.net.URLStreamHandlerFactory
javax.xml.bind.JAXBContext.createMarshaller

代码示例：

package com.study.designpattern.factory;

public class FactoryMethod {
    public static void main(String[] args) {
//        Application app=new Application();
//        Product product=app.getObject(1);
//        product.method1();
        Application1 app=FactoryProducer.getFactory("A");
        Product product=app.getObject();
        product.method1();
    }
}
interface Product{
    public void method1();
}
class ProductA implements Product{
public void method1(){
    System.out.println("======>ProductA.method1 executed");
}
}
class ProductB implements Product{
    public void method1(){
        System.out.println("======>ProductB.method1 executed");
    }
}
//简单工厂，并不是设计模式，而是一种设计方法，使代码更灵活，增加可用性。
class SimpleFactory{
    public static Product createProduct(int type){
        switch (type){
            case 0:
                return new ProductA();
            case 1:
                return new ProductB();
            default:
                return null;
        }
    }
}
class Application{
    private Product createProduct(int type){

        return SimpleFactory.createProduct(type);
    }
        public Product getObject(int type){
        Product product=createProduct(type);
        return product;
    }
}
//工厂方法模式，符合开闭原则（对拓展开放，对修改关闭），单一职责原则
abstract class Application1{
    abstract Product createProduct();
    public Product getObject(){
        Product product=createProduct();
        return product;
    }
}
class conCreateProductA extends Application1{
    @Override
    Product createProduct() {
        return new ProductA();
    }
}
class conCreateProductB extends Application1{
    @Override
    Product createProduct() {
        return new ProductB();
    }
}

2.抽象工厂模式

抽象工程模式：https://www.runoob.com/design-pattern/abstract-factory-pattern.html
简介：

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

应用场景:
程序需要处理不同系列的相关产品，但是您不希望它依赖于这些产品的具体类时，
可以使用抽象工厂
优点:
1.可以确信你从工厂得到的产品彼此是兼容的。
2.可以避免具体产品和客户端代码之间的紧密耦合。
3.符合单一职责原则
4.符合开闭原则
代码示例：

package com.study.designpattern.factory;

public class AbstractFactoryTest {
    public static void main(String[] args) {
        IDatabaseUtils databaseUtils=new MysqlDatabase();
        IConnection connection = databaseUtils.getConnection();
        connection.Connection();
        ICommand command = databaseUtils.getCommand();
        command.Command();
    }
}
//描述：数据库有mysql，oracle，分别有不同的connection，command.
//接口声明：
interface IConnection{
   void Connection();
}
interface ICommand{
    void Command();
}
//接口实现抽象
interface IDatabaseUtils{
    IConnection getConnection();
    ICommand getCommand();
}
//抽象类实现
abstract class IDataBase{
    abstract IConnection getConnection();
    abstract ICommand getICommand();
}
//Mysql
class MysqlConnection implements IConnection{
    @Override
    public void Connection() {
        System.out.println("Mysql connected!");
    }
}
class MysqlCommand implements ICommand{
    @Override
    public void Command() {
        System.out.println("Mysql command.");
    }
}
class MysqlDatabase implements IDatabaseUtils{
    @Override
    public IConnection getConnection() {
        return new MysqlConnection();
    }

    @Override
    public ICommand getCommand() {
        return new MysqlCommand();
    }
}
class MysqlData extends IDataBase{
    @Override
    IConnection getConnection() {
        return new MysqlConnection();
    }

    @Override
    ICommand getICommand() {
        return new MysqlCommand();
    }
}
//Oracle
class OracleConnection implements IConnection{
    @Override
    public void Connection() {
        System.out.println("Oracle connected!");
    }
}
class OracleCommand implements ICommand{
    @Override
    public void Command() {
        System.out.println("Oracle command.");
    }
}
class OracleDatabase implements IDatabaseUtils{
    @Override
    public IConnection getConnection() {
        return new OracleConnection();
    }

    @Override
    public ICommand getCommand() {
        return new OracleCommand();
    }
}
class OracleData extends IDataBase{
    @Override
    IConnection getConnection() {
        return new OracleConnection();
    }

    @Override
    ICommand getICommand() {
        return new OracleCommand();
    }
}