
2020-09-04 2997

2020-09-05 254

2020-09-17 218

2020-09-16 158

2020-09-15 153
抽象工厂模式应该如何理解原理? 根据我的理解可以分为已下几个关注点: 1.抽象工厂—定义生产的抽象产品,一般为一个产品族 2.具体工厂—实现抽象工厂,一般用于获取每个类型的产品 3.抽象产品—抽象产品类型并集为一个产品族 4.具体产品—抽象产品的具体实现 使用场景:某家服饰公司要生产鞋、衣服、裤子等服装,服装又分婴儿、儿童、成人,请问应该如何设计? 下面是我的设计思路,
装饰者模式应该如何理解原理? 根据我的理解可以分为已下几个关注点: 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()); } 难点:为什么 价格!=上个对象+装饰对象的价格 我们可以理解为最终装饰对象=被装饰对象+所有装饰对象的组合
//静态代理设计实现 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(); } 缺点:需要为每个代理类实现接口
单例模式分为两种,饿汉式与懒汉式 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; } }