抽象工厂模式应该如何理解原理? 根据我的理解可以分为已下几个关注点： 1.抽象工厂—定义生产的抽象产品,一般为一个产品族 2.具体工厂—实现抽象工厂，一般用于获取每个类型的产品 3.抽象产品—抽象产品类型并集为一个产品族 4.具体产品—抽象产品的具体实现 使用场景：某家服饰公司要生产鞋、衣服、裤子等服装，服装又分婴儿、儿童、成人，请问应该如何设计？ 下面是我的设计思路，
Rick
163
0
2020-10-11
阅读全文
装饰者模式应该如何理解原理? 根据我的理解可以分为已下几个关注点： 1.被装饰的抽象对象—最终装饰成什么样的一个组合体 2.被装饰对象的实现—以该抽象实例为基础与其他装饰对象为一体 3.抽象装饰器—构造参数必须传入装饰对象，所有的装饰类基础该抽象装饰器 4.装饰器对象的实现—装饰对象为被装饰对象增强功能 /被装饰抽象对象:饮料
interface Drink {
//价格
public Integer price();
//名称
public String name();
//描述
public String desc();
}
//被装饰对象实现:咖啡
class Coffer implements Drink {
private Integer price = 10;
private String name = "普通咖啡";
@Override
public Integer price() {
return price;
}
@Override
public String name() {
return name;
}
@Override
public String desc() {
return String.format("[%s] 价格:%d", name(), price());
}
}
//抽象装饰器
abstract class Decoeator implements Drink {
protected Drink drink;
public Decoeator(Drink drink) {
this.drink = drink;
}
}
//牛奶装饰器
class MilkDecoeator extends Decoeator {
private Integer price = 5;
private String name = "牛奶";
public MilkDecoeator(Drink drink) {
super(drink);
}
@Override
public Integer price() {
return super.drink.price() + price;
}
@Override
public String name() {
return super.drink.name() + " + " + name;
}
@Override
public String desc() {
return String.format("[%s] 价格:%d", name(), price());
}
}
class Sugar extends Decoeator {
private Integer price = 1;
private String name = "糖";
public Sugar(Drink drink) {
super(drink);
}
@Override
public Integer price() {
return super.drink.price() + price;
}
@Override
public String name() {
return super.drink.name() + " + " + name;
}
@Override
public String desc() {
return String.format("[%s] 价格:%d", name(), price());
}
}
class Banana extends Decoeator {
private Integer price = 3;
private String name = "香蕉";
public Banana(Drink drink) {
super(drink);
}
@Override
public Integer price() {
return super.drink.price() + price;
}
@Override
public String name() {
return super.drink.name() + " + " + name;
}
@Override
public String desc() {
return String.format("[%s] 价格:%d", name(), price());
}
} 测试: public static void main(String[] args) {
Drink drink = new Coffer();
System.out.println(drink.desc());
drink = new MilkDecoeator(drink);
System.out.println(drink.desc());
drink = new Sugar(drink);
System.out.println(drink.desc());
drink = new Banana(drink);
System.out.println(drink.desc());
} 难点：为什么 价格！=上个对象+装饰对象的价格 我们可以理解为最终装饰对象=被装饰对象+所有装饰对象的组合
Rick
139
0
2020-09-26
阅读全文
//静态代理设计实现
interface UserService {
public void update();
}
class UserImpl implements UserService {
@Override
public void update() {
System.out.println("修改用户..");
}
}
class UserProxy implements UserService {
UserService userService;
public UserProxy(UserService userService) {
this.userService = userService;
}
@Override
public void update() {
//操作之前拓展逻辑
userService.update();
//操作之后拓展逻辑
}
} 运行: public static void main(String[] args) {
UserProxy proxy = new UserProxy(new UserImpl());
proxy.update();
} 缺点：需要为每个代理类实现接口
Rick
136
0
2020-09-26
阅读全文
单例模式分为两种，饿汉式与懒汉式 1.饿汉式，随着类加载时被完成初始化，缺点是有可能浪费资源 class SingletonLazy {
//懒汉式直接创建对象
private static SingletonLazy singletonLazy = new SingletonLazy();
private static SingletonLazy getInstance() {
return singletonLazy;
}
}
2.懒汉式，懒汉式双重校验锁（线程安全） class SingletonHungry {
//加volatile关键字是防止指令重排
private static volatile SingletonHungry singletonHungry;
private static SingletonHungry getInstance() {
//这一步是减少不必要的加锁损耗资源
if (singletonHungry == null) {
synchronized (SingletonHungry.class) {
//这一步是第一个线程进来加锁进行对象的初始化
if (singletonHungry == null) {
singletonHungry = new SingletonHungry();
}
}
}
return singletonHungry;
}
}
Rick
155
0
2020-09-26
阅读全文
