Programação Orientada a Objetos em Rust - Guia Completo

Programação Orientada a Objetos em Rust 🦀

A programação orientada a objetos é um paradigma de programação que se concentra em objetos e suas interações. Rust é uma linguagem de programação moderna que tem crescido em popularidade nos últimos anos por sua combinação única de eficiência e segurança. Embora Rust não seja tradicionalmente considerada uma linguagem orientada a objetos, ela oferece suporte a muitos dos principais conceitos de programação orientada a objetos. Neste artigo, vamos explorar como implementar programação orientada a objetos em Rust.

Classes em Rust

Em Rust, as classes são definidas como estruturas (structs) e implementações (impls). Uma estrutura é a definição do objeto, enquanto uma implementação é a definição das funções que operam no objeto. Aqui está um exemplo básico de uma classe em Rust:

struct Retangulo {
    largura: i32,
    altura: i32,
}

impl Retangulo {
    fn area(&self) -> i32 {
        self.largura * self.altura
    }
}

Neste exemplo, temos uma estrutura chamada `Retângulo`, que tem dois campos: `largura` e `altura`. Também temos uma implementação para a classe `Retângulo` que define uma função `área` que calcula a área do retângulo.

Encapsulamento em Rust 💊

O encapsulamento é um dos principais conceitos da programação orientada a objetos. Ele nos permite esconder a implementação de um objeto e expor apenas a interface pública. Em Rust, podemos alcançar o encapsulamento usando `pub` e `priv`. O `pub` indica que um campo ou função é público e pode ser acessado por outros módulos ou structs. O `priv` indica que um campo ou função é privado e só pode ser acessado pela própria estrutura. Aqui está um exemplo de encapsulamento em Rust:

struct Pessoa {
    nome: String,
    idade: i32,
}

impl Pessoa {
    pub fn novo(nome: String, idade: i32) -> Pessoa {
        Pessoa {
            nome,
            idade,
        }
    }

    pub fn nome(&self) -> &str {
        &self.nome
    }

    priv fn idade(&self) -> i32 {
        self.idade
    }
}

Neste exemplo, temos uma estrutura `Pessoa` com dois campos: `nome` e `idade`. A função `novo` é pública e pode ser usada para criar uma nova instância de `Pessoa`. A função `nome` é pública e pode ser usada para obter o nome de uma pessoa. A função `idade` é privada e só pode ser acessada dentro da própria implementação `Pessoa`.

Herança em Rust

A herança é outro conceito importante da programação orientada a objetos. Ela nos permite criar novas classes baseadas em classes existentes, reutilizando o código já escrito. Em Rust, podemos alcançar a herança usando a palavra-chave `impl` e a sintaxe `: Parent`. Aqui está um exemplo de herança em Rust:

struct Pessoa {
    nome: String,
    idade: i32,
}

impl Pessoa {
    pub fn novo(nome: String, idade: i32) -> Pessoa {
        Pessoa {
            nome,
            idade,
        }
    }

    pub fn nome(&self) -> &str {
        &self.nome
    }

    priv fn idade(&self) -> i32 {
        self.idade
    }
}

struct Estudante: Pessoa {
    curso: String,
}

impl Estudante {
    pub fn novo(nome: String, idade: i32, curso: String) -> Estudante {
        Estudante {
            curso,
            ..Pessoa::novo(nome, idade)
        }
    }

    pub fn curso(&self) -> &str {
        &self.curso
    }
}

Neste exemplo, temos uma estrutura `Pessoa` com dois campos: `nome` e `idade`. A função `novo` é pública e pode ser usada para criar uma nova instância de `Pessoa`. A função `nome` é pública e pode ser usada para obter o nome de uma pessoa. A função `idade` é privada e só pode ser acessada dentro da própria implementação `Pessoa`. Em seguida, temos uma estrutura `Estudante` que herda de `Pessoa` e adiciona um novo campo `curso`. A função `novo` é pública e pode ser usada para criar uma nova instância de `Estudante`. A função `curso` é pública e pode ser usada para obter o curso de um estudante.

Polimorfismo em Rust

O polimorfismo é outro conceito importante da programação orientada a objetos. Ele nos permite tratar objetos de diferentes classes como se fossem da mesma classe. Em Rust, podemos alcançar o polimorfismo usando trait. Um trait é uma descrição abstrata de um comportamento que pode ser implementado por diferentes structs. Aqui está um exemplo de polimorfismo em Rust:

trait Forma {
    fn area(&self) -> i32;
}

struct Retangulo {
    largura: i32,
    altura: i32,
}

impl Forma for Retangulo {
    fn area(&self) -> i32 {
        self.largura * self.altura
    }
}

struct Circulo {
    raio: i32,
}

impl Forma for Circulo {
    fn area(&self) -> i32 {
        self.raio * self.raio * 3
    }
}

fn imprimir_area(forma: &impl Forma) {
    println!("A área é {}", forma.area());
}

Neste exemplo, temos um trait `Forma` que descreve o comportamento de calcular a área de uma forma. Temos duas estruturas `Retângulo` e `Círculo` que implementam o trait `Forma`. Em seguida, temos uma função `imprimir_área` que recebe qualquer objeto que implemente o trait `Forma` e imprime sua área. O objeto passado para a função pode ser de qualquer uma das duas estruturas.

Conclusão 📚

Neste artigo, exploramos a programação orientada a objetos em Rust. Vimos como criar estruturas, métodos, encapsulamento, herança e polimorfismo em Rust. Rust é uma linguagem poderosa e segura que oferece suporte à programação orientada a objetos, juntamente com outros paradigmas de programação. Com este guia completo, você deve ter uma boa compreensão dos conceitos básicos da programação orientada a objetos em Rust e estar pronto para começar a criar seus próprios projetos em Rust.