一. 设计模式-工厂模式
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]));
}
}
