极客996

极客996

  • 22文章
  • 1评论
  • 1080文章浏览

Java设计模式——抽象工厂模式

抽象工厂模式应该如何理解原理? 根据我的理解可以分为已下几个关注点: 1.抽象工厂—定义生产的抽象产品,一般为一个产品族 2.具体工厂—实现抽象工厂,一般用于获取每个类型的产品 3.抽象产品—抽象产品类型并集为一个产品族 4.具体产品—抽象产品的具体实现 使用场景:某家服饰公司要生产鞋、衣服、裤子等服装,服装又分婴儿、儿童、成人,请问应该如何设计? 下面是我的设计思路,

Rick  24  2020-10-11 阅读全文

Java设计模式——装饰器模式

装饰者模式应该如何理解原理? 根据我的理解可以分为已下几个关注点: 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  44  2020-09-26 阅读全文

Java设计模式——静态代理模式

//静态代理设计实现
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  33  2020-09-26 阅读全文

Java设计模式——单例模式

单例模式分为两种,饿汉式与懒汉式 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  47  2020-09-26 阅读全文