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!

Tópico com bug de formatação corrigido.

 

---------------------------------------------------

Tutorial muito bom, luan.

Tópico com bug de formatação corrigido.

 

---------------------------------------------------

Tutorial muito bom, luan.

Err.... tipo... a formatação ta bugada, da última vez que vi o tópico, estava formatado com codes e etc...

Muito bom cara, estou fazendo tec informática e to bem nessa materia vai ser de grande ajuda

@Snowsz, não sei dizer onde exatamente estavam os codes, pois no código bugado não aparece essa informação... :/