Examinar a estrutura de programas orientados a objetos

11 minutos

A OOP (programação orientada a objeto) usa objetos para modelar entidades do mundo real.

Para desenvolvedores familiarizados com a programação estruturada, uma comparação entre programação estruturada e programação orientada a objetos pode ajudar a esclarecer as diferenças entre as duas abordagens. Além disso, aumentar a compreensão do encapsulamento e do ciclo de vida da classe pode ajudá-lo a desenvolver soluções seguras e robustas.

Comparar programação Object-Oriented com programação estruturada

A programação estruturada e a OOP (programação orientada a objetos) são duas abordagens distintas para o desenvolvimento de software, cada uma com seu próprio conjunto de princípios e metodologias. A programação estruturada baseia-se em uma abordagem de cima para baixo em que o programa é dividido em funções ou procedimentos menores e gerenciáveis. Essa abordagem enfatiza um fluxo claro e lógico de controle usando loops, condicionalidades e sub-rotinas. A programação orientada a objetos organiza o design de software em torno de objetos que encapsulam dados e comportamentos, promovendo uma estrutura de código mais modular e reutilizável. Embora a programação estruturada se concentre na sequência de ações a serem executadas, a programação orientada a objetos enfatiza os objetos envolvidos nas ações.

Podemos usar exemplos reais de projetos de construção como metáforas para ilustrar as diferenças entre programação estruturada e programação orientada a objetos.

exemplo de Programação Object-Oriented

Imagine a programação orientada a objetos como projetar e construir uma cidade. Nesta metáfora, cada edifício representa uma classe, e as salas e instalações de cada edifício representam as propriedades e métodos dessa classe. Assim como uma cidade é composta por vários edifícios, cada um atendendo a uma finalidade específica (residencial, comercial, industrial), um programa OOP é composto por várias classes, cada uma projetada para lidar com tarefas específicas. Os edifícios (classes) são construídos com base em blueprints (definições de classe) e cada edifício pode ter várias instâncias (objetos) que compartilham a mesma estrutura, mas podem ter estados diferentes (dados).

Nesta cidade, o encapsulamento é como as paredes de um edifício que protege sua estrutura interna e só permite o acesso por meio de portas e janelas designadas (métodos). O encapsulamento garante que o funcionamento interno de um edifício (classe) esteja oculto do mundo exterior, e as interações com o edifício sejam controladas e seguras.

Esta metáfora de construção da cidade destaca a natureza modular e reutilizável do OOP, onde cada classe (construção) pode ser desenvolvida, testada e mantida de forma independente, mas todas trabalham juntas para formar uma cidade coesa e funcional (programa). Assim como uma cidade bem planejada permite uma gestão e escalabilidade eficientes, um programa OOP bem projetado promove a manutenção, a flexibilidade e a escalabilidade.

Exemplo de programação estruturada

Imagine a programação estruturada como fazer uma colcha. Nesta metáfora, cada peça de malha representa uma função ou procedimento em seu programa. Assim como uma colcha é composta por muitos patches individuais costurados juntos, um programa estruturado é composto por várias funções que são projetadas para executar tarefas específicas. Cada função é como um patch que pode ser desenvolvido, testado e mantido de forma independente. Ao costurar esses patches em uma ordem específica, você cria uma colcha completa, assim como combina funções para formar um programa completo.

Na programação estruturada, o foco está no fluxo lógico de controle, assim como um colcha planeja o layout e a sequência de patches para criar um design coeso. A colcha garante que cada patch se ajuste perfeitamente com os outros, mantendo um padrão claro e organizado. Da mesma forma, um programador estruturado garante que cada função se ajuste perfeitamente ao programa geral, mantendo um fluxo claro e lógico de controle por meio do uso de loops, condicionais e sub-rotinas.

Esta metáfora de colcha destaca a natureza modular da programação estruturada, onde cada função (ou patch) pode ser reutilizado e reorganizado conforme necessário. Assim como um colchão pode substituir ou modificar patches individuais sem interromper toda a colcha, um programador pode atualizar ou refinar funções individuais sem afetar todo o programa. Essa modularidade torna a programação estruturada uma abordagem eficaz para criar um código claro, mantenedível e reutilizável. No entanto, à medida que o programa aumenta em tamanho e complexidade, o gerenciamento das interações entre funções pode se tornar mais desafiador. Assim como uma colcha com muitos patches pode se tornar desordada e difícil de gerenciar, um programa estruturado com inúmeras funções e procedimentos pode se tornar complicado e difícil de manter. À medida que o número de patches (funções) aumenta, torna-se mais desafiador acompanhar como eles se encaixam e interagem. Isso leva a problemas como duplicação de código, dificuldade na depuração e falta de coesão. Em aplicativos grandes, a abordagem linear e de cima para baixo da programação estruturada pode resultar em uma web emaranhada de funções interdependentes, dificultando a compreensão e modificação da base de código. Essa complexidade pode dificultar a escalabilidade e a manutenção, afetando, em última análise, a qualidade geral e o desempenho do software.

Examinar o uso de classes na Programação Object-Oriented

As classes são os blocos de construção da programação orientada a objetos (OOP) e são usadas para definir a estrutura e o comportamento dos objetos em um programa. Entender os benefícios fornecidos pelo encapsulamento e o ciclo de vida das classes ajuda você a entender como a programação orientada a objetos funciona.

Encapsulação

O encapsulamento é um dos princípios fundamentais da programação orientada a objetos (OOP). Refere-se ao agrupamento de dados (campos) e métodos (comportamentos) que operam nos dados em uma única unidade, normalmente uma classe. O encapsulamento restringe o acesso direto a alguns dos componentes de um objeto, o que pode impedir a modificação acidental de dados.

O encapsulamento oferece os seguintes benefícios:

Ocultação de dados: o encapsulamento permite que o estado interno de um objeto fique oculto do lado de fora. Isso significa que a representação interna de um objeto pode ser alterada sem afetar o código externo que usa o objeto. Por exemplo, usando campos privados e fornecendo métodos públicos getter e setter, você pode controlar como os dados são acessados e modificados.

Manutenção aprimorada: o encapsulamento facilita a manutenção e a modificação do código. As alterações na implementação interna de uma classe não afetam o código que usa a classe, desde que a interface pública permaneça a mesma. Essa separação de preocupações permite que os desenvolvedores se concentrem em partes específicas do código sem se preocupar com efeitos colaterais não intencionais.

Maior flexibilidade: o encapsulamento permite um código mais flexível e modular. Ao definir interfaces claras, você pode substituir ou atualizar facilmente partes do código sem afetar outras partes. Essa modularidade facilita a reutilização de código e a criação de sistemas complexos com base em componentes mais simples.

Segurança aprimorada: o encapsulamento ajuda a proteger a integridade dos dados de um objeto, impedindo o acesso e a modificação não autorizados. Ao controlar o acesso aos dados por meio de métodos, você pode impor regras e restrições sobre como os dados são usados. Essa imposição ajuda a evitar bugs e garantir que o objeto permaneça em um estado válido.

Abstração: o encapsulamento dá suporte ao conceito de abstração expondo apenas os detalhes necessários de um objeto para o mundo exterior. Isso simplifica a interface e facilita a compreensão e o uso do objeto. Os usuários do objeto não precisam conhecer a implementação interna, o que reduz a complexidade do código e melhora a legibilidade.

Nota

O encapsulamento é sobre ocultar os membros de dados de que os usuários de uma classe não precisam. Os membros de dados são encapsulados ou ocultos usando a palavra-chave do acessador private. O acesso a variáveis de campo ocultas é controlado usando propriedades e métodos. Os membros de dados ocultos não são diretamente acessíveis.


public class Person
{
    // Private fields
    private string firstName;
    private string lastName;
    private int age;

    // Public properties with getters and setters
    public string FirstName
    {
        get { return firstName; }
        set { firstName = value; }
    }

    public string LastName
    {
        get { return lastName; }
        set { lastName = value; }
    }

    public int Age
    {
        get { return age; }
        set
        {
            if (value >= 0)
            {
                age = value;
            }
            else
            {
                throw new ArgumentException("Age can't be negative");
            }
        }
    }

    // Public method
    public void Introduce()
    {
        Console.WriteLine($"Hi, I'm {FirstName} {LastName}, and I'm {Age} years old.");
    }
}

Neste exemplo:

Os campos firstName, lastNamee age são private, o que significa que eles não podem ser acessados diretamente de fora da classe.
As propriedades públicas FirstName, LastNamee Age fornecem acesso controlado aos campos privados.
A propriedade Age inclui lógica de validação para garantir que a idade não possa ser definida como um valor negativo.
O método Introduce fornece uma maneira de interagir com os dados do objeto sem expor os detalhes da implementação interna.

Ciclo de vida da classe

Em um aplicativo C#, o ciclo de vida de uma classe envolve vários estágios desde sua definição até sua eventual destruição. O ciclo de vida de uma classe inclui as seguintes etapas:

Definição de classe: defina a classe com seus membros.
Compilação: compile a classe no código IL.
Carregando: carregue o assembly na memória.
Instanciação: criar uma instância da classe.
Inicialização: inicialize os campos e as propriedades do objeto.
Uso: use o objeto no aplicativo.
Coleta de Lixo: recupere a memória do objeto quando ele não for mais necessário.
Destruição: executar a lógica de limpeza e liberar memória.

Aqui está um exemplo que inclui como explicação cada etapa no ciclo de vida de uma classe:

Definição de classe

Definição: uma classe é definida no código-fonte com suas propriedades, métodos e outros membros.

Por exemplo:


public class Person
{
    // auto-implemented properties for name and age
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public int Age { get; set; }

    // method to introduce the person
    public void Introduce()
    {
        Console.WriteLine($"Hi, I'm {FirstName} {LastName}, and I'm {Age} years old.");
    }
}

Compilação

Compilação: o código-fonte é compilado em um IL (linguagem intermediária) pelo compilador C#. O código IL é armazenado em um assembly (arquivo DLL ou EXE).

Por exemplo: a classe Person é compilada no código IL e incluída no assembly.
Carregamento

Carregamento: quando o aplicativo é executado, o CLR (Common Language Runtime) carrega o assembly na memória.

Por exemplo: o assembly que contém a classe Person é carregado na memória pelo CLR.
Instanciação

Instanciação: uma instância da classe é criada usando a palavra-chave new. O construtor da classe é chamado para inicializar o objeto.

Por exemplo:
```
Person person1 = new Person { FirstName = "Tim", LastName = "Shao", Age = 25 };
```
Inicialização

Inicialização: o construtor inicializa os campos e as propriedades do objeto. Qualquer lógica de inicialização definida no construtor é executada.

Exemplo: o objeto Personperson1 é inicializado com os valores especificados para FirstName, LastNamee Age.
Uso

Uso: o objeto é usado no aplicativo. Métodos e propriedades do objeto são acessados e modificados conforme necessário.

Por exemplo:
```
person1.Introduce();
```
Coleta de lixo

Coleta de Lixo: quando o objeto não é mais necessário e não há referências a ele, o coletor de lixo (GC) recupera a memória usada pelo objeto. O destruidor (finalizador) será chamado se estiver definido.

Exemplo: se person1 não for mais referenciado em nenhum lugar no código, o GC eventualmente recuperará sua memória.
Destruição

Destruição: a memória do objeto é liberada e qualquer lógica de limpeza definida no destruidor (o finalizador, se for especificado) é executada.

Exemplo: o objeto Personperson1 é destruído e sua memória é recuperada pelo GC.

Comentários

Esta página foi útil?