rust 跟java对比 rust和java

文章目录

• 命令模式

• 介绍
• java
• rust
• rust仓库

命令模式

命令模式（Command Pattern）是一种数据驱动的设计模式。请求以命令的形式包裹在对象中，并传给调用对象。调用对象寻找可以处理该命令的合适的对象，并把该命令传给相应的对象，该对象执行命令。

介绍

• 意图：将一个请求封装成一个对象，从而使您可以用不同的请求对客户进行参数化。
• 主要解决：在软件系统中，行为请求者与行为实现者通常是一种紧耦合的关系，但某些场合，比如需要对行为进行记录、撤销或重做、事务等处理时，这种无法抵御变化的紧耦合的设计就不太合适。
• 何时使用：当需要先将一个函数登记上，然后再以后调用此函数时，就需要使用命令模式，其实这就是回调函数。
• 优点：1.类间解耦：调用者角色与接收者角色之间没有任何依赖关系，调用者实现功能时只需调用Command 抽象类的execute方法就可以，不需要了解到底是哪个接收者执行。2.可扩展性：Command的子类可以非常容易地扩展，而调用者Invoker和高层次的模块Client不产生严 重的代码耦合。3.命令模式结合其他模式会更优秀：命令模式可以结合责任链模式，实现命令族解析任务；结合模板方法模式，则可以减少 Command子类的膨胀问题。
• 缺点：命令模式也是有缺点的，请看Command的子类：如果有N个命令，问题就出来 了，Command的子类就可不是几个，而是N个，这个类膨胀得非常大，这个就需要读者在项 目中慎重考虑使用。

命令模式结构示意图:

java

我们首先创建作为命令的接口 Order，然后创建作为请求的 Stock 类。实体命令类 BuyStock 和 SellStock，实现了 Order 接口，将执行实际的命令处理。创建作为调用对象的类 Broker，它接受订单并能下订单。

Broker 对象使用命令模式，基于命令的类型确定哪个对象执行哪个命令。CommandPatternDemo 类使用 Broker 类来演示命令模式。

步骤 1
创建一个命令接口。

Order.java

public interface Order {
   void execute();
}

步骤 2
创建一个请求类。
Stock.java

public class Stock {
   
   private String name = "ABC";
   private int quantity = 10;
 
   public void buy(){
      System.out.println("Stock [ Name: "+name+", 
         Quantity: " + quantity +" ] bought");
   }
   public void sell(){
      System.out.println("Stock [ Name: "+name+", 
         Quantity: " + quantity +" ] sold");
   }
}

步骤 3
创建实现了 Order 接口的实体类。

BuyStock.java

public class BuyStock implements Order {
   private Stock abcStock;
 
   public BuyStock(Stock abcStock){
      this.abcStock = abcStock;
   }
 
   public void execute() {
      abcStock.buy();
   }
}

SellStock.java

public class SellStock implements Order {
   private Stock abcStock;
 
   public SellStock(Stock abcStock){
      this.abcStock = abcStock;
   }
 
   public void execute() {
      abcStock.sell();
   }
}

步骤 4
创建命令调用类。

Broker.java
import java.util.ArrayList;
import java.util.List;

public class Broker {
   private List<Order> orderList = new ArrayList<Order>(); 
 
   public void takeOrder(Order order){
      orderList.add(order);      
   }
 
   public void placeOrders(){
      for (Order order : orderList) {
         order.execute();
      }
      orderList.clear();
   }
}

步骤 5
使用 Broker 类来接受并执行命令。

CommandPatternDemo.java

public class CommandPatternDemo {
   public static void main(String[] args) {
      Stock abcStock = new Stock();
 
      BuyStock buyStockOrder = new BuyStock(abcStock);
      SellStock sellStockOrder = new SellStock(abcStock);
 
      Broker broker = new Broker();
      broker.takeOrder(buyStockOrder);
      broker.takeOrder(sellStockOrder);
 
      broker.placeOrders();
   }
}

步骤 6
执行程序，输出结果：

Stock [ Name: ABC, Quantity: 10 ] bought
Stock [ Name: ABC, Quantity: 10 ] sold

rust

trait Order {
    fn execute(&self);
}
#[derive(Clone)]
struct Stock{
    name:String,
    quantity:i32,
}
impl Stock {
    fn buy(&self) {
        println!("Stock [ Name : {}  Quantity: {}] bought",self.name,self.quantity);
    }
    fn sell(&self) {
        println!("Stock [ Name : {}  Quantity: {}] sold",self.name,self.quantity);
    }
    fn new()->Stock{
        Stock{
            name:"ABC".to_owned(),
            quantity:10
        }
    }
}
// 创建命令实体
struct  BuyStock {
    abc_stock:Stock
}
impl Order for BuyStock {
    fn execute(&self) {
        self.abc_stock.buy();
    }
}
struct  SellStock {
    abc_stock:Stock
}
impl Order for SellStock {
    fn execute(&self) {
        self.abc_stock.sell();
    }
}
// 创建命令调用类。
struct Broker{
    order_list:Vec<Box<dyn Order>>
}
impl Broker {
    fn take_order(&mut self,order:impl Order+ 'static){
        
        self.order_list.push(Box::new(order));
    }
    fn place_orders(&self){
        self.order_list.iter().for_each(|f|f.execute());
    }
    fn  new()->Broker {
        Broker{
            order_list:vec![]
        }
    }
}
fn main(){
    let stock=Stock::new();
   
    let buy=BuyStock{abc_stock:stock.clone()};
    let sell=SellStock{abc_stock:stock.clone()};
    let mut broker=Broker::new();
    broker.take_order(buy);
    broker.take_order(sell);
    broker.place_orders();

}