Orientação a objetos

A orientação a objetos é um paradigma de programação que se baseia na organização e estruturação do código em torno de objetos, que são representações de entidades do mundo real. Esses objetos possuem características (atributos) e comportamentos (métodos) que podem ser definidos e manipulados de forma independente. A orientação a objetos visa a modularidade, reutilização de código e facilita o desenvolvimento de sistemas complexos.

Classe

Em programação orientada a objetos, uma classe é uma estrutura que define um tipo de objeto. Ela serve como um modelo para a criação de objetos, determinando quais atributos e métodos um objeto desse tipo pode ter. A classe é a base para a criação de instâncias de objetos, que são as ocorrências concretas da classe. As instâncias herdam os atributos e comportamentos definidos pela classe, mas também podem ter suas próprias características específicas.

Um exemplo de classe em orientação a objetos seria a classe "Carro". Essa classe poderia ter atributos como "cor", "modelo" e "ano", e métodos como "ligar", "acelerar" e "frear". A classe "Carro" serviria como um modelo para a criação de instâncias de carros específicos, onde cada instância teria seus próprios valores para os atributos e poderia executar os métodos definidos na classe.

Abaixo será meu código exemplo utilizado nos estudos.

package carro;

public class Carro {
  //Abaixo segue os atributos
  private String cor;
  private String modelo;
  private int ano;
  private double litrosTanque;
//final dos atributos

  // Método construtor
  public Carro(String cor, String modelo, int ano, double litrosTanque) {
      this.cor = cor;
      this.modelo = modelo;
      this.ano = ano;
      this.litrosTanque = litrosTanque;
      //final construtor
  }

  //getters e setters inicio
  public String getCor() {
      return cor;
  }
  public void setCor(String cor) {
      this.cor = cor;
  }

  public int getAno() {
      return ano;
  }
  public void setAno(int ano) {
      this.ano = ano;
  }

  public String getModelo() {
      return modelo;
  }
  public void setModelo(String modelo) {
      this.modelo = modelo;    }

  public double getLitrosTanque() {
      return litrosTanque;
  }
  public void setLitrosTanque(double litrosTanque) {
      this.litrosTanque = litrosTanque;
  }
  // getters e setters final

  //Metodos abaixo
  public void ligar() {
      // Lógica para ligar o carro
  }

  public void acelerar() {
      // Lógica para acelerar o carro
  }

  public void frear() {
      // Lógica para frear o carro
  }

  public void encherTanque(double litrosColocar) {
      this.litrosTanque += litrosColocar;
  }
  // final dos metodos
}

Atributo

Em orientação a objetos em Java, um atributo é uma variável que está associada a uma classe ou a uma instância dessa classe. Essas variáveis representam características ou propriedades dos objetos criados a partir da classe.

No exemplo do código fornecido, a classe "Carro" possui três atributos: "cor", "modelo" e "ano". Esses atributos são definidos como variáveis privadas e podem ser acessados e modificados por meio de métodos públicos, como "ligar", "acelerar" e "frear".

Os atributos permitem armazenar e representar informações específicas de cada objeto criado a partir da classe. Eles ajudam a definir o estado dos objetos e permitem que sejam manipulados e usados de acordo com as necessidades do programa.

É importante observar que os atributos são definidos dentro da classe, mas são inicializados e utilizados nas instâncias de objetos criadas a partir dessa classe. Cada instância possui seus próprios valores para os atributos, permitindo que diferentes objetos tenham características distintas.

Método

Método é uma função ou procedimento associado a uma classe em orientação a objetos. Ele define o comportamento dos objetos criados a partir da classe, permitindo que executem ações específicas ou realizem cálculos.

No exemplo do código fornecido, a classe "Carro" possui três métodos: "ligar", "acelerar" e "frear". Cada um desses métodos contém a lógica necessária para executar a ação correspondente. Por exemplo, o método "ligar" pode conter o código para ligar o carro, enquanto o método "acelerar" pode conter o código para acelerar o carro.

Os métodos podem receber parâmetros, que são valores passados para o método para que ele possa executar a ação desejada. Além disso, os métodos podem retornar um valor, que pode ser utilizado em outras partes do programa.

A definição de métodos em orientação a objetos permite que os objetos interajam entre si e com o ambiente de forma estruturada e controlada, tornando o código mais organizado, modular e reutilizável.

Método construtor é um tipo especial de método em uma classe que é usado para inicializar os objetos da classe. Ele é chamado automaticamente quando um objeto é criado a partir da classe. No exemplo do código fornecido, o método construtor da classe "Carro" pode ser adicionado da seguinte forma:

Nesse exemplo, o método construtor recebe os parâmetros "cor", "modelo", "ano" e "litrosTanque" e os utiliza para inicializar os atributos correspondentes do objeto. Assim, ao criar uma instância de carro, os valores passados para o método construtor serão atribuídos aos atributos do objeto.

Por exemplo, ao criar um objeto "meuCarro" da classe "Carro" com o método construtor, podemos fazer o seguinte:

Carro meuCarro = new Carro("vermelho", "Sedan", 2022, 50.5);

Dessa forma, o objeto "meuCarro" terá a cor "vermelho", modelo "Sedan", ano 2022 e um tanque com 50.5 litros.

O método construtor é útil para garantir que os objetos sejam criados de forma consistente e para realizar qualquer inicialização necessária antes de utilizar os objetos da classe.

Sobrecarga

Em Java, a sobrecarga ocorre quando uma classe tem dois ou mais métodos com o mesmo nome, mas com diferentes parâmetros.

A sobrecarga de métodos permite que você tenha vários métodos com o mesmo nome, mas que sejam diferenciados pela quantidade de parâmetros, pelo tipo dos parâmetros ou ambos. Isso proporciona flexibilidade ao programador, pois permite que diferentes versões do mesmo método sejam criadas para lidar com diferentes tipos de entrada ou comportamentos.

Por exemplo, na classe "Calculadora", podemos ter vários métodos chamados "somar" para lidar com diferentes tipos de dados. Podemos ter um método "somar" para adicionar dois inteiros, outro método "somar" para adicionar dois números de ponto flutuante e assim por diante. Cada método de soma teria uma assinatura diferente, ou seja, teria uma lista de parâmetros diferente.

A sobrecarga de métodos é determinada pelo número de parâmetros, pelo tipo dos parâmetros e pela ordem dos parâmetros. Isso significa que você pode ter métodos com o mesmo nome, desde que eles tenham uma assinatura diferente. A assinatura de um método é composta pelo nome do método e pelos tipos e ordem dos seus parâmetros.

Ao chamar um método sobrecarregado, o compilador Java determina qual versão do método deve ser chamada com base nos argumentos passados. Isso é conhecido como resolução de sobrecarga.

A sobrecarga de métodos é uma técnica poderosa em Java que permite criar código mais legível e fácil de usar, fornecendo diferentes maneiras de interagir com o mesmo método, dependendo das necessidades do programador.

Objeto e mensagem

Um objeto é uma instância de uma classe.

Carro meuCarro = new Carro("vermelho", "Sedan", 2022, 50.5);

Uma mensagem é uma solicitação enviada a um objeto para que ele execute um método. No caso do carro, uma mensagem "ligar" solicitaria ao objeto que execute o método "ligar”

Para ligar o carro, podemos usar o seguinte código

meuCarro.ligar();

Este código irá chamar o método `ligar()` do objeto `meuCarro`.

Exemplo pratico visto

package carro;
import java.util.Scanner;

public class novoCarro{

  public static void main (String[]args){
      Scanner sc = new Scanner(System.in);
      Carro gol = new Carro("Azul", "Gol Quadrado", 2021, 15.8);

      System.out.println("O seu carro e um " + gol.getModelo() + " da cor " + gol.getCor() + " do ano de " + gol.getAno());

              gol.encherTanque(20);.
      System.out.println(gol.getLitrosTanque());
  }
}

Pilares POO

Encapsulamento

O encapsulamento é um dos três pilares da programação orientada a objetos (POO), juntamente com a herança e o polimorfismo. Ele consiste em esconder os detalhes de implementação de uma classe, expondo apenas uma interface pública para interagir com ela.

Em Java, o encapsulamento é implementado usando modificadores de acesso. Os modificadores de acesso são palavras-chave que determinam quem pode acessar os membros de uma classe.

Os modificadores de acesso em Java são:

• public: acessível de qualquer lugar do programa.
• private: acessível apenas dentro da própria classe.
• protected: acessível dentro da classe e pelas classes derivadas.
• package-private: acessível dentro do mesmo pacote.

Herança

Herança é o mecanismo que permite que uma classe herde os atributos e métodos de outra classe. A classe que herda é chamada de subclasse, e a classe de onde herda é chamada de superclasse. Por exemplo, a classe Animal pode ser a superclasse de Cachorro e Gato. Nesse caso, as classes Cachorro e Gato herdarão os atributos e métodos da classe Animal, como comer(), dormir() e respirar().

Exemplo:

class Carro extends Veiculo {

private int qtdePortas;

public Carro(String modelo, int ano, int qtdePortas) {
  super(modelo, ano);
  this.qtdePortas = qtdePortas;
}

@Override
public void acelerar() {
  System.out.println("Acelerando o carro...");
}

@Override
public void frear() {
  System.out.println("Freando o carro...");
}

@Override
public void virar() {
  System.out.println("Virando o carro...");
}
}

class Caminhao extends Veiculo {

private double carga;

public Caminhao(String modelo, int ano, double carga) {
  super(modelo, ano);
  this.carga = carga;
}


//Continuando explicação

public void acelerar() {
  System.out.println("Acelerando o caminhão...");
}

@Override
public void frear() {
  System.out.println("Freando o caminhão...");
}

@Override
public void virar() {
  System.out.println("Virando o caminhão...");
}
}

public class Teste {

public static void main(String[] args) {
  Carro carro = new Carro("Gol", 2023, 4);
  carro.acelerar();
  carro.frear();
  carro.virar();

  Caminhao caminhao = new Caminhao("Scania", 2022, 10000);
  caminhao.acelerar();
  caminhao.frear();
  caminhao.virar();
}
}

Abstração

Abstração é o mecanismo que permite ocultar os detalhes de implementação de uma classe. A classe abstrata é uma classe que não pode ser instanciada. Ela serve apenas como um modelo para outras classes que dela herdam.

Figura Geometrica pode ser uma classe abstrata. Essa classe pode definir métodos abstratos, que devem ser implementados nas classes derivadas.

A abstração é um mecanismo importante para a modularização do código. Ao abstrair as funcionalidades de uma classe, podemos torná-las mais fáceis de entender e usar.

Exemplo

abstract class Veiculo {

protected String modelo;
protected int ano;

public Veiculo(String modelo, int ano) {
  this.modelo = modelo;
  this.ano = ano;
}

public abstract void acelerar();

public abstract void frear();

public abstract void virar();
}
}

Polimorfismo

O polimorfismo é um conceito da programação orientada a objetos que permite que objetos de classes diferentes tenham comportamentos diferentes ao receberem a mesma mensagem. Em Java, o polimorfismo é implementado por meio da herança e da sobrecarga de métodos.

public class Carro {

  private String modelo;
  private String marca;
  private int ano;

  public Carro(String modelo, String marca, int ano) {
      this.modelo = modelo;
      this.marca = marca;
      this.ano = ano;
  }

  public void acelerar() {
      System.out.println("O carro está acelerando");
  }

  public void frear() {
      System.out.println("O carro está freando");
  }

  public void virar() {
      System.out.println("O carro está virando");
  }
}

Essa classe define os métodos básicos para acelerar, frear e virar um carro.

Agora, vamos criar uma subclasse de Carro chamada Ferrari.

Essa subclasse redefine o método acelerar para imprimir uma mensagem diferente.

public class Ferrari extends Carro {

  public Ferrari(String modelo, String marca, int ano) {
      super(modelo, marca, ano);
  }

  @Override
  public void acelerar() {
      System.out.println("O Ferrari está acelerando muito rápido");
  }

}

Interface

Uma interface em Java é uma definição de um contrato que uma classe deve implementar. Um contrato é um conjunto de métodos e atributos que uma classe deve fornecer.

No exemplo de um carro, podemos definir uma interface chamada Veiculo que define os seguintes métodos:

public void acelerar();
public void frear();
public void virar();

Qualquer classe que implementar a interface Veiculo deve fornecer uma implementação para esses métodos.

Por exemplo, a classe Carro pode implementar a interface Veiculo da seguinte forma:

public class Carro implements Veiculo {


  public void acelerar() {
      // Código para acelerar o carro
  }

  public void frear() {
      // Código para frear o carro
  }

  public void virar() {
      // Código para virar o carro
  }
}