JAVA之工厂模式、装饰模式

什么是工厂设计模式？

• 之前我们创建类对象时，都是使用new 对象的形式创建，在很多业务场景下也提供了不直接new的方式。
• 工厂模式（Factory Pattern） 是Java中最常用的设计模式之一，这种类型的设计模式属于创建型模式，它提供了一种获取对象的方式。

工厂设计模式的作用：

• 工厂的方法可以封装对象的创建细节，比如：为该对象进行加工和数据注入。
• 可以实现类与类之间的解耦操作（核心思想）。

 简单的小案例（模拟卖/查电脑）：

电脑类：

public abstract class Computer {
    private String name;
    private double price;

    public abstract void start();

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }
}

两个不同类型电脑启动类： 

public class HuaWei extends Computer{
    @Override
    public void start() {
        System.out.println(getName()+"开机了。。");
    }
}

public class Mac extends Computer{

    @Override
    public void start() {
        System.out.println(getName()+"启动了。。");
    }
}

简单模拟工厂类：

public class FactoryPattern {
    //定义一个方法，创建对象返回
    public static Computer createComputer(String info){
        switch(info){
            case "Mac":
                Computer c1=new Mac();
                c1.setName("MacBook pro");
                c1.setPrice(10000);
                return c1;
            case "HuaWei":
                Computer c2=new HuaWei();
                c2.setName("HuaWei pro");
                c2.setPrice(9999);
                return c2;
            default:
                return null;
        }
    }
}

 主类：

public class Text {
    public static void main(String[] args) {
        Computer c1=FactoryPattern.createComputer("HuaWei");
        c1.start();

        Computer c2=FactoryPattern.createComputer("Mac");
        c2.start();

        //运行结果：
        // HuaWei pro开机了。。
        //MacBook pro启动了。。

    }
}

 什么是装饰设计模式？

创建一个新类，包装原始类，从而在新类中提升原来类的功能。

装饰设计模式的作用：

装饰模式指的是在不改变原类的基础上，动态的扩展一个类的功能。

简单小案例（模拟IO流）：

主类：

/*
装饰模式：

定义父类：InputStream
定义实现类：FileInputStream 继承父类，定义功能
定义装饰实现类：BufferedInputStream 继承父类，定义功能，包装原始类，增强功能
 */
public class Text {
    public static void main(String[] args) {
        InputStream is =new BufferedInputStream(new FileInputStream());
        System.out.println(is.read());
        System.out.println(is.read(new byte[3]));

       //运行结果：
        // 提供缓冲区，提高读取性能。
        //以低性能的形式读取了一个字节a
        //97
        //提供缓冲区，提高读取性能
        //以低性能的方式读取了一个字节数组：[97, 98, 99]
        //3
    }
}

共同父类： 

//共同父类
public abstract class InputStream {
    public abstract int read();
    public abstract int read(byte[] buffer);

}

原始类： 

import java.util.Arrays;
//原始类
public class FileInputStream extends InputStream{
    @Override
    public int read() {
        System.out.println("以低性能的形式读取了一个字节a");
        return 97;
    }

    @Override
    public int read(byte[] buffer) {
        buffer[0]=97;
        buffer[1]=98;
        buffer[2]=99;
        System.out.println("以低性能的方式读取了一个字节数组："+ Arrays.toString(buffer));
        return 3;
    }
}

装饰类：

//装饰类：继承InputStream，拓展原始类的功能
public class BufferedInputStream extends InputStream{
    private InputStream is;

    public BufferedInputStream(InputStream is) {
        this.is=is;
    }

    @Override
    public int read() {
        System.out.println("提供缓冲区，提高读取性能。");
        return is.read();
    }

    @Override
    public int read(byte[] buffer) {
        System.out.println("提供缓冲区，提高读取性能");
        return is.read(buffer);
    }
}