设计模式-工厂、装饰模式

一. 设计模式-工厂模式

package com.factory.pattern;


/**
    目标：工厂模式。

    什么是工厂设计模式？
            工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。
            这种类型的设计模式属于创建型模式，它提供了一种创建对象的方式。
            之前我们创建类对象时, 都是使用new对象的形式创建, 除new对象方式以外,
            工厂模式也可以创建对象。

    工厂设计模式的作用：
            1.对象通过工厂的方法创建返回，工厂的方法可以为该对象进行加工和数据注入。
            2.可以实现类与类之间的解耦操作（核心思想，重点）

    小结：
        工厂模式的思想是提供一个工厂方法返回对象！
 */
public class FactoryDemo {
    public static void main(String[] args) {
        Computer c1 = FactoryPattern.createComputer("Huawei");
        c1.start();

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

package com.factory.pattern;

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

    public abstract void start();


    public Computer() {
    }

    public Computer(String name, double price) {
        this.name = name;
        this.price = price;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return price
     */
    public double getPrice() {
        return price;
    }

    /**
     * 设置
     * @param price
     */
    public void setPrice(double price) {
        this.price = price;
    }
    
    @Override
    public String toString() {
        return "Computer{name = " + name + ", price = " + price + "}";
    }
}

package com.factory.pattern;

public class Huawei extends Computer {
    @Override
    public void start() {
        System.out.println(getName() + "开机了,展示了华为的菊花LOGO");
    }
}

package com.factory.pattern;

public class Mac extends Computer{
    @Override
    public void start() {
        System.out.println(getName() + "以非常优雅的方式启动了,展示了一个苹果的LOGO");
    }
}

package com.factory.pattern;

/**
   工厂模式
 */
public class FactoryPattern {
    /**
       定义一个方法,创建对象返回
     */
    public static Computer createComputer(String info){
        switch(info){
            case "Huawei":
                Computer c1 = new Huawei();
                c1.setName("Huawei Pro 16");
                c1.setPrice(6999);
                return c1;
            case "Mac":
                Computer c2 = new Mac();
                c2.setName("MacBook Pro");
                c2.setPrice(11999.9);
                return c2;
            default:
                return null;
        }
    }
}

 二. 设计模式-装饰模式

package com.decorator.pattern;

/**
   定义共同父类
 */
public abstract class InputStream {
    // 每次读一个字节
    public abstract int read();
    // 每次读一个字节数组
    public abstract int read(byte buffer[]);
}

 

package com.decorator.pattern;

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;
    }
}

package com.decorator.pattern;

/**
   定义装饰类,继承父类InputStream,包装原始类,扩展 / 增强原始类的功能
 */
public class BufferedInputStream extends InputStream{
    private InputStream is;
    public BufferedInputStream(InputStream is){
        this.is = is;
    }
    @Override
    public int read() {
        System.out.println("提供8KB的缓冲区,提高读数据性能~~~");
        return is.read();
    }

    @Override
    public int read(byte[] buffer) {
        System.out.println("提供8KB的缓冲区,提高读数据性能~~~");
        return is.read(buffer);
    }
}

package com.decorator.pattern;

/**
  装饰模式:

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