Object-Oriented Programming in Rust

Overview

Chapter 17 of the Rust Book introduces Object-Oriented Programming (OOP) concepts and how they can be implemented in Rust. The chapter emphasizes using traits, structs, and enums to achieve polymorphism and encapsulation, which are core principles of OOP.

Key Concepts

1. Structs

• Definition: Structs are custom data types that can encapsulate related data.
• Usage: They allow you to create complex data types by grouping multiple values.

Example:

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

2. Traits

• Definition: Traits are similar to interfaces in other languages; they define shared behavior that can be implemented by different types.
• Usage: Traits allow for polymorphism, enabling different types to be treated the same way if they implement the same trait.

Example:

trait Shape {
    fn area(&self) -> f64;
}

impl Shape for Rectangle {
    fn area(&self) -> f64 {
        (self.width * self.height) as f64
    }
}

3. Enums

• Definition: Enums allow you to define a type that can be one of several variants. They can be used to model data that can take on different forms.
• Usage: Enums can also hold data, making them versatile for representing complex behaviors.

Example:

enum ShapeType {
    Circle(f64), // radius
    Rectangle(u32, u32), // width, height
}

4. Polymorphism

• Definition: Polymorphism allows functions to use entities of different types at different times.
• Usage: Achieved through traits, enabling functions to accept different types that implement the same trait.

Example:

fn print_area(shape: T) {
    println!("Area: {}", shape.area());
}

5. Encapsulation

• Definition: Encapsulation is the bundling of data and methods that operate on that data within one unit (like a struct) and restricting access to some of the object's components.
• Usage: In Rust, you can use pub and private visibility modifiers to control access to struct fields.

Conclusion

The chapter on OOP in Rust highlights how to use structs, traits, and enums to implement core OOP principles. Understanding these concepts is essential for writing robust and reusable Rust code. By using traits, you can define shared behavior and achieve polymorphism, while structs and enums help organize and encapsulate data effectively.