Programação Orientada a Objetos (POO) em Java

Classes
Oque são classes?
Classes em Java são como pasta onde você cria parte das funções, é como se fosse a estante de
livros.

Como criar as classes?

public class NomeDaClasse {

//tudo que você for fazer fica dentro dessas chaves

Depois de criar as classes você tem que declará-las na classe geralmente denominada “Main”
que é onde fica a linha executável do código.

public class Main{

public static void Main(String[] ags){

Na classe Main você tem que declarar o objeto/instância da seguinte forma:

NomeDaClasse NomeDoObjeto = new NomeDaClasse();

_____________________________________________________________________________

Herança
Herança é a ideia de herdar funcionalidades, métodos e variaveis(valores) da classe pai.

Como fazer uma classe que herda?

Você vai ter a classe pai com suas variaveis, métodos e tudo mais:

public class ClassePai{

String Teste = “Teste”; //Variável

public void HelloWorld(){

System.out.println(“Hello World”);

Então a partir disso você cria a classe filho que vai herdar as funcionalidades do pai:

public class ClasseFilho extends ClassePai{

//Qualquer coisa que você quiser fazer a mais você pode.

}
Pronto agora basta você criar o objeto para a classe que então você pode usar tudo da classe
pai mesmo sem ter nada na classe filho

ClasseFilho classefilho = new ClasseFilho();

E então você pode exibir as informações apenas chamando as:

Para chamar o método basta

classefilho.HelloWorld();

e para chamar a linha escrita “teste”

System.out.println(classefilho.Teste)

_____________________________________________________________________________

Encapsulamento
A ideia de encapsulamento se resume a literalmente encapsular algo para proteção dentro de
uma classe.

Quando você for criar uma variavel você usa o pré-fixo “private”.

private String Teste;

Então a variavel só pode ser acessada dentro da classe que ela foi criada certo?
Constructors
Você cria um constructor da seguinte forma:

public NomeDaClasse (String Teste Dentro você escreve todas as variáveis e seus tipos){

this.Teste = Teste; // O this. é para se referir a variavel lá de cima (o Java fica perdido), caso o
valor de dentro dos parênteses tivesse um nome diferente não seria necessário o this.

E então você cria os getter e setters

Getter e Setter
O propósito do Get é criar uma espécie de fantoche para a variável para que ela possa ser
acessível/chamada fora da classe, se cria um get assim:

public //tipo da variavel nesse caso String String getTeste(){

return Teste;

O propósito do Set é ter a possibilidade de atribuir um valor para a variável:

public void setTeste(String Teste){

Teste=Teste;

}
Para acessá-los você cria um objeto fora da classe

NomeDaClasse NomeDoObjeto = new NomeDaClasse(“teste”);

Usa o get para acessar a variável

System.out.println(NomeDoObjeto.getTeste);

Daí imprime o valor dela

Para atribuir um novo valor para a variável você usa o set

NomeDoObjeto.setTeste(“Atribuir o que você quiser”);

Obs: Mesmo que que não seja útil o encapsulamento em alguns casos, é sempre melhor usá-
lo do que deixar public

_____________________________________________________________________________

Polimorfismo
O polimorfismo em Java refere-se à capacidade de uma classe mais específica (subclasse)
fornece uma implementação especializada de um método que já está definido em sua classe
base (superclasse). Em outras palavras, é a capacidade de um objeto ser referenciado de várias
maneiras e executar métodos de acordo com o tipo real ao qual pertence.

Por exemplo, considere as classes A e B, onde B herda de A. A classe A possui um método

chamado Som(), que exibe o som comum dos pássaros, inicialmente definido como "bem-te-
vi". No entanto, ao criar a classe B para representar uma águia, podemos sobrescrever o
método Som() para fornecer um som diferente:

// Classe A (Som dos pássaros)

public class SomPassaros {

public void Som() {

System.out.println("bem-te-vi");

// Classe B (Águia)

public class SomAguia extends SomPassaros {

@Override
 public void Som() {

System.out.println("croac croac, cuá");

Na classe principal (Main), podemos criar objetos de ambas as classes e chamá-las de maneira
polimórfica:

public class Main {

public static void main(String[] args) {

SomPassaros somPassaros = new SomPassaros();

SomAguia somAguia = new SomAguia();

// Chamada polimórfica dos métodos

somPassaros.Som(); // Saída: bem-te-vi

somAguia.Som(); // Saída: croac croac, cuá

Dessa forma, mesmo chamando métodos com o mesmo nome (Som()), a execução resulta em
comportamentos diferentes com base no tipo real do objeto.

_____________________________________________________________________________

Abstract
O uso de Abstract segue a ideia de algo conter informações uteis suficientes para as subclasses,
mas que em si é tão genérico que fica confuso:

exemplos:

Classe Animal que contém o int idade e String Nome e um método para fazer o barulho do
animal, isso é tão genérico que ficaria confuso então a classe é declarada abstrato e os
métodos também para aquela classe se tornar "invisível", cria-se as dependências dessa classe
como exemplo um cavalo em que vai herdar as variaveis e métodos da classe genérica "animal"
e para os métodos usamos o polimorfismo já que não podemos criar um corpo para um
método abstrato e muito menos criar uma instancia (objeto) para a classe abstrata
// Classe abstrata

abstract class Animal {

// Método abstrato (sem implementação)

public abstract void emitirSom();

// Método concreto (com implementação)

public void dormir() {

System.out.println("Zzzz... O animal está dormindo.");

// Classe filha que estende a classe abstrata

class Cachorro extends Animal {

// Implementação do método abstrato

@Override

public void emitirSom() {

System.out.println("Au au!");

// Classe filha que estende a classe abstrata

class Gato extends Animal {

// Implementação do método abstrato

@Override

public void emitirSom() {

System.out.println("Miau!");

_____________________________________________________________________________
 Interfaces
Interfaces são como classes abstratas, porém com uma maior flexibilidade pois classes podem
“herdar” mais de uma interface.

Só pode ser criado uma interface a classe que somente tem métodos abstratos.

Uma interface e a palavra em si é como se fosse uma substituição da palavra “abstract class”.

Como cria uma interface?

public interface Teste {

void Teste();

1° aquele void se refere ao tipo do método, se for retornar algo tem que botar por exemplo o
double.

2° o método não tem corpo, ele vai ser definido na classe que importar a interface do mesmo
jeito que o abstract funciona e o polimorfismo.

Herança de interface
Interfaces podem herdar outras interfaces e por fim, as classes que implementar a interface
final vai ter todos os métodos e constantes das outras interfaces.

Constantes
Constantes são valores fixos que não podem ser mudados, e interfaces permitem implementá-
los.

Constantes devem ser criadas da seguinte forma

public static final (valor da constante ex: double) double PI = 3.14;

Outros tipos de constantes

fora do escopo de programação orientada a objetos, existe uma outra forma de declarar
constantes ex:

enum DiaDaSemana { SEGUNDA, TERCA, QUARTA, QUINTA, SEXTA, SABADO, DOMINGO };

basta usar a palavra-chave “enum” e listar a constante. Enums são tipos de dados especiais
que representam um conjunto fixo de valores.