A Programação Orientada a Objetos (POO) é baseada no conceito de modelar objetos do mundo real e suas interações como objetos de software. Os dois blocos de construção fundamentais da POO são classes e objetos.

Uma classe é um blueprint ou template (projeto) para criar objetos. Ela define os atributos (também chamados de propriedades ou variáveis de instância) e métodos (também chamados de comportamentos ou funções de membro) que todos os objetos dessa classe terão.

Por exemplo, uma classe para um carro pode incluir atributos como cor, modelo e anoe métodos como partida, acelerar, e reduzir.

As classes são como formas de cupcakes, permitindo que você crie vários objetos que compartilham a mesma estrutura e comportamento.

Um objeto é uma instância de uma classe, com seu próprio conjunto valores únicos para os atributos definidos na classe. Quando um objeto é criado, diz-se que ele é instanciado a partir da classe.

Por exemplo, se temos uma classe Carro, podemos criar um objeto chamado myCar com atributos como marca="Honda", modelo="Civic" e ano="2022". Os objetos são como os cupcakes que são desenformados da forma - cada um é único, com seu próprio conjunto de características, mesmo que todos os cupcackes pareçam iguais, isso é o mesmo para objetos em POO.

Na POO, os objetos podem interagir uns com os outros enviando mensagens (também chamados de métodos ou funções de membro) uns para os outros. Por exemplo, se tivermos dois objetos criados a partir da classe carro, podemos enviar uma mensagem para um objeto de carro para acelerar, e uma mensagem para o outro objeto de carro para desacelerar. Isto é, chamamos as funções com estes nomes em cada objeto.

No geral, classes e objetos são os blocos de construção da Programação Orientada a Objetos (POO) e são essenciais para a criação de código modular, reutilizável e sustentável. Definindo classes que representam objetos do mundo real e criando objetos baseados nessas classes, os desenvolvedores podem criar sistemas de software poderosos e flexíveis que podem modelar cenários complexos do mundo real com facilidade.

A seguir, vamos entender melhor como pensar para modelar as classes e sua relação com os objetos.

Classes em POO

Na Programação Orientada a Objetos (POO), uma classe é um blueprint ou template para criar objetos. Ela define os atributos e métodos que todos os objetos dessa, do tipo desta classe terão. Os atributos (também chamados de propriedades ou variáveis de instância) representam os dados associados a um objeto, enquanto os métodos (também chamados de comportamentos ou funções de membro) representam as ações (comportamento) que um objeto pode executar.

As classes fornecem uma maneira de organizar o código em componentes reutilizáveis e modulares. Ao definir uma classe que representa um objeto ou conceito do mundo real, os desenvolvedores podem criar uma única base de código que pode ser usada para criar vários objetos com propriedades e comportamentos semelhantes. Essa abordagem ajuda a reduzir a duplicação de código e aumentar a capacidade de manutenção.

Para pensar e modelar classes em POO, é útil primeiro identificar os objetos ou conceitos que você deseja representar em seu programa. Por exemplo, se você estiver criando um jogo, poderá ter classes para jogadores, inimigos, armas e outros objetos de jogo. Depois de identificar os objetos, você pode começar a pensar sobre os atributos e métodos que eles precisarão.

Atributos

No contexto da programação orientada a objetos (POO), atributos são as propriedades ou características de um objeto. Eles definem os dados associados a um objeto e podem ser pensados como o “estado” do objeto em qualquer ponto no tempo. Os atributos podem armazenar valores simples, como cadeias de caracteres (strings) ou números, ou ainda armazenar estruturas de dados mais complexas, como matrizes (arrays) ou objetos.

Os atributos são definidos dentro de uma classe. Cada objeto criado a partir de uma classe terá seu próprio conjunto de valores de atributo que refletem seu estado atual. Por exemplo, se tivermos uma classe Pessoa com atributos para nome, idade, e endereço, cada instância da classe Pessoa que criarmos terá seus próprios valores para esses atributos.

Você aprenderá mais sobre os estados de instância e objeto nas próximas lições.

Os atributos podem ser acessados e modificados diretamente ou através de métodos, que são funções definidas dentro da classe que nos permitem manipular os valores das propriedades do objeto.

É importante observar que atributos definem os dados associados a um objeto, mas não são a classe em si. Por exemplo, em uma classe carro, marca, modelo e ano são atributos que definem os dados associados a um objeto do tipo carro, mas não são a classe de carro em si. A classe define a estrutura e o comportamento do objeto,
enquanto os atributos definem os dados, valores, associados ao objeto.

Como dados associados, os atributos podem ser considerados como containers (armazenadores) que contêm dados associados a um objeto. Isto é, cada atributo contém um dado, simples ou complexo.

Cada classe pode ter nenhum, um ou vários atributos, que podem conter um valor simples ou um valor complexo. Por exemplo, em uma classe Carro os atributos marca e modelo podem conter valores únicos, como “BMW” e “X5”, enquanto o atributo motor pode conter um valor complexo que inclui várias propriedades e métodos (o que significa, pode manter ou fazer uma referência a outro objeto do tipo Motor, criado a partir de uma classe Motor).

No geral, os atributos são um conceito fundamental na POO que nos permite representar os dados e as características dos objetos do mundo real em nossos aplicativos de software.

Métodos

No contexto da programação orientada a objetos (POO), um método é uma função definida (implementada) dentro de uma classe e pode ser chamada (executada) em um objeto dessa classe. Os métodos nos permitem definir os comportamentos e ações dos objetos e manipular os dados associados a esses objetos.

Os métodos são definidos dentro de uma classe usando uma sintaxe específica e podem usar parâmetros como funções regulares. Quando um método é chamado em um objeto, ele opera nos dados associados a esse objeto (propriedades) e pode modificar o estado do objeto. Por exemplo, um método setNome definido dentro de uma classe Pessoa pode usar um parâmetro string que representa um novo nome e atualizar o valor do atributo name para o objeto no qual ele é chamado.

No POO, todo o código é escrito nas classes, mas a execução é realizada pelos objetos. Quando criamos um objeto a partir de uma classe, estamos criando uma instância dessa classe, que tem seu próprio conjunto exclusivo de valores de atributo. Podemos então interagir com esse objeto chamando seus métodos, que executam ações com base nos valores de atributo do objeto.

Além de modificar o estado (valores armazenados nas propriedades) do objeto, os métodos também podem executar outras ações, como executar cálculos, interagir com sistemas externos, ler e gravar arquivos ou retornar informações sobre o objeto. Por exemplo, um método calcularDesconto pode ser escrito dentro de uma classe Produto para calcular um desconto no preço do produto e retornar o preço com desconto como resultado.

No geral, os métodos são um conceito-chave na POO que nos permitem definir os comportamentos e ações dos objetos em nossos aplicativos de software e interagir com os dados associados a esses objetos de forma estruturada e organizada.

Modelagem de classes na POO

Para modelar classes em Programação Orientada a Objetos (POO), é importante entender o as regras do negócio ou para o qual o software está sendo desenvolvido. Isso envolve identificar os objetos, conceitos e comportamentos que são relevantes para o domínio, e definir classes que podem modelar esses objetos e comportamentos de uma maneira natural e intuitiva para desenvolvedores e usuários finais.

Iniciando um exemplo POO de comércio eletrônico

Por exemplo, se estivermos desenvolvendo um site de comércio eletrônico, podemos identificar objetos como carrinho de compras de produtos, pedido e cliente como sendo relevantes para o domínio. Em seguida, definiríamos classes que representam esses objetos, com atributos e métodos que refletem suas características e comportamentos do mundo real.

Vamos começar criando uma classe Produto, que representará um produto em nossa loja online. Os usuários do sistema podem “usar” essa classe para pesquisar, inspecionar e adicionar produtos aos carrinhos de compras. Para começar com um exemplo simples, podemos definir atributos para a classe Produto, como nome, categoria e preco, que representam as informações básicas sobre o produto.

Além desses atributos, podemos definir métodos para a classe Produto que nos permitem manipular e trabalhar com the dados de produto. Por exemplo, podemos criar um método setPreco que nos permite atualizar o preço de um produto, ou um método calcularDesconto que aplica um desconto ao preço do produto com base em uma determinada porcentagem ou código de cupom.

Ao criar uma classe Produto com esses atributos e métodos, podemos começar a modelar o comportamento e as características de um produto do mundo real em nosso aplicativo de software.

A imagem a seguir é uma representação de nossa classe Produto (em inglês). A classe Produto pode ser representada visualmente usando a notação Unified Modeling Language (UML), conforme mostrado na imagem a seguir:

Classe de produto

Aqui está um exemplo de como a classe Produto pode ser criada no código:

class Product {
    public string $name;
    public string $category;
    public float $price;

    public function setPrice(float $newPrice): float {
        $this->price = $newPrice;
        return $newPrice;
    }

    public function calculateDiscount(float $discountPercentage): float {
        return $this->price * (1 - ($discountPercentage / 100));
    }
}

class Product {
    constructor(name, category, price) {
        this.name = name;
        this.category = category;
        this.price = price;
    }

    setPrice(newPrice) {
        this.price = newPrice;
        return newPrice;
    }

    calculateDiscount(discountPercentage) {
        return this.price * (1 - (discountPercentage / 100));
    }
}

class Product:
  def __init__(self, name, category, price):
    self.name = name
    self.category = category
    self.price = price

  def setPrice(self, newPrice):
    self.price = newPrice
    return newPrice

  def calculateDiscount(self, discountPercentage):
    return self.price * (1 - (discountPercentage / 100))

public class Product {
  public String name;
  public String category;
  public float price;

  public float setPrice(float newPrice) {
    this.price = newPrice;
    return newPrice;
  }

  public float calculateDiscount(float discountPercentage) {
    return this.price * (1 - (discountPercentage / 100));
  }
}

class Product {
  String name;
  String category;
  double price;

  double setPrice(double newPrice) {
    this.price = newPrice;
    return newPrice;
  }

  double calculateDiscount(double discountPercentage) {
    return this.price * (1 - (discountPercentage / 100));
  }
}

Na próxima lição, você aprenderá a criar objetos com base em nossa classe Product e começar a aproveitar suas funcionalidades.