Seguinte pessoal, estou estudando POO em Java e decidi compartilhar com vocês!
1 - Criando uma classe:
Primeiramente definimos qual será a classe que iremos criar, após escolher pense nas possíveis características/atributos e ações/métodos que tal objeto pode ter. Por exemplo, minha classe será uma Conta de Banco ...
Possíveis características/atributos do objeto:
• número da conta
• dono
• saldo
Obs: lembrando que quando definimos um atributo precisamos colocar antes o tipo de dados que ele representa, por exemplo: int (de inteiro), double (de um ponto flutuante), String (de conjunto de palavras), boolean (de valor lógico), etc ..
Possíveis Ações do objeto/métodos:
• sacar um valor
• depositar um valor
• mostrar o dono da conta
• mostrar o saldo atual
Agora podemos começar criar nossa classe Conta:
class Conta {
// Atributos
int numero;
String dono;
double saldo;
// Métodos
usuario()
saldo()
sacar()
depositar()
}
Pronto, inicialmente criamos nossa nova classe Conta.
2 - Definir Métodos Getters e Setters:
Normalmente (não sempre) o método setter irá começar com void e o método getter irá começar com o tipo de dados que vai retornar.
Os métodos podem receber parâmetro(s) de entrada, definido pelo tipo de dados no começo.
// Getters
String usuario() {
return dono;
}
Double saldo() {
return saldo;
}
// Setters
void sacar(double valor) {
if (saldo >= valor) {
saldo = saldo - valor; //ou this saldo -= valor;
} else {
System.out.println("Seu saldo é insuficiente.");
}
}
void depositar(double valor) {
saldo = saldo + valor; //ou this saldo += valor
}
Obs: Você pode, ou não usar this.atributo para referenciar um atributo da classe, porem ele é mais utilizado quando quando o nome do atributo é o mesmo nome de algum parâmetro de entrada do método. Por exemplo:
void depositar(double saldo) {
this.saldo = this.saldo + saldo; //ou this saldo += saldo
}
3 - Definindo Encapsulamento da Classe:
Podemos proteger nossa classe, atributos e métodos com o encapsulamento, definindo seu modificador de acesso. Existem 4 tipos de modificadores de acesso:
• public: Deixa o atributo, método ou classe acessível por qualquer um em todo o projeto.
• private: Deixa o atributo ou método acessível apenas dentro da classe à qual pertence.
• protected: Deixa o atributo ou método acessível dentro de todo o pacote e também nas subclasses da classe ao qual pertence, podendo ser estas subclasses de outros pacotes do projeto.
• default (sem modificador): todas as classes do mesmo pacote tem acesso ao atributo, construtor, método ou classe.
- Uma regra básica de proteção é definir a classe como public, seus atributos como private e determinados métodos como public e outros como private (dependendo do grau de segurança de determinado método).
Ficando assim:
public class Conta {
// Atributos
private int numero;
private String dono;
private double saldo;
// Métodos Getters
public String usuario() {
return dono;
}
public Double saldo() {
return saldo;
}
// Métodos Setters
public void sacar(double valor) {
if (saldo >= valor) {
saldo -= valor;
} else {
System.out.println("Seu saldo é insuficiente.");
}
}
public void depositar(double valor) {
saldo += valor;
}
}
4 - Método construtor:
O método construtor é o responsável por criar um objeto da classe, podendo criar-los com parâmetros iniciais ou não, Caso não tenha parâmetros não precisa declara-lo no código, pois ele funcionará como default (criando um objeto sem parâmetros de entrada). Cada construtor deve ser escrito de acordo com a necessidade de cada classe.
Crie seu método construtor com o mesmo nome da classe (o método construtor não precisa da palavra reservada void, apenas do encapsulamento).
Por exemplo:
// Método construtor sem parâmetros (ele é um padrão, não é necessário cria-lo)
public Conta() {}
// Método construtor com parâmetros
public Conta(int numero, String dono, double saldo) {
this.numero = numero;
this.dono = dono;
this.saldo = saldo;
}
5 - Instanciando um objeto:
Cria o arquivo principal de seu projeto (normalmente Class Main ou Class Principal), e defina o método public static void main(String[] args) nela, e dentro dele iremos instanciar o objeto que você criou anteriormente.
Defina assim: Classe_Nome Objeto_Especifico = new Classe_Nome(parametros)
No exemplo da classe Conta, ficaria assim:
Conta conta1 = new Conta(1, "Luan", 1000.0); // ou seja, defini os parametro numero = 1, dono = "Luan" e saldo = 1000.0
Agora para usar os métodos da classe ficaria assim:
conta1:depositar(100.0) // do saldo de 1000.0 irá adicionar 100.0 ficando 1100.0
conta1:usuario() // irá retornar o dono da conta, no caso: "Luan"
conta1:sacar(1099.0) // do saldo de 1100.0 irá retirar 1099.0 ficando 1.0
conta1:saldo // irá retornar o saldo atual da conta, no caso: 1.0
Irá fica assim a classe principal:
public class AulaJava {
public static void main(String[] args) {
Conta conta1 = new Conta(1, "Luan", 1000.0); // ou seja, defini os parametro numero = 1, dono = "Luan" e saldo = 1000.0
conta1:depositar(100.0) // do saldo de 1000.0 irá adicionar 100.0 ficando 1100.0
conta1:usuario() // irá retonar o dono da conta, no caso: "Luan"
conta1:sacar(1099.0) // do saldo de 1100.0 irá retirar 1099.0 ficando 1.0
conta1:saldo // irá retonar o saldo atual da conta, no caso: 1.0
}
}
6 - Herança (também conhecida como especialização ou generalização):
• A Herança é uma ótimo ferramenta de reuso para POO.
• Na herança temos a classe pai (super classe, classe generalizada), e as classes filhas (subclasses, classes especializadas).
• As classes filhas herdam os atributos e métodos da classe pai (quando o modificador de acesso é protected, public ou default), exceto as privadas.
É necessário indicar a classe qual ele herdará, definindo no cabeçalho da classe: class Subsclasse_Name extendes Classe_Super {}
Outra mudança é no método construtor da classe filha, que além de definido os atributos especificos, pode usar um método particular para definir os atributos da classe Pai: SUPER.
Por exemplo, imaginemos que os parametros 1 e 2 definem atributos já existentes na classe Pai, e o parametro 3 defini um atributo da class filha, ficará assim:
Contrutor (parametro1, parametro2, parametro3) {
super(parametro1, parametro2);
this.atributo = parametro3;
}
Como estou estudando, quero aprender CORRETAMENTE, portanto, quem ver algo errado, por favor diga e me ajude, criticas construtivas são sempre bem-vindas!