Rust 笔记：Rust 语言中的 结构体 与面向对象编程的实现

struct Person {
    name: String,
    age: u32,
}

let person1 = Person {
    name: String::from("Alice"),
    age: 25,
};

struct Point {
    x: f32,
    y: f32,
}

let origin = Point { x: 0.0, y: 0.0 };
println!("Origin: ({}, {})", origin.x, origin.y);

struct Rectangle {
    width: u32,
    height: u32,
}

let rect = Rectangle {
    width: 10,
    height: 20,
};

println!("Width: {}", rect.width);
println!("Height: {}", rect.height);

impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }
}

let rect = Rectangle {
    width: 10,
    height: 20,
};
println!("Area: {}", rect.area());

struct Circle {
    radius: f32,
}
impl Circle {
    fn new(radius: f32) -> Circle {
        Circle { radius }
    }
    fn area(&self) -> f32 {
        3.14 * self.radius * self.radius
    }
}

fn main() {
    let circle = Circle::new(5.0);
    println!("Area: {}", circle.area());
}

struct Car {
    make: String,
    model: String,
    year: u32,
}

let car = Car {
    make: String::from("Toyota"),
    model: String::from("Camry"),
    year: 2021,
};

let car = Car {
    make: String::from("Toyota"),
    model: String::from("Camry"),
    ..Default::default()
};

struct Person {
    name: String,
    age: u32,
    city: String,
}
impl Person {
    fn new(name: String, age: u32, city: String) -> Person {
        Person {
            name,
            age,
            city,
        }
    }
}

fn main() {
    let person1 = Person::new(String::from("Alice"), 25, String::from("New York"));
    let person2 = Person {
        name: String::from("Bob"),
        ..person1
    };
    println!("Person 1: {}, {}, {}", person1.name, person1.age, person1.city);
    println!("Person 2: {}, {}, {}", person2.name, person2.age, person2.city);
}

struct Rectangle {
    width: u32,
    height: u32,
}
impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }
    fn is_square(&self) -> bool {
        self.width == self.height
    }
}

let rect = Rectangle {
    width: 10,
    height: 20,
};
println!("Area: {}", rect.area());
println!("Is Square: {}", rect.is_square());

struct Circle {
    radius: f64,
}
trait Shape {
    fn area(&self) -> f64;
}
impl Shape for Circle {
    fn area(&self) -> f64 {
        3.14 * self.radius * self.radius
    }
}

let circle = Circle { radius: 5.0 };
println!("Area: {}", circle.area());

struct Square {
    side_length: u32,
}
trait Shape {
    fn area(&self) -> u32;
    fn perimeter(&self) -> u32;
}
impl Shape for Square {
    fn area(&self) -> u32 {
        self.side_length * self.side_length
    }
    fn perimeter(&self) -> u32 {
        4 * self.side_length
    }
}
impl Square {
    fn is_square(&self) -> bool {
        self.side_length > 0 && self.side_length == self.perimeter() / 4
    }
}

fn main() {
    let square = Square { side_length: 5 };
    println!("Area: {}", square.area());
    println!("Perimeter: {}", square.perimeter());
    println!("Is Square: {}", square.is_square());
}

struct Person(String, u32);
fn main() {
    let person = Person(String::from("Alice"), 25);
    println!("Name: {}", person.0);
    println!("Age: {}", person.1);
}

struct Person {
    name: String,
    age: u32,
}
struct Employee {
    person: Person,
    employee_id: u32,
}
fn main() {
    let person = Person {
        name: String::from("Alice"),
        age: 25,
    };
    let employee = Employee {
        person,
        employee_id: 12345,
    };
    println!("Name: {}", employee.person.name);
    println!("Age: {}", employee.person.age);
    println!("Employee ID: {}", employee.employee_id);
}

struct Shape {
    color: String,
}
struct Rectangle {
    shape: Shape,
    width: u32,
    height: u32,
}
struct Circle {
    shape: Shape,
    radius: f64,
}
fn main() {
    let red_rectangle = Rectangle {
        shape: Shape {
            color: String::from("red"),
        },
        width: 10,
        height: 20,
    };
    let blue_circle = Circle {
        shape: Shape {
            color: String::from("blue"),
        },
        radius: 5.0,
    };
    println!("Rectangle: {} x {}", red_rectangle.width, red_rectangle.height);
    println!("Circle: radius {}", blue_circle.radius);
    println!("Color: Rectangle - {}, Circle - {}", red_rectangle.shape.color, blue_circle.shape.color);
}

struct Person {
    name: String,
    age: u32,
}
impl Person {
    fn introduce(&self) {
        println!("My name is {} and I am {} years old.", self.name, self.age);
    }
}

fn main() {
    let person = Person {
        name: String::from("Alice"),
        age: 25,
    };
    person.introduce();
}