public interface SDCard {
//读取SD卡方法
String readSD();
//写入SD卡功能
int writeSD(String msg);
}
2、创建SD卡接口的实现类,模拟SD卡的功能:
public class SDCardImpl implements SDCard {
@Override
public String readSD() {
String msg = "sdcard read a msg :hello word SD";
return msg;
}
@Override
public int writeSD(String msg) {
System.out.println("sd card write msg : " + msg);
return 1;
}
}
3、创建计算机接口,计算机提供读取SD卡方法:
public interface Computer {
String readSD(SDCard sdCard);
}
4、创建一个计算机实例,实现计算机接口,并实现其读取SD卡方法:
public class ThinkpadComputer implements Computer {
@Override
public String readSD(SDCard sdCard) {
if(sdCard == null)throw new NullPointerException("sd card null");
return sdCard.readSD();
}
}
5、这时候就可以模拟计算机读取SD卡功能:
public class ComputerReadDemo {
public static void main(String[] args) {
Computer computer = new ThinkpadComputer();
SDCard sdCard = new SDCardImpl();
System.out.println(computer.readSD(sdCard));
}
}
二、接下来在不改变计算机读取SD卡接口的情况下,通过适配器模式读取TF卡:
1、创建TF卡接口:
public interface TFCard {
String readTF();
int writeTF(String msg);
}
2、创建TF卡实例:
public class TFCardImpl implements TFCard {
@Override
public String readTF() {
String msg ="tf card reade msg : hello word tf card";
return msg;
}
@Override
public int writeTF(String msg) {
System.out.println("tf card write a msg : " + msg);
return 1;
}
}
3、创建SD适配TF (也可以说是SD兼容TF,相当于读卡器):
实现SDCard接口,并将要适配的对象作为适配器的属性引入。
public class SDAdapterTF implements SDCard {
private TFCard tfCard;
public SDAdapterTF(TFCard tfCard) {
this.tfCard = tfCard;
}
@Override
public String readSD() {
System.out.println("adapter read tf card ");
return tfCard.readTF();
}
@Override
public int writeSD(String msg) {
System.out.println("adapter write tf card");
return tfCard.writeTF(msg);
}
}
4、通过上面的例子测试计算机通过SD读卡器读取TF卡:
public class ComputerReadDemo {
public static void main(String[] args) {
Computer computer = new ThinkpadComputer();
SDCard sdCard = new SDCardImpl();
System.out.println(computer.readSD(sdCard));
System.out.println("====================================");
TFCard tfCard = new TFCardImpl();
SDCard tfCardAdapterSD = new SDAdapterTF(tfCard);
System.out.println(computer.readSD(tfCardAdapterSD));
}
}
输出:
sdcard read a msg :hello word SD
====================================
adapter read tf card
tf card reade msg : hello word tf card
private static Hashtable<String, Shape> shapeMap = new Hashtable<String, Shape>();//维护一个注册表
public static void loadCache() {
Circle circle = new Circle();
circle.setId("1");
shapeMap.put(circle.getId(),circle);
Square square = new Square();
square.setId("2");
shapeMap.put(square.getId(),square);
Rectangle rectangle = new Rectangle();
rectangle.setId("3");
shapeMap.put(rectangle.getId(),rectangle);
}
public static Shape getShape(String shapeId) {//提供一个获取新实例的方法
Shape cachedShape = shapeMap.get(shapeId);//提供一个找出正确实例原型的方法
return (Shape) cachedShape.clone();//委托复制实例的方法生成新实例。
}
2251建造者模式
步骤 7可以拆开吧?
抽象建造者 1
public class Builder {
public Meal meal = new Meal();
public void prepareVegMeal(){};
public void prepareNonVegMeal(){};
public Meal getMeal(){return null;
};
指挥者 2
public class Director {
public void Constuct(Builder builder){
builder.prepareVegMeal();
builder.prepareNonVegMeal();
}
}
具体的建造者
public class VegMealBuilder extends Builder{
public void prepareVegMeal() {
meal.addItem(new VegBurger());
meal.addItem(new Coke());
}
public void prepareNonVegMeal() { }
public Meal getMeal() {
return meal;
}
}
具体建造者
public class NonVegMealBuilder extends Builder {
@Override
public void prepareVegMeal() { }
@Override
public void prepareNonVegMeal() {
meal.addItem(new ChickenBurger());
meal.addItem(new Pepsi());
}
@Override
public Meal getMeal() {
return meal;
}
}
调用
public class Test {
@Test
public void BuilderPatternDemo() {
Director director = new Director();
VegMealBuilder b1 = new VegMealBuilder();
NonVegMealBuilder b2 = new NonVegMealBuilder();
director.Constuct(b1);
director.Constuct(b2);
Meal vegMeal = b1.getMeal();
System.out.println("Veg Meal");
vegMeal.showItems();
System.out.println("Total Cost: " +vegMeal.getCost());
Meal nonVegMeal = b2.getMeal();
System.out.println("\n\nNon-Veg Meal");
nonVegMeal.showItems();
System.out.println("Total Cost: " +nonVegMeal.getCost());
}
}
public abstract class Builder {
public abstract void buildPart1();
public abstract void buildPart2();
public abstract void buildPart3();
}
监工角色:
public class Director { // 将一个复杂的构建过程与其表示相分离
private Builder builder; // 针对接口编程,而不是针对实现编程
public Director(Builder builder) {
this.builder = builder;
}
public void setBuilder(Builder builder) {
this.builder = builder;
}
public void construct() { // 控制(定义)一个复杂的构建过程
builder.buildPart1();
for (int i = 0; i < 5; i++) { // 提示:如果想在运行过程中替换构建算法,可以考虑结合策略模式。
builder.buildPart2();
}
builder.buildPart3();
}
}
具体的建造者角色:
/**
* 此处实现了建造纯文本文档的具体建造者。
* 可以考虑再实现一个建造HTML文档、XML文档,或者其它什么文档的具体建造者。
* 这样,就可以使得同样的构建过程可以创建不同的表示
*/
public class ConcreteBuilder1 extends Builder {
private StringBuffer buffer = new StringBuffer();//假设 buffer.toString() 就是最终生成的产品
@Override
public void buildPart1() {//实现构建最终实例需要的所有方法
buffer.append("Builder1 : Part1\n");
}
@Override
public void buildPart2() {
buffer.append("Builder1 : Part2\n");
}
@Override
public void buildPart3() {
buffer.append("Builder1 : Part3\n");
}
public String getResult() {//定义获取最终生成实例的方法
return buffer.toString();
}
}
客户角色:
public class Client {
public void testBuilderPattern() {
ConcreteBuilder1 b1 = new ConcreteBuilder1();//建造者
Director director = new Director(b1);//监工
director.construct();//建造实例(监工负责监督,建造者实际建造)
String result = b1.getResult();//获取最终生成结果
System.out.printf("the result is :%n%s", result);
}
}
public class OrderBuilder{
private Burger mBurger;
private Suit mSuit;
//单点汉堡,num为数量
public OrderBuilder burger(Burger burger, int num){
mBurger = burger;
}
//点套餐,实际中套餐也可以点多份
public OrderBuilder suit(Suit suit, int num){
mSuit = suit;
}
//完成订单
public Order build(){
Order order = new Order();
order.setBurger(mBurger);
order.setSuit(mSuit);
return order;
}
}
public Request build() {
if (url == null) throw new IllegalStateException("url == null");
return new Request(this);
}
例如订单要求价格至少达到 30 块:
//完成订单
public Order build(){
Order order = new Order();
order.setBurger(mBurger);
order.setSuit(mSuit);
if(order.getPrice() < 30){
throw new BuildException("订单金额未达到30元");
}
return order;
}
2253适配器模式
分享一个例子:笔记本通过读卡去读取TF卡;
一、先模拟计算机读取SD卡:
1、先创建一个SD卡的接口:
2、创建SD卡接口的实现类,模拟SD卡的功能:
3、创建计算机接口,计算机提供读取SD卡方法:
4、创建一个计算机实例,实现计算机接口,并实现其读取SD卡方法:
5、这时候就可以模拟计算机读取SD卡功能:
二、接下来在不改变计算机读取SD卡接口的情况下,通过适配器模式读取TF卡:
1、创建TF卡接口:
2、创建TF卡实例:
3、创建SD适配TF (也可以说是SD兼容TF,相当于读卡器):
实现SDCard接口,并将要适配的对象作为适配器的属性引入。
4、通过上面的例子测试计算机通过SD读卡器读取TF卡:
输出:
在这种模式下,计算机并不需要知道具体是什么卡,只需要负责操作接口即可,具体操作的什么类,由适配器决定。
2252原型模式
原型模式中有三个登场角色:
原型角色:定义用于复制现有实例来生成新实例的方法;
具体原型角色:实现用于复制现有实例来生成新实例的方法
使用者角色:维护一个注册表,并提供一个找出正确实例原型的方法。最后,提供一个获取新实例的方法,用来委托复制实例的方法生成新实例。
2251建造者模式
步骤 7可以拆开吧?
抽象建造者 1
指挥者 2
具体的建造者
具体建造者
调用
最后应该是优化成 list(含有多参数)传入,上层组装meal套餐或者单点,这种灵活性更强吧。
2250建造者模式
建造者模式,又称生成器模式:将一个复杂的构建与其表示相分离,使得同样的构建过程可以创建不同的表示。
三个角色:建造者、具体的建造者、监工、使用者(严格来说不算)
建造者角色:
监工角色:
具体的建造者角色:
客户角色:
2249建造者模式
建造者模式举例:去肯德基点餐,我们可以认为点餐就属于一个建造订单的过程。我们点餐的顺序是无关的,点什么东西也是没有要求的,可以单点,也可以点套餐,也可以套餐加单点,但是最后一定要点确认来完成订单。
另外适用于快速失败,在 build 时可以做校验,如果不满足必要条件,则可以直接抛出创建异常,在 OkHttp3 中的 Request.Builder 中就是这样用的。
例如订单要求价格至少达到 30 块:
另外,在构建时如果有必传参数和可选参数,可以为 Builder 类添加构造函数来保证必传参数不会遗漏,例如在构建一个 http 请求时, url 是必传的: