Abstracao

É o primeiro passo para formular o sistema. Primeiro precisamos analisar

nosso problema e projetar-lo orientado a objetos, isto é, quais objetos nosso
sistema tem e como eles se relacionam.

Como exemplo básico, temos um sistema de um banco:

O que tem um banco? Tem clientes, funcionários e contas.

A convenção de nomes em Java diz o seguinte:

classes sempre são substantivos e todas as palavras começam com letra

maiúscula:

public class MinhaClasse {

Public class Banco{

Metodos são verbos e atributos adjetivos.

Metodos e atributos somente a primeira palavra comeca com letra

minúscula e as restantes com maiúscula:

int nomeDoAtributo;

void nomeDoMetodo(){

Encapsulamento

Após projetar nosso sistema, precisamos encapsular as informações e ações

de cada classe. O encapsulamento é muito importante para que os usuários
de nossa classe não fazem usos estranhos e apenas se concentrem nas
suas classes. Isso otimiza a produtividade.

E m nosso exemplo, precisamos agora projetar as informações e ações que

nossas classes tem:

Nos concentramos agora na classe Conta. Uma conta “conhece” saldo,

limite e um titular.

Suas ações, a prori, são depositar, sacar e transferir.

Sempre as informações de um objeto só dizem respeito a ele, correto? Você

não sai por ai dizendo seu saldo no banco. Então sempre os atributos de
nossas classes serão privados.
Para isso, utilizamos a palavra-chave private:

private double saldo;

Metodos que serão públicos compõe a interface de nossa classe, ou seja,

são aqueles utilizados para haja relacionamento de nossas classes com seus
usuários. Sempre são públicos:

public double sacar(Double quantidade){

//código

Aqueles que são que auxiliares permanecem privados.

O estado de nossa classe Conta está assim:

public class Conta {

private double saldo;

public double sacar(double quantidade) {

saldo -= quantidade;

return quantidade;

Construtores

Construtores são aqueles que instaciam nossos objetos, i.e., criam um

objeto a partir de uma classe.

new Conta();

Em Java, a palavra-chave new cria nosso objeto na memoria, mas ainda não
temos como chegar nele. Para isso temos que referencia-lo:

Conta c; // Apenas estamos criando uma variável de referencia a um

objeto do tipo Conta

C = new Conta(); // Agora já podemos referenciar um objeto por c

Caso na tenha feito um construtor explicitamente, o compilador Java cria o

padrão, que tem a seguinte forma:

public Conta(){

Todo construtor deve ser publico.

Em nosso sistema de banco, toda conta deve ter um limite. Podemos
obrigar o usuário de nossa classe a ter que fornecer o valor do limite assim
que ele criar o objeto Conta. Para isso usamos o construtor:

public class Conta{

public Conta(Double novoLimite){

limite = novoLimite;

// métodos e atributos

E quando alguém for utilizar nossa classe, será obrigado a fazer isso:

Conta c = new Conta(2000.0);

Sobrecarga

Há varias maneiras de se fazer uma coisa. Voce pode somar apenas dois
números, ou três ou ate mais de uma única vez. Exemplo:

public int somar(int a, int b){

// codigo

public int somar(int a, int b, int c){

// codigo

Isso é a sobrecarga de um metodo, que tambem pode ser feita sobre o

constructor.

Atente-se ao fato de que a assinatura deve ser a mesma, apenas os

argumentos mudam:

public int somar(/* Aqui pode ser qualquer argumento que será tratado na
implementação*/)

Metodos GETTERS E SETTERS

Nossos atributos são privados, mas e quando precisamos disponibilizar-los

aos usuários de nossas classes? Para isso temos os métodos recuperadores
(getters) e os modificadores (setters).
Os métodos recuperadores apenas devolvem o valor contido no atributo,
não modificando nada:

public double getSaldo(){

return saldo;

Os metodos modificadores apenas modificam os atributos, a priori nao

devolvendo nada:

public void setTitular(String novoNome){

nome = novoNome;

As palavras get e set não são reservadas pelo Java, mas são um padrao
para os programadores e usuarios saberem que aqueles metodos sao para
acesso indireto em nossos atributos.

Cuidado com o uso indiscriminado desses métodos, analise se todos os

métodos precisam de get, e se todos realmente precisam ser modificados.
Um projeto mais inteligente ou utiliza dos construtores para modificar os
atributos logo no inicio, ou usam nomes que tem relação com o negocio do
sistema, por exemplo em nosso sistema de banco:

ao invés de usarmos o get: public double getSaldo()...

é mais usual: public double consultarSaldo()...,

e também vale aos modificadores: public void setSaldo(double novoSaldo)...

é mais inteligente: public void depositar(double novoSaldo)...

Interfaces

Anteriormente falei que a interface de uma classe é composta por métodos

públicos, pois estes se relacionam com as outras classes. Pois bem, em Java
você pode criar um interface que será como um protocolo entre você e os
usuários de sua classe. Para se criar uma interface, retiramos a palavra-
chave class e colocamos a interface:

public class InterConta{

public double sacar(double quantidade);

public double depositar(double deposito);

// outros metodos

}
Em uma interface somente vão as assinaturas de nossos métodos
PUBLICOS. Não precisamos colocar a implementação, ou seja , não abre
chaves, apenas a termine com o ponto-e-virgula (;).

E quando formos realmente criar a classe que será utilizada no sistema,

precisamos seguir rigorasamente este protocolo, se não o compilador
disparara mensagens de erro. Para isso isso utilize a palavra reservada
implements:

public class Conta implements InterConta {

// métodos e atributos

O Java so nos cobrara os métodos que estão na interface, ficamos a

vontade de colocar métodos auxiliares e atributos. Alem disso,
permite-se utilizar em uma mesma classe varias interfaces:

public class MinhaClasse implements Interface1, Interface2, Interface3 {

// metodos e atributos

Heranca

Muitas vezes temos classes que tem os mesmos metodos e atributos. Por
exemlo, temos em um banco a conta corrente e a conta poupança. Quando
a relação é um existir, temos a herança: conta corrente é uma conta? Sim,
então a classe ContaCorrente pode herdar de Conta . Para que
ContaCorrente herde de Conta, utilizamos a palavra-chave extends:

public class ContaCorrente extends Conta{

// métodos e atributos

Todo o codigo que está em Conta será herdado em ContaCorrente, não

precisando reescreve-lo, a não se que queira, alem de poder colocar mas
métodos e atributos que queira na classe que herda.

Em Java somente é permitida a herança simples, i.e., uma classe so herda

de outra classe. Para que se tenha algo como herança múltipla, utiliza-se de
interfaces.

A relação de herança entre classes pode ser descrita assim: se B herda de

A, então A é superclasse de B, e B é subclasse de A. Também existe a
denominação de que a superclasse é a classe mãe e a subclasse é a classe
filha.