正如您所注意到的，Rust不是围绕类分类原则构建的，因此设计通常是不同的，您不应该试图在Rust中模仿OO语言。
你问了一个非常一般的问题，但有很多具体的情况需要不同的解决方案。
通常，当你想用OO语言定义什么对象是类时，你会使用traits来指定Rust中结构体行为的某些方面。
在您的特定情况下，假设正确的解决方案不涉及参数化或i18n实用程序，我可能会同时使用composition和enum来表示问候：

pub struct Greeting {
    name: String,
    greeter: Greeter;
}
impl Greeting {
    pub fn greet(&self) -> String {
        // use self.greeter.date_format() and self.name
    }
}

pub enum Greeter {
    USA,
    UK,
}
impl Greeter {
    fn date_format(&self) -> &'static str {
        match self {
           USA => ...,
           UK => ...,
        }
    }    
}

您的复合实现只需在需要时打开变体。

• （请注意，我不编写这种情况下的实现，因为性能问题可能会为不同的设计调用Rust，而不是动态解释的模式，但这会使我们远离您的问题）*

您可以添加返回对必填字段的引用的函数，并定义函数的默认实现。这是java或C#中的常用技术（get; set;）

trait Greeting: 
{
    fn get_name(&self) -> &str;
    fn format_date(&self) -> &str;
    fn greet(&self)
    {
        println!("Hello {}\n Today is {}", self.get_name(), self.format_date());
    }
}

struct USAGreeting{name: String }
struct UKGreeting{name: String }

impl Greeting for USAGreeting
{
    fn get_name(&self) -> &str { &self.name }

    fn format_date(&self) -> &str {
        return "$month/$day/$year"
    }
}

impl Greeting for UKGreeting
{
    fn get_name(&self) -> &str { &self.name }

    fn format_date(&self) -> &str {
        return "$day/$month/$year"
    }
}

fn main() {
    let uk = UKGreeting { name: "UK Greeting!".to_owned() };
    let usa = UKGreeting { name: "UK Greeting!".to_owned() };

    let dynamic: Vec<&dyn Greeting> = vec![&uk, &usa];

    for greeter in dynamic
    {
        greeter.get_name();
        greeter.greet();
    }
}

现在，Greeting可以在动态或通用上下文中使用。如果每次实现Greeting时都必须定义get_name() -> &str，那么解决方法如下所示：

trait Named
{
    fn get_name(&self) -> &str;
}

trait Greeting: Named 
{
    fn format_date(&self) -> &str;
    fn greet(&self)
    {
        println!("Hello {}\n Today is {}", self.get_name(), self.format_date());
    }
}

impl Greeting for USAGreeting
{
    fn format_date(&self) -> &str {
        return "$month/$day/$year"
    }
}

impl Greeting for UKGreeting
{
    fn format_date(&self) -> &str {
        return "$day/$month/$year"
    }
}

它并没有解决这个问题，而是把它从Greeting特征中分离出来。现在你可以使用过程宏（#[derive()]）来自动生成get_name。
例如，过程宏可能如下所示

use proc_macro::{self, TokenStream};
use quote::quote;
use syn;

#[proc_macro_derive(NamedMacro)]
pub fn describe(tokens: TokenStream) -> TokenStream {
    let ast: syn::DeriveInput = syn::parse(tokens).unwrap();

    let name = &ast.ident;

    quote! {
        impl Named for #name {
            fn get_name(&self) -> &str {
               &self.name
            }
        }
    }.into()

}

然后将get_name()添加到struct中就很容易了：

use my_macro::NamedMacro;

#[derive(NamedMacro)]
struct USAGreeting{ name: String }
#[derive(NamedMacro)]
struct UKGreeting{ name: String }

您可以在此处阅读有关宏的信息
Procedural Macros
Macros

最通用的解决方案似乎是我最初的第三个要点：而不是一个特征，用一个泛型来创建一个结构，泛型的关联函数完成了功能。
对于最初的玩具Greeting的例子，Denys的答案可能是最好的，但是一个更一般的解决主要问题的方法是：

trait Locale {
  pub fn format_date() -> String;
}

pub struct Greeting<LOCALE: Locale> {
  name: String,
  locale: PhantomData<LOCALE>, // needed to satisfy compiler
}

impl<LOCALE: Locale> Greeting<LOCALE> {
  pub fn new(name: String) {
    Self {
      name,
      locale: PhantomData,
    }
  }

  pub fn greet() {
    format!("Hello {}\nToday is {}", self.name, LOCALE::format_date());
  }
}

pub struct UsaLocale;

impl Locale for UsaLocale {
  pub fn format_date() -> {
    // somehow get year, month, day
    format!("{}/{}/{}", month, day, year)
  };
}

pub type UsaGreeting = Greeting<UsaLocale>;
pub type UkGreeting = ...