java上下文context java上下文模式

转载

数据科学探索者 2024-05-30 11:22:37

文章标签 java上下文context 数据 ide 中介者 文章分类 Java 后端开发

几个重要的设计模式

相关知识点

策略模式的定义：定义一系列算法，把它们一个个地封装起来，并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。策略模式的结构中包括3种角色。

策略（Strategy):策略是一个接口，该接口定义若干个算法标识，即定义了若干个抽象方法。
具体策略（ConcreteStrategy):具体策略是实现策略接口的类。具体策略重写策略接口所定义的抽象方法，即给出算法标识的具体算法。
上下文（Context)：上下文是依赖于策略接口的类，即上下文包含策略声明的变量。上下文中提供一个方法，该方法委托策略变量调用具体策略所重写的策略接口中的方法。

interface Group {	//策略
    void group();   //一个无参数无返回的抽象方法
}

class strategyOne implements Group {    //具体策略
    @Override
    public void group() {
        System.out.println("我是策略1");
    }
}

class strategyTwo implements Group {
    @Override
    public void group() {
        System.out.println("我是策略2");
    }
}

class strategyThree implements Group {
    @Override
    public void group() {
        System.out.println("我是策略3");
    }
}

class Content { //上下文
    Group strategy; //接口变量

    Content() {
    }

    public void setStrategy(Group strategy) {   //设置具体策略
        this.strategy = strategy;
    }

    public void showStrategy() {    //展示策略
        strategy.group();
    }
}

根据策略模式定义的类和接口就是一个开发框架，用户可以使用该框架进行程序设计。根据策略模式给出的开发框架模式满足“开-闭”原则，当增加新的具体策略时，不需要修改上下文类的代码，上下文类就可以引用新的具体策略的实例。

相关知识点2

中介者模式的定义：用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
中介者模式的结构中包括4种角色。

中介者（Mediator):中介者是一个接口，该接口定义了用于同事（Colleague)对象之间进行通信的方法。
具体中介者(ConcreteMediator):具体中介者是实现中介者接口的类。具体中介者需要包含所有具体同事（ConcreteColleague)的引用，并通过重写中介者接口中的方法来满足具体同事之间的通信请求。
同事（Colleague)：一个接口，规定了具体同事需要实现的方法。
具体同事(ConcreteColleague):实现同事接口的类。具体同事需要包含具体中介者的引用，一个具体同事需要和其他具体同事交互时，只需将自己的请求通知给它所包含的具体中介者即可。

可以看成房屋出租

interface Colleague {    //同事
    public void setName(String name);

    public String getName();

    public void giveMess(String mess);

    public void ReceiveMess(String mess);
}

class RentHouse implements Colleague {   //具体同事
    Mediator mediator;  //中介者变量
    String name;

    RentHouse() {
    }

    RentHouse(Mediator mediator) {
        this.mediator = mediator;
    }

    @Override
    public void setName(String name) {
        this.name = name;
    }

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

    @Override
    public void giveMess(String mess) {
        mediator.deliverMess(this, mess);

    }

    public void ReceiveMess(String mess) {
        System.out.println(name + "收到一条信息:");
        System.out.println(mess);
    }
}

class BegRentHosue implements Colleague {
    Mediator mediator;
    String name;

    public BegRentHosue() {
    }

    public BegRentHosue(Mediator mediator) {
        this.mediator = mediator;
    }

    @Override
    public void setName(String name) {
        this.name = name;
    }

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

    @Override
    public void giveMess(String mess) {
        mediator.deliverMess(this, mess);

    }

    public void ReceiveMess(String mess) {
        System.out.println(name + "收到一条信息:");
        System.out.println(mess);
    }
}

class Mediator {
    RentHouse rentHouse;
    BegRentHosue begRentHosue;

    public void setRentHouse(RentHouse rentHouse) {
        this.rentHouse = rentHouse;
    }

    public void setBegRentHosue(BegRentHosue begRentHosue) {
        this.begRentHosue = begRentHosue;
    }

    public void deliverMess(Colleague colleague, String mess) {
        if (colleague instanceof RentHouse) {    //如果对象是出租的话
            begRentHosue.ReceiveMess(rentHouse.getName() + "有房屋" + mess);
        } else if (colleague instanceof BegRentHosue) {
            rentHouse.ReceiveMess(begRentHosue.getName() + "说" + mess);
        }
    }
}

public class Example_2 {
    public static void main(String[] args) {
        Mediator mediator = new Mediator();
        RentHouse rentHouse = new RentHouse(mediator);
        BegRentHosue begRentHosue = new BegRentHosue(mediator);
        rentHouse.setName("小红");
        begRentHosue.setName("小明");
        mediator.setRentHouse(rentHouse);
        mediator.setBegRentHosue(begRentHosue);
        rentHouse.giveMess("我有房出租");
        begRentHosue.giveMess("我要租房");
    }
}

运行的结果

java上下文context java上下文模式_数据

相关知识点3

模板方法模式的定义：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。模板方法是关于怎样将若干个方法集成到一个方法中，以便形成一个解决问题的算法骨架。模板方法模式的关键是在一个抽象类中定义一个算法的骨架，即将若干个抽象方法集成到一个方法中，并称该方法为一个模板方法，或简称为模板。模板方法所调用的其他方法通常为抽象的方法，这些抽象方法相当于算法骨架中的各个步骤，这些步骤的实现可以由抽象类的子类去完成。

模板方法模式包括两种角色。

抽象模板(AbstractTemplate)：抽象模板是一个抽象类。抽象模板定义了若干个方法以表示一个算法的各个步骤，这些方法中有抽象方法也有非抽象方法，其中的抽象方法称作原语操作（Primitive Operation)。重要的一点是，抽象模板中还定义了一个称作模板方法的方法，该方法负责组织调用抽象模板中表示算法步骤的方法，即模板方法定义了算法的骨架。
具体模板(Concrete Template):具体模板是抽象模板的子类，重写抽象模板中的原语操作。

abstract class EditFile{    //抽象模板
    abstract void choiceEditTool();  //抽象方法
    abstract void inputContent();
    abstract void saveFile();
    void Step(){	//集成若干个抽象方法
        choiceEditTool();
        inputContent();
        saveFile();
    }
}
class File extends EditFile{	//具体模板
    @Override
    void choiceEditTool() {
        System.out.println("开始选择");
    }

    @Override
    void inputContent() {
        System.out.println("正在编辑");
    }

    @Override
    void saveFile() {
        System.out.println("执行保存");

    }
}
public class Example_3 {
    public static void main(String[] args) {
        File file = new File();
        file.Step();
    }
}

程序设计的基本成分

程序设计语言的基本成分包括数据、运算、控制和传输等。

程序设计语言的数据成分

程序设计语言包括语法、语义、语用三个方面。语法表示程序的结构，即表示构成语言的各记号间的组合规则；语义表示程序的含义，即表示按照各种方法所使用的各个记号的特定含义；语用表示程序与使用者的关系。
程序设计语言的数据成分指的是一种程序设计语言的数据类型。数据是程序操作的对象，具有存储类、类型、名称、作用域和生存期等属性，使用时要为它分配内存空间。数据名称由用户通过标识符命名，标识符由字母、数字和下划线组成；类型说明数据占用内存的大小和存放形式；存储类说明数据在内存中的位置和生存期；作用域则说明可以使用数据的代码范围：生存期说明数据占用内存的时间范围。从不同角度可将数据进行不同的划分。

常量和变量