先放弃这种想法，但是可以用泛型（或假多态）思维。
Rust中其实归根到底还是函数编程的思维占主要的的，虽然有结构这东西可能实现面向对象编程，但是更多设计思维上还是函数。但是了为代码简洁还是要使用继承和多态。

暂定思维：
1.继承 == 全局Util函数，或者使用宏
2.多态使用 trait

看下面代码：

pub trait Monter {
    fn p1(&self);
}

pub struct Mon1{
    pub name:String,
}

pub struct Mon2{
    pub name:String,
}

impl Monter for Mon1 {
    fn p1(&self) {
        println!("mon1 {}", self.name);
    }
}

impl Monter for Mon2 {
    fn p1(&self) {
        println!("mon2 {}", self.name);
    }
}

就是保持每个“子类”都有相同的方法。

下面实现调用：重点 &dyn 还有 :: 变成 .

fn test_mod1() {
    let mon1 = Mon1{ name: "test1".to_owned()};
    let mon2 = Mon2{ name: "test2".to_owned()};

    for i in 0..10 {
        let tmp:&dyn Monter = if i % 2 == 0 {
            &mon1
        }else{
            &mon2
        };
        
        tmp.p1();
    }
}

写工具时通常会生成ZIP文件，一般来说就传相对路径和内容就好。但是今天发现一个细节。还需要将文件所在的目录也要传进去。虽然现在的解压软件都支持不传，但是如果解压的代码不规范就会造成保存路径不存在，因为父级目录不存在：

let file: File = File::create(zip_path).unwrap();  
let mut writer: ZipWriter<File> = ZipWriter::new(file);
let options = zip::write::FileOptions::default()
    .compression_method(zip::CompressionMethod::Deflated);

// 因为这里已经将所有目录 遍历好。目录结构已经不存在的，只能通过文件路径反向还原，并使用map去重
let mut dirMap:HashMap<String, bool> = HashMap::new();

// .... 中间省略循环遍历
// 先将文件目录结构创建
let arr:Vec<&str> = path.split('/').collect();
let mut tmp_dir: String = String::new();
for i in 0..(arr.len() - 1) {
    let tmp = arr[i];
    tmp_dir.push('/');
    tmp_dir.push_str(tmp);
    if dirMap.contains_key(&tmp_dir){ // 缓存保存过的目录
        continue;
    }
    dirMap.insert(tmp_dir.clone(), true);
    writer.add_directory(&tmp_dir, options).unwrap();
}

// 将文件写入ZIP
let mut buffer = Vec::new();
let mut file = File::open(&tmp_path).unwrap();
file.read_to_end(&mut buffer).unwrap();
writer.start_file(path, options).unwrap();
writer.write_all(&buffer).unwrap();