建造者模式 rust和java的实现(二)

简介: 建造者模式 rust和java的实现

建造者模式 rust和java的实现(一)https://developer.aliyun.com/article/1392031


步骤 5

创建一个 Meal 类,带有上面定义的 Item 对象。

Meal.java

import java.util.ArrayList;
import java.util.List;
public class Meal {
   private List<Item> items = new ArrayList<Item>();    
   public void addItem(Item item){
      items.add(item);
   }
   public float getCost(){
      float cost = 0.0f;
      for (Item item : items) {
         cost += item.price();
      }        
      return cost;
   }
   public void showItems(){
      for (Item item : items) {
         System.out.print("Item : "+item.name());
         System.out.print(", Packing : "+item.packing().pack());
         System.out.println(", Price : "+item.price());
      }        
   }    
}

步骤 6

创建一个 MealBuilder 类,实际的 builder 类负责创建 Meal 对象。

MealBuilder.java

public class MealBuilder {
   public Meal prepareVegMeal (){
      Meal meal = new Meal();
      meal.addItem(new VegBurger());
      meal.addItem(new Coke());
      return meal;
   }   
   public Meal prepareNonVegMeal (){
      Meal meal = new Meal();
      meal.addItem(new ChickenBurger());
      meal.addItem(new Pepsi());
      return meal;
   }
}

步骤 7

BuiderPatternDemo 使用 MealBuilder 来演示建造者模式(Builder Pattern)。

BuilderPatternDemo.java

public class BuilderPatternDemo {
   public static void main(String[] args) {
      MealBuilder mealBuilder = new MealBuilder();
      Meal vegMeal = mealBuilder.prepareVegMeal();
      System.out.println("Veg Meal");
      vegMeal.showItems();
      System.out.println("Total Cost: " +vegMeal.getCost());
      Meal nonVegMeal = mealBuilder.prepareNonVegMeal();
      System.out.println("\n\nNon-Veg Meal");
      nonVegMeal.showItems();
      System.out.println("Total Cost: " +nonVegMeal.getCost());
   }
}

步骤 8

执行程序,输出结果:

Veg Meal
Item : Veg Burger, Packing : Wrapper, Price : 25.0
Item : Coke, Packing : Bottle, Price : 30.0
Total Cost: 55.0
Non-Veg Meal
Item : Chicken Burger, Packing : Wrapper, Price : 50.5
Item : Pepsi, Packing : Bottle, Price : 35.0
Total Cost: 85.5

rust

因为rust的类支持组合式而不支持继承,在进行建造者构件时比java更加容易,rust的trait是支持继承的。

// rsut trait不支持重名
pub trait Item {
    fn name(&self)->String;   
    fn price(&self)->f32;   
    fn packing(&self)->String;
}
// 汉堡实体类
struct ChickenBurger;
impl Item for ChickenBurger {
    fn name(&self)->String {
        String::from("ChickenBurger")
    }
    fn price(&self)->f32 {
        35.0
    }
    fn packing(&self)->String {
        String::from("Wrappper")
    }
}  
struct VegBurger;
impl Item for VegBurger {
    fn name(&self)->String {
        String::from("Pepsi")
    }
    fn price(&self)->f32 {
        35.0
    }
    fn packing(&self)->String {
        String::from("Wrappper")
    }
}  
// 饮料实体类
struct Pepsi;
impl Item for Pepsi {
    fn name(&self)->String {
        String::from("Pesi")
    }
    fn price(&self)->f32 {
        35.0
    }
    fn packing(&self)->String {
        String::from("Bottle")
    }
}  
struct Coke;
impl Item for Coke {
    fn name(&self)->String {
        String::from("Coke")
    }
    fn price(&self)->f32 {
        35.0
    }
    fn packing(&self)->String {
        String::from("Bottle")
    }
}  
struct Meal {
    items:Vec<Box<dyn Item>>,
}
impl Meal {
    fn add_item<T>(&mut self,item:Box<dyn Item>) 
    {
        self.items.push(item)
    }
    fn get_cost(&self)->f32{
        // 普通函数实现
        // let mut sum:f32=0.0; 
        // for i in self.items.iter()  {
        //     let price = i.price();
        //     sum+=price;
        // }
        // sum
        // 函数sji
        self.items.iter().fold(0.0, |acc, x| acc + x.price())
    }
    fn  show_items(&self){
        for  i in self.items.iter() {
            println!("{}",i.name());
            println!("{}",i.packing());
            println!("{}",i.price());
        }
    }
}
// 添加建造者
struct MealBuilder {}
impl  MealBuilder {
    fn prepareVegMeal()->Meal{
        let mut meal=Meal{items:Vec::new()};
        meal.add_item::<Box<dyn Item>>(Box::new(VegBurger{}));
        meal.add_item::<Box<dyn Item>>(Box::new(Coke{}));
        meal
    }
    fn prepareNonVegMeal()->Meal{
        let mut meal=Meal{items:Vec::new()};
        meal.add_item::<Box<dyn Item>>(Box::new(ChickenBurger{}));
        meal.add_item::<Box<dyn Item>>(Box::new(Pepsi{}));
        meal
    }
}
fn main() {
    let m=MealBuilder::prepareVegMeal();
    println!(" Veg Meal");
    m.show_items();
    println!("Total Cost : {}",m.get_cost());
    let m=MealBuilder::prepareNonVegMeal();
    println!(" \n\nNon-Veg Meal");
    m.show_items();
    println!("Total Cost : {}",m.get_cost());
}

rust代码仓库

https://github.com/onenewcode/design.git

本教程项目在bin文件夹下的builder.rs文件中

相关文章
|
4月前
|
设计模式 Java 机器人
Java设计模式-建造者模式
建造者(Builder)模式指将一个产品的内部表象与产品的生成过程分割开来,从而可以使一个建造过程生成具有不同的内部表象的产品对象。它是把对象的构建和表述分离。
52 0
Java设计模式-建造者模式
|
5月前
|
设计模式 Java
Java设计模式【四】:建造者模式
Java设计模式【四】:建造者模式
24 0
|
1月前
|
设计模式 Java
23种设计模式,建造者模式的概念优缺点以及JAVA代码举例
【4月更文挑战第10天】建造者模式是一种对象创建型设计模式,用于创建复杂对象。其核心思想是将一个复杂对象的构建与其表示分离,使得同样的构建过程可以创建不同的表示。建造者模式通常包括一个Director类,用于管理构建过程,和多个Builder类,每个Builder负责构造复杂对象的一部分。
29 7
|
3月前
|
Rust 安全 Java
Rust与Java:性能与效率的较量
本文将对比Rust和Java两种编程语言在性能和效率方面的差异。我们将探讨Rust如何通过其独特的内存管理、并发模型和编译时优化来实现高性能,同时分析Java如何在虚拟机(JVM)的支持下实现高效运行。通过比较这两种语言的特性和应用场景,我们可以为开发者在选择编程语言时提供有益的参考。
|
4月前
|
Rust Java Linux
【一起学Rust | 进阶篇 | jni库】JNI实现Java与Rust进行交互
【一起学Rust | 进阶篇 | jni库】JNI实现Java与Rust进行交互
87 0
|
5月前
|
Rust 前端开发 Java
中介者模式 rust和java的实现
中介者模式 rust和java的实现
41 0
|
5月前
|
存储 Rust Java
备忘录模式 rust和java的实现
备忘录模式 rust和java的实现
30 0
|
5月前
|
设计模式 Rust Java
组合模式 rust和java的实现
组合模式 rust和java的实现
63 0
|
5月前
|
Rust Java uml
外观模式 rust和java的实现
外观模式 rust和java的实现
41 0
|
19天前
|
Rust 安全 程序员