栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

JAVA知识体系之设计模式篇

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

JAVA知识体系之设计模式篇

目录
  • 1、设计原则
    • 1.1 开闭原则
    • 1.2 单一职责原则
    • 1.3 里式替换原则
    • 1.4 接口隔离原则
    • 1.5 最小知道原则(迪米特法则)
    • 1.6 依赖倒置原则
  • 2、单例模式
    • 2.1 饿汉模式
    • 2.2 懒汉模式
    • 2.3 加锁懒汉模式
    • 2.4 双重检查锁
    • 2.5 静态内部类
    • 2.6 枚举
  • 3、工厂模式
    • 3.1 简单工厂模式
    • 3.2 工厂方法模式
  • 4、代理模式
    • 4.1 静态代理
    • 4.2 动态代理
      • 4.2.1 JDK动态代理
      • 4.2.2 CGLIB动态代理
  • 5、策略模式
  • 6、模板方法模式
  • 7、原型模式
  • 8、责任链模式
  • 9、委派模式
  • 10、装饰器模式
  • 11、观察者模式

1、设计原则 1.1 开闭原则

  一个软件实体如类、模块和函数应该对扩展开放,对修改关闭。以书店卖书为例:

public interface IBook {

    String getName();

    int getPrice();

    String getAuthor();
}
public class NovelBook implements IBook {

    private String name;

    private int price;

    private String author;


    @Override
    public String getName() {
        return this.name;
    }

    @Override
    public int getPrice() {
        return this.price;
    }

    @Override
    public String getAuthor() {
        return this.author;
    }

    public NovelBook(String name, int price, String author) {
        this.name = name;
        this.price = price;
        this.author = author;
    }
}
public class BookStore {

    private final static List bookList = new ArrayList<>();

    static {
        bookList.add(new NovelBook("《天龙八部》", 100, "金庸"));
        bookList.add(new NovelBook("《巴黎圣母院》", 200, "雨果"));
        bookList.add(new NovelBook("《悲惨世界》", 300, "雨果"));
        bookList.add(new NovelBook("《金瓶梅》", 400, "兰陵笑笑生"));
    }

    public static void main(String[] args) {
        NumberFormat numberFormat = NumberFormat.getCurrencyInstance();
        numberFormat.setMaximumFractionDigits(2);
        System.out.println("-----------书店卖出去的书籍记录如下:-----------");
        for (IBook book : bookList) {
            System.out.println("书籍名称:" + book.getName() + "t书籍作者:" + book.getAuthor()
                    + "t书籍价格:" + numberFormat.format(book.getPrice() / 100.0) + "元");
        }
    }
}

运行结果:

-----------书店卖出去的书籍记录如下:-----------
书籍名称:《天龙八部》	书籍作者:金庸	书籍价格:¥100.00元
书籍名称:《巴黎圣母院》	书籍作者:雨果	书籍价格:¥200.00元
书籍名称:《悲惨世界》	书籍作者:雨果	书籍价格:¥300.00元
书籍名称:《金瓶梅》	书籍作者:兰陵笑笑生	书籍价格:¥400.00元

  假设现在需要打折,有以下几种方案:
  在IBook上新增加一个方法getOffPrice(),专门用于进行打折处理,所有的实现类实现该方法。但是这样修改的后果就是,实现类NovelBook要修改,BookStore中的main方法也修改。因此,该方案否定。
  修改NovelBook类中的方法,直接在getPrice()中实现打折处理。该方法在项目有明确的章程(团队内约束)或优良的架构设计时,是一个非常优秀的方法,但是该方法还是有缺陷的。例如采购书籍人员也是要看价格的,由于该方法已经实现了打折处理价格,因此采购人员看到的也是打折后的价格,会因信息不对称而出现决策失误的情况。因此,该方案也不是一个最优的方案。
  增加一个子类OffNovelBook,覆写getPrice方法,高层次的模块(也就是static静态模块 区)通过OffNovelBook类产生新的对象,完成业务变化对系统的最小化开发。好办法,修改也少,风险也小。

public class OffNovelBook extends NovelBook {
    public OffNovelBook(String _name, int _price, String _author) {
        super(_name, _price, _author);
    }
    //覆写销售价格
    @Override
    public int getPrice() {
        //原价
        int selfPrice = super.getPrice();
        int offPrice = 0;
        if (selfPrice > 4000) {
            //原价大于40元,则打9折
            offPrice = selfPrice * 90 / 100;
        } else {
            offPrice = selfPrice * 80 / 100;
        }
        return offPrice;
    }
}

修改BookStore静态代码块,进行打折

public class BookStore {

    private final static List bookList = new ArrayList<>();

    static {
        bookList.add(new OffNovelBook("《天龙八部》", 3200, "金庸"));
        bookList.add(new OffNovelBook("《巴黎圣母院》", 5600, "雨果"));
        bookList.add(new OffNovelBook("《悲惨世界》", 3500, "雨果"));
        bookList.add(new OffNovelBook("《金瓶梅》", 4300, "兰陵笑笑生"));
    }

    public static void main(String[] args) {
        NumberFormat numberFormat = NumberFormat.getCurrencyInstance();
        numberFormat.setMaximumFractionDigits(2);
        System.out.println("-----------书店卖出去的书籍记录如下:-----------");
        for (IBook book : bookList) {
            System.out.println("书籍名称:" + book.getName() + "t书籍作者:" + book.getAuthor()
                    + "t书籍价格:" + numberFormat.format(book.getPrice() / 100.0) + "元");
        }
    }
}

运行结果:

-----------书店卖出去的书籍记录如下:-----------
书籍名称:《天龙八部》	书籍作者:金庸	书籍价格:¥25.60元
书籍名称:《巴黎圣母院》	书籍作者:雨果	书籍价格:¥50.40元
书籍名称:《悲惨世界》	书籍作者:雨果	书籍价格:¥28.00元
书籍名称:《金瓶梅》	书籍作者:兰陵笑笑生	书籍价格:¥38.70元
1.2 单一职责原则

  一个类应该有且仅有一种原因引起改变。

1.3 里式替换原则

  所有引用基类的地方必须能透明地使用其子类的对象。

1.4 接口隔离原则

  客户端不应该依赖它不需要的接口。一个类对另一个类的依赖应该建立在最小的接口上。

1.5 最小知道原则(迪米特法则)

  一个类对于其他类知道的越少越好,就是说一个对象应当对其他对象有尽可能少的了解,只和朋友通信,不和陌生人说话。以清点学生人数为例(反例):

public class Teacher {
    //老师对学生发布命令,清一下女生
    public void command(GroupLeader groupLeader) {
        List listGirls = new ArrayList();
        //初始化女生
        for (int i = 0; i < 20; i++) {
            listGirls.add(new Girl());
        }
        //告诉体育委员开始执行清查任务
        groupLeader.countGirls(listGirls);
    }
}
public class GroupLeader {
    //清查女生数量
    public void countGirls(List listGirls) {
        System.out.println("女生数量是:" + listGirls.size());
    }
}
public class Girl {
}
public class Client {

    public static void main(String[] args) {
        Teacher teacher = new Teacher();
        teacher.command(new GroupLeader());
    }
}

运行结果:

女生数量是:20

  迪米特法则告诉我们一个类只和朋友类交流,但是我们刚刚定义的commond方法却与Girl类有了交流,声明了一个List动态数组,也就是与一个陌生的类Girl有了交流, 这样就破坏了Teacher的健壮性。方法是类的一个行为,类竟然不知道自己的行为与其他类产生依赖关系,这是不允许的,严重违反了迪米特法则,需要进行优化:

public class Teacher {
    //老师对学生发布命令,清一下女生
    public void command(GroupLeader groupLeader) {
        //告诉体育委员开始执行清查任务
        groupLeader.countGirls();
    }
}
public class GroupLeader {

    private List listGirls;

    public GroupLeader(List listGirls) {
        this.listGirls = listGirls;
    }

    //清查女生数量
    public void countGirls() {
        System.out.println("女生数量是:" + listGirls.size());
    }
}
public class Client {

    public static void main(String[] args) {

        List listGirls = new ArrayList<>();
        //初始化女生
        for (int i = 0; i < 20; i++) {
            listGirls.add(new Girl());
        }

        Teacher teacher = new Teacher();
        teacher.command(new GroupLeader(listGirls));
    }
}

运行结果:

女生数量是:20

  对程序进行了简单的修改,把Teacher中对List的初始化移动到了场景类中,同时在GroupLeader中增加了对Girl的注入,避开了Teacher类对陌生类Girl的访问,降低了系统间的耦合,提高了系统的健壮性。

1.6 依赖倒置原则

  程序要依赖于抽象接口,不要依赖于具体实现。简单的说就是要求对抽象进行编程,不要对实现进行编程,这样就降低了客户与实现模块间的耦合。以司机开车为例(反例):

public class Driver {
    //司机的主要职责就是驾驶汽车
    public void drive(Benz benz) {
        benz.run();
    }
}
public class Benz {
    //汽车肯定会跑
    public void run() {
        System.out.println("奔驰汽车开始运行...");
    }
}
public class Client {
    public static void main(String[] args) {
        Driver zhangSan = new Driver();
        Benz benz = new Benz();
        //张三开奔驰车
        zhangSan.drive(benz);
    }
}

运行结果:

奔驰汽车开始运行...

  通过以上的代码,完成了司机开动奔驰车的场景,到目前为止,这个司机开奔驰车的项目没有任何问题。但是如果我们在一段貌似磐石的程序上加上一块小石头:张三司机不仅要开奔驰车,还要开宝马车,这样就无法实现了,因为张三没有开宝马车的方法?一个拿有C驾照的司机竟然只能开奔驰车而不能开宝马车,这也太不合理了!在 现实世界都不允许存在这种情况,何况程序还是对现实世界的抽象,我们的设计出现了问题:司机类和奔驰车类之间是紧耦合的关系,其导致的结果就是系统的可维护性和可读性大大降低。根据依赖倒置原则优化后:

public class Driver {

    private ICar car;

    //司机的主要职责就是驾驶汽车
    public void drive() {
        car.run();
    }

    public void setCar(ICar car) {
        this.car = car;
    }
}
public interface ICar {

    void run();
}
public class Benz implements ICar{
    //汽车肯定会跑
    @Override
    public void run() {
        System.out.println("奔驰汽车开始运行...");
    }
}
public class BMW implements ICar {
    //宝马车当然也可以开动了
    @Override
    public void run() {
        System.out.println("宝马汽车开始运行...");
    }
}
public class Client {
    public static void main(String[] args) {
        Driver zhangSan = new Driver();
        //张三开奔驰车
        zhangSan.setCar(new Benz());
        zhangSan.drive();
        //张三开宝妈车
        zhangSan.setCar(new BMW());
        zhangSan.drive();
    }
}

运行结果:

奔驰汽车开始运行...
宝马汽车开始运行...
2、单例模式

2.1 饿汉模式
package singleton;

public class Hungry {

    private Hungry(){}
    
    private static Hungry hungry = new Hungry();
    
    public static Hungry getInstance(){
        return hungry;
    }
}
2.2 懒汉模式
package singleton;

public class LazyNotSafe {

    private LazyNotSafe(){}
    
    private static LazyNotSafe lazyNotSafe;
    
    public static LazyNotSafe getInstance(){
        if(lazyNotSafe == null){
            lazyNotSafe = new LazyNotSafe();
        }
        return lazyNotSafe;
    }
}
2.3 加锁懒汉模式
package singleton;

public class LazySync{

    private LazySync(){}
    
    private static LazySync lazySync;
    
    public static synchronized LazySync getInstance(){
        if(lazySync == null){
            lazySync = new LazySync();
        }
        return lazySync;
    }
}
2.4 双重检查锁
package singleton;

public class LazyDoubleLock {

    private LazyDoubleLock(){}
    
    private static volatile LazyDoubleLock lazyDoubleLock;
    
    public static LazyDoubleLock getInstance(){
        if(lazyDoubleLock == null){
            synchronized (LazyDoubleLock.class){
                if(lazyDoubleLock == null){
                    lazyDoubleLock = new LazyDoubleLock();
                }
            }
        }
        return lazyDoubleLock;
    }
}
2.5 静态内部类
package singleton;
import java.io.ObjectStreamException;
import java.io.Serializable;

public class StaticInner implements Serializable {
    
    private StaticInner(){
        //构造器判断,防止反射攻击
        if(InnerInstance.STATIC_INNER != null){
            throw new IllegalStateException();
        }
    }

    private Object readResolve() throws ObjectStreamException {
        return InnerInstance.STATIC_INNER;
    }

    public static StaticInner getInstance(){
        return InnerInstance.STATIC_INNER;
    }
    
    private static class InnerInstance{
        private static final StaticInner STATIC_INNER = new StaticInner();
    }
}
2.6 枚举
package singleton;

public enum  EnumSingleton {
    INSTANCE;
    public EnumSingleton getInstance(){
        return INSTANCE;
    }
}
3、工厂模式
public interface IMilk {
}
public class Mengniu implements IMilk {

    public Mengniu(){
        System.out.println("生产蒙牛");
    }
}
public class Jindian implements IMilk {

    public Jindian() {
        System.out.println("生产金典");
    }
}
public class Telunsu implements IMilk {

    public Telunsu() {
        System.out.println("生产特仑苏");
    }
}
3.1 简单工厂模式

public class SimpleMilkFactory {

    public IMilk createMilk(String name) {
        if ("Telunsu".equals(name)) {
            return new Telunsu();
        } else if ("Jindian".equals(name)) {
            return new Jindian();
        } else if ("Mengniu".equals(name)) {
            return new Mengniu();
        } else {
            System.out.println("不支持生产");
            return null;
        }
    }
}
public class SimpleFactoryDemo {

    public static void main(String[] args) {
        SimpleMilkFactory simpleMilkFactory = new SimpleMilkFactory();
        IMilk mengniu = simpleMilkFactory.createMilk("Mengniu");
        IMilk jindian = simpleMilkFactory.createMilk("Jindian");
        IMilk telunsu = simpleMilkFactory.createMilk("Telunsu");
    }
}

运行结果:

生产蒙牛
生产金典
生产特仑苏
3.2 工厂方法模式

public interface IMethodMilkFactory {

    IMilk createMilk();
}
public class JindianMilkFactory implements IMethodMilkFactory {

    @Override
    public IMilk createMilk() {
        return new Jindian();
    }
}
public class MengniuMilkFactory implements IMethodMilkFactory {

    @Override
    public IMilk createMilk() {
        return new Mengniu();
    }
}
public class TelunsuMilkFactory implements IMethodMilkFactory {

    @Override
    public IMilk createMilk() {
        return new Telunsu();
    }
}
public class MethodFactoryDemo {

    public static void main(String[] args) {
        IMethodMilkFactory jindianMilkFactory = new JindianMilkFactory();
        jindianMilkFactory.createMilk();
        IMethodMilkFactory mengniuMilkFactory = new MengniuMilkFactory();
        mengniuMilkFactory.createMilk();
        IMethodMilkFactory telunsuMilkFactory = new TelunsuMilkFactory();
        telunsuMilkFactory.createMilk();
    }
}

运行结果:

生产蒙牛
生产金典
生产特仑苏
4、代理模式
public interface ITarget {

    void doSomething();
}
public class Target implements ITarget{

    @Override
    public void doSomething() {
        System.out.println("目标对象执行任务");
    }
}
4.1 静态代理

public class StaticProxy implements ITarget {

    private Target target;

    public StaticProxy(Target target) {
        this.target = target;
    }

    @Override
    public void doSomething() {
        System.out.println("代理对象执行任务");
        target.doSomething();
    }
}
public class StaticProxyDemo {

    public static void main(String[] args) {
        Target target = new Target();
        ITarget staticProxy = new StaticProxy(target);
        staticProxy.doSomething();
    }
}

运行结果:

代理对象执行任务
目标对象执行任务
4.2 动态代理 4.2.1 JDK动态代理
public class JdkDynamicInvocationHandler implements InvocationHandler {

    private Object object;

    public JdkDynamicInvocationHandler(Object object) {
        this.object = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        System.out.println("代理对象执行任务");
        Object result = method.invoke(this.object, args);
        return result;
    }
}
public class JdkDynamicDemo {

    public static void main(String[] args) {
        Target target = new Target();
        ITarget proxy = (ITarget)Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(), new JdkDynamicInvocationHandler(target));
        proxy.doSomething();
    }
}

运行结果:

代理对象执行任务
目标对象执行任务
4.2.2 CGLIB动态代理
public class CglibMethodInterceptor implements MethodInterceptor {

    private Object object;

    public CglibMethodInterceptor(Object object) {
        this.object = object;
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {

        System.out.println("代理对象执行任务");
        Object result = method.invoke(object, objects);
        return result;
    }
}
public class CglibDynamicDemo {

    public static void main(String[] args) {

        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(Target.class);
        enhancer.setCallback(new CglibMethodInterceptor(new Target()));
        Target target = (Target)enhancer.create();
        target.doSomething();
    }
}

执行结果:

代理对象执行任务
目标对象执行任务
5、策略模式

public interface Pay {

    void pay();
}
public class AliPay implements Pay {

    @Override
    public void pay() {
        System.out.println("支付宝支付");
    }
}
public class WeChatPay implements Pay {

    @Override
    public void pay() {
        System.out.println("微信支付");
    }
}
public class QuickPassPay implements Pay {

    @Override
    public void pay() {
        System.out.println("云闪付支付");
    }
}
public class StrategyContext {

    private Pay pay;

    public StrategyContext (Pay pay) {
        this.pay = pay;
    }

    public void dealPay() {
        pay.pay();
    }
}
public class StrategyDemo {

    public static void main(String[] args) {

        StrategyContext aliPayStrategyContext = new StrategyContext(new AliPay());
        aliPayStrategyContext.dealPay();

        StrategyContext weChatPayStrategyContext = new StrategyContext(new WeChatPay());
        weChatPayStrategyContext.dealPay();

        StrategyContext quickPassPayStrategyContext = new StrategyContext(new QuickPassPay());
        quickPassPayStrategyContext.dealPay();
    }

}

运行结果:

支付宝支付
微信支付
云闪付支付
6、模板方法模式

public abstract class AbstractTemplate {

    public void init(){
        System.out.println("执行初始化方法");
    }

    abstract void doSomething1();

    public void hookMethod(){}

    abstract void doSomething2();

    public void destroy() {
        System.out.println("执行结束方法");
    }

    public void template() {

        init();

        doSomething1();

        hookMethod();

        doSomething2();

        destroy();
    }
}
public class TemplateObjectA extends AbstractTemplate {
    @Override
    public void doSomething1() {
        System.out.println("模板A执行方法1");
    }

    @Override
    public void hookMethod() {
        System.out.println("模板A执行钩子方法");
    }

    @Override
    public void doSomething2() {
        System.out.println("模板A执行方法2");
    }
}
public class TemplateObjectB extends AbstractTemplate {
    @Override
    void doSomething1() {
        System.out.println("模板B执行方法1");
    }

    @Override
    void doSomething2() {
        System.out.println("模板B执行方法2");
    }
}
public class TemplateDemo {

    public static void main(String[] args) {
        TemplateObjectA templateObjectA = new TemplateObjectA();
        TemplateObjectB templateObjectB = new TemplateObjectB();
        templateObjectA.template();
        System.out.println("-----");
        templateObjectB.template();
    }
}

运行结果:

执行初始化方法
模板A执行方法1
模板A执行钩子方法
模板A执行方法2
执行结束方法
-----
执行初始化方法
模板B执行方法1
模板B执行方法2
执行结束方法
7、原型模式
@Data
public class ProtoObject implements Cloneable, Serializable {

    private List list = new ArrayList<>();

    public List getList() {
        return list;
    }

    @Override
    public ProtoObject clone() throws CloneNotSupportedException {
        return (ProtoObject) super.clone();
    }

    public ProtoObject deepClone() {
        ProtoObject protoObject = null;
        try(ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("protoObject"));
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("protoObject"))) {
            oos.writeObject(this);
            protoObject = (ProtoObject)ois.readObject();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return protoObject;
    }
}
public class PrototypeDemo {

    public static void main(String[] args) throws CloneNotSupportedException {
        ProtoObject protoObject = new ProtoObject();
        ProtoObject protoObjectCommon = protoObject.clone();
        ProtoObject protoObjectDeep = protoObject.deepClone();
        System.out.println("克隆后赋值原型对象list");
        protoObject.getList().add("A");
        System.out.println("原型对象:" + protoObject);
        System.out.println("浅克隆结果:" + protoObjectCommon);
        System.out.println("深克隆结果:" + protoObjectDeep);
    }
}

运行结果:

克隆后赋值原型对象list
原型对象:ProtoObject(list=[A])
浅克隆结果:ProtoObject(list=[A])
深克隆结果:ProtoObject(list=[])
8、责任链模式

public abstract class AbstractChain {

    private AbstractChain nextChain;

    abstract void doSomethingBefore(String request);

    abstract void doSomethingAfter(String request);

    public void handler(String request) {
        doSomethingBefore(request);
        AbstractChain chain = getNextChain();
        if (chain != null) {
            chain.handler(request);
        }
        doSomethingAfter(request);
    }

    public AbstractChain getNextChain() {
        return nextChain;
    }

    public void setNextChain(AbstractChain nextChain) {
        this.nextChain = nextChain;
    }
}
public class ConcreteHandlerA extends AbstractChain {

    @Override
    void doSomethingBefore(String request) {
        System.out.println("ConcreteHandlerA doSomethingBefore " + request);
    }

    @Override
    void doSomethingAfter(String request) {
        System.out.println("ConcreteHandlerA doSomethingAfter " + request);
    }
}
public class ConcreteHandlerB extends AbstractChain {

    @Override
    void doSomethingBefore(String request) {
        System.out.println("ConcreteHandlerB doSomethingBefore " + request);
    }

    @Override
    void doSomethingAfter(String request) {
        System.out.println("ConcreteHandlerB doSomethingAfter " + request);
    }
}
public class ConcreteHandlerC extends AbstractChain {

    @Override
    void doSomethingBefore(String request) {
        System.out.println("ConcreteHandlerC doSomethingBefore " + request);
    }

    @Override
    void doSomethingAfter(String request) {
        System.out.println("ConcreteHandlerC doSomethingAfter " + request);
    }
}
public class ChainDemo {

    public static void main(String[] args) {
        ConcreteHandlerA concreteHandlerA = new ConcreteHandlerA();
        ConcreteHandlerB concreteHandlerB = new ConcreteHandlerB();
        ConcreteHandlerC concreteHandlerC = new ConcreteHandlerC();
        concreteHandlerA.setNextChain(concreteHandlerB);
        concreteHandlerB.setNextChain(concreteHandlerC);
        concreteHandlerA.handler("request");
    }
}

运行结果:

ConcreteHandlerA doSomethingBefore request
ConcreteHandlerB doSomethingBefore request
ConcreteHandlerC doSomethingBefore request
ConcreteHandlerC doSomethingAfter request
ConcreteHandlerB doSomethingAfter request
ConcreteHandlerA doSomethingAfter request
9、委派模式

public interface IEmployee {

    void doing(String task);
}
public class EmployeeA implements IEmployee {

    protected String name;

    public EmployeeA(String name){
        this.name = name;
    }

    @Override
    public void doing(String task) {
        System.out.println("我是员工A,我擅长"+name+",现在开始做"+task+"工作");
    }
}
public class EmployeeB implements IEmployee {

    protected String name;

    public EmployeeB(String name){
        this.name = name;
    }
    @Override
    public void doing(String task) {
        System.out.println("我是员工B,我擅长"+name+",现在开始做"+task+"工作");
    }
}
public class Leader implements IEmployee {

    HashMap map = new HashMap<>();

    public Leader(){
        map.put("登录",new EmployeeA("开发"));
        map.put("登录页面",new EmployeeB("UI"));
    }

    @Override
    public void doing(String task) {
        map.get(task).doing(task);
    }
}
public class DelegateDemo {

    public static void main(String[] args) {
        new Leader().doing("登录");
        new Leader().doing("登录页面");
    }
}

运行结果:

我是员工A,我擅长开发,现在开始做登录工作
我是员工B,我擅长UI,现在开始做登录页面工作
10、装饰器模式

public interface Shape {

    void draw();
}
public class Circle implements Shape {

    @Override
    public void draw() {
        System.out.println("Shape: Circle");
    }
}
public class Rectangle implements Shape {

    @Override
    public void draw() {
        System.out.println("Shape: Rectangle");
    }
}
public abstract class ShapeDecorator implements Shape {

    protected Shape decoratedShape;

    public ShapeDecorator(Shape decoratedShape){
        this.decoratedShape = decoratedShape;
    }
}
public class RedShapeDecorator extends ShapeDecorator {

    public RedShapeDecorator(Shape decoratedShape) {
        super(decoratedShape);
    }

    @Override
    public void draw() {
        decoratedShape.draw();
        setRedBorder(decoratedShape);
    }

    private void setRedBorder(Shape decoratedShape){
        System.out.println("Border Color: Red");
    }
}
public class DecoratorDemo {

    public static void main(String[] args) {
        Shape circle = new Circle();
        ShapeDecorator redCircle = new RedShapeDecorator(new Circle());
        ShapeDecorator redRectangle = new RedShapeDecorator(new Rectangle());
        //Shape redCircle = new RedShapeDecorator(new Circle());
        //Shape redRectangle = new RedShapeDecorator(new Rectangle());
        System.out.println("Circle with normal border");
        circle.draw();

        System.out.println("nCircle of red border");
        redCircle.draw();

        System.out.println("nRectangle of red border");
        redRectangle.draw();
    }
}

运行结果:

Circle with normal border
Shape: Circle

Circle of red border
Shape: Circle
Border Color: Red

Rectangle of red border
Shape: Rectangle
Border Color: Red
11、观察者模式

public class Subject {

    private List observers = new ArrayList<>();

    private int state;

    public int getState() {
        return state;
    }

    public void setState(int state) {
        this.state = state;
        notifyAllObservers();
    }

    public void attach(Observer observer){
        observers.add(observer);
    }

    public void notifyAllObservers(){
        for (Observer observer : observers) {
            observer.update();
        }
    }
}
public abstract class Observer {

    protected Subject subject;

    public abstract void update();
}
public class BinaryObserver extends Observer {

    public BinaryObserver(Subject subject) {
        this.subject = subject;
        this.subject.attach(this);
    }

    @Override
    public void update() {
        System.out.println("Binary String: " + Integer.toBinaryString(subject.getState()));
    }
}
public class OctalObserver extends Observer{

    public OctalObserver(Subject subject){
        this.subject = subject;
        this.subject.attach(this);
    }

    @Override
    public void update() {
        System.out.println( "Octal String: " + Integer.toOctalString(subject.getState()));
    }
}
public class HexaObserver extends Observer{

    public HexaObserver(Subject subject){
        this.subject = subject;
        this.subject.attach(this);
    }

    @Override
    public void update() {
        System.out.println( "Hex String: " + Integer.toHexString( subject.getState() ).toUpperCase() );
    }
}
public class ObserverDemo {
    public static void main(String[] args) {
        Subject subject = new Subject();
        new HexaObserver(subject);
        new OctalObserver(subject);
        new BinaryObserver(subject);

        System.out.println("First state change: 15");
        subject.setState(15);
        System.out.println("Second state change: 10");
        subject.setState(10);
    }
}
转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/936985.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号