Programação Orientada a Objetos com Java

Programação
Orientada a Objetos
com Java
19/09/2014

Direitos Autorais
Você está autorizado e incentivado a distribuir este material.
Copie, compartilhe e modifique, apenas cite a fonte.

Direitos Autorais
Luiz Ricardo
luizricardo.org
facebook.com/StateOfTheArtBlog

Objetos
• Estado
• Atributos e Características
• Comportamento
• Ações

Classe
• Tipo base para objetos, um “Molde”
class Classe {
}
objeto = new Classe()

Classe
class Carro {
}
Carro meuCarro = new Carro();

Estrutura da Classe
Classe
Atributos
Métodos

Atributos
class Carro {
String marca;
String cor;
int ano;
int velocidade = 0;
}

Acesso a Atributos
carro.velocidade = 1;
int velocidade = carro.velocidade;

Métodos
class Carro {
void acelerar() {
velocidade++;
}
}

Parâmetros
class Carro {
void quadrado(double numero){
return numero * numero;
}
}

Parâmetros
class Carro {
int velocidade = 0;
void mudarVelocidade(int velocidade){
???
}
}

Parâmetros
class Carro {
int velocidade = 0;
void mudarVelocidade(int velocidade){
this.velocidade = velocidade;
}
}

Retorno
class Carro {
int lerVelocidade() {
return velocidade;
}
}

Execução de Métodos
carro.aumentarVelocidade(2);
int v = carro.lerVelocidade();

Exercícios
1. Implemente uma classe chamada Cliente que tenha um
código, nome, idade, CPF e e-mail.
2. Implemente um método que:
– Receba dois clientes; e
– Retorne os seus respectivos e-mails separados por vírgula.

Sobrecarga
class Carro {
void aumentarVelocidade(int quantidade) {
this.velocidade += quantidade;
}
void aumentarVelocidade() {
this.velocidade++;
}
}

Sobrecarga
carro.aumentarVelocidade(10);
carro.aumentarVelocidade();

Exercícios
3. Continue do exercício 2, mas agora implemente um
método que receba três clientes e retorna seus e-mails.
4. Faça o mesmo para um array de clientes

Encapsulamento
Você não quer outras pessoas fuxicando nos
atributos da sua classe, não é?

Encapsulamento
public class Carro {
int velocidade = 0;
}
meuCarro.velocidade = 1000000000;
meuCarro.velocidade = -7;

Métodos de Acesso
• Padrão Java Bean
– Getters, para recuperar valores
– Setters, para definir ou alterar valores

Getter e Setter
int velocidade = 0;
void setVelocidade(int velocidade) {
}
int getVelocidade() {
return velocidade;
}
}

Modificadores de Acesso
private int velocidade = 0;
public void setVelocidade(int velocidade) {
}
public int getVelocidade() {
return velocidade;
}
}

Modificadores de Acesso
public void setVelocidade(int velocidade) {
if (velocidade >= 0 && velocidade < 160)
}
}

Acoplamento
É a interdependência entre as classes

Coesão
Envolve a divisão de responsabilidades entre as
classes

Acoplamento e Coesão
• Acoplamento forte, baixa coesão
– Ruim
• Acoplamento fraco, alta coesão
– Bom

Exercícios
5. Altere a classe Cliente e as demais classes dos exercícios
anteriores aplicando os conceitos de encapsulamento,
acoplamento e coesão.
Dica: crie uma outra classe MailUtil com os respectivos
métodos.
6. Implemente uma classe Bicicleta, crie duas instância de
cores e marcas diferentes, faça elas correrem a 20 e
30km/hora.

Instanciação
Carro carro = new Carro();

Construtores
private int velocidade;
public Carro(int velocidadeInicial) {
this.velocidade = velocidadeInicial;
}
}

Instanciação
Carro carro = new Carro(10);

Exercício 7
Modifique o Cliente criado anteriormente de
forma que os valores dos atributos sejam
definidos através de um construtor.

Atributos estáticos
private String marca;
public Carro(String marca) {
this.marca = marca;
}
public void imprimeMarca() {
System.out.println(marca);
}
}
Atributo “comum” de instância

Qual o resultado?
Carro gol = new Carro("Gol");
Carro palio = new Carro("Palio");
gol.imprimeMarca();
palio.imprimeMarca();

private static String marca;
public Carro(String marca) {
Carro.marca = marca;
}
public void imprimeMarca() {
System.out.println(marca);
}
}
Atributo estático

Métodos estáticos
public class ConexaoComBanco {
public static Conexao abrirConexao() {
return new Conexao(
servidor, usuario, senha);
}
}

Exercícios
8. Crie um método estático que calcule a raiz quadrada de um
número. Utilize o método estático sqrt da classe Math.
9. Altera a classe MailUtil do exercício 5 para que os métodos
sejam estáticos
10. Crie uma classe que conte o número de instâncias criadas
dela mesma.

Herança
Variação
Veiculo
Carro Motocicleta

Herança
Especialização
Carro
CarroDePasseio CarroDeCorrida

Herança
class Veiculo {
void acelerar() {
velocidade++;
}
void frear() {
velocidade--;
}
}
Superclasse

Herança
class Carro extends Veiculo {
private boolean vidrosAbertos;
void abaixarVidros() {
vidrosAbertos = true;
}
void levantarVidros() {
vidrosAbertos = false;
}
}
Subclasse (1)

Herança
class Motocicleta extends Veiculo {
boolean cavaleteAbaixado = false;
void apoiarCavelete() {
cavaleteAbaixado = true;
}
}
Subclasse (2)

Herança
Carro é um Veículo
Carro c = new Carro();
c.abaixarVidros();
c.acelerar();

Herança
Motocicleta é um Veículo
Motocicleta m = new Motocicleta();
m.acelerar();
m.frear();
m.apoiarCavalete();

Herança
class Veiculo {
public int velocidade;
protected int velocidade;
}
void acelerar() {
velocidade++;
}
}
Visibilidade nas Subclasses

Herança
class Carro{
protected int velocidade;
public void acelerar() {
velocidade++;
}
}
class CarroDeCorrida extends Veiculo {
@Override
velocidade += 10;
}
}
Sobrescrita de Métodos

Herança
Executando um Método Sobrescrito
class Carro{
velocidade++;
}
}
class CarroDeCorrida extends Veiculo {
@Override
super.acelerar();
}
}

Herança
Vários Níveis de Herança
Veiculo
Carro
Gol

Herança
Vários Níveis de Herança
class Veiculo {
}
}
class Gol extends Carro {
}

Herança
class Carro
extends Veiculo, MeioDeTransporte {
}
Herança Múltipla Não Existe

Exercício 11
• Crie uma hierarquia de pessoas.
• A superclasse deve chamar-se Pessoa.
• Crie algumas subclasses para diferentes
tipos de pessoas (PF, PJ?).
• Defina atributos e comportamentos gerais
e especializados para cada tipo de
pessoa.

Classes e Métodos Abstratos
abstract class Veiculo {
abstract void acelerar();
}
void acelerar() {
velocidade++;
}
}

Exercício 12
• Altere a classe Pessoa do exercício 11 de
forma que ela seja abstrata.

Classes e Métodos Abstratos
abstract class Ordenacao {
abstract int comparar(
Object a, Object b);
void ordenar(Object[] v) {
//bubble sort
}
}
Strategy Pattern

Exercício 13
• Use o método de ordenação Bolha e
implemente uma classe concreta usando
o Strategy Pattern, conforme proposto no
slide anterior.
for (int i = 0; i < v.length; i++) {
for (int x = 1; x < v.length - i; x++) {
if (comparar(v[x - 1], v[x]) > 0) {
Object aux = v[x - 1]; v[x - 1] = v[x]; v[x] = aux;
}
}
}

Herança?
Tem algo podre no reino da Dinamarca

Herança?
Ave
void voar()
Beija-flor Pardal

Herança?
Ave
Beija-flor Pardal
void voar()
Avestruz
???

Interfaces
Ao resgate!
• Contrato de comportamento
• Todos os métodos abstratos
• É uma classe 100% abstrata

Interfaces
interface Veiculo {
void acelerar();
void frear();
}
Declarando

Interfaces
interface Veiculo {
void acelerar();
void frear();
}
public Carro implements Veiculo {
public void acelerar() { }
public void frear() { }
}
Implementando

Interfaces
interface Voador {
void voar();
}
interface Corredor {
void correr();
}
interface Falador {
void falar();
}

Interfaces
class Papagaio implements Voador, Falador {
public void voar() { }
public void falar() {
System.out.printlmn("Loro!");
}
}
class Cachorro implements Corredor, Falador {
public void correr() { }
public void falar() {
System.out.println("Au! Au!");
}
}
Implementando várias Interfaces

Exercício 14
Trabalhando com Abstração
• Crie a interface ContaCliente, com
métodos para consultar o saldo, debitar e
creditar dinheiro.
• Implemente um método transferencia
que receba duas contas e um valor e
execute a transação necessária.

Polimorfismo
• A capacidade de um mesmo objeto de se
apresentar de várias formas
Papagaio papagaio = new Papagaio();
Voador bichoQueVoa = papagaio;
Falador bichoQueFala = new Papagaio();

Polimorfismo
• Um tipo mais específico sempre pode ser
atribuído a uma variável de tipo mais
genérico, nunca o contrário.
Voador bichoQueVoa = papagaio;
Papagaio papagaio = bichoQueVoa;

Polimorfismo
Cast
• Força uma “conversão”
• Não afeta o objeto
• Pode resultar em erro se não for do
mesmo tipo
Papagaio papagaio = (Papagaio) bichoQueVoa;

Polimorfismo
Verificando o Tipo
if (bichoQueVoa instanceof Papagaio) {
System.out.println("Sim, é um papagaio!");
} else {
System.out.println("Não é um papagaio!");
}

Exercício 15
• Usando o exemplo de polimorfismo com
animais, Implemente um método que
receba um Voador e descubra se ele é
um Papagaio.
• Execute o método duas vezes, uma
passando uma instância de Papagaio e
depois outra subclasse de Voador.

Exceções
• Classes que representam erros de
execução
• Criadas pelo Java ou manualmente
• Objeto contém informações do erro
– Descrição, Mensagem, Local

Exceções
Lançando uma Exceção
throw new Exception("Meu próprio erro")

Exceções
Novas Exceções
class ErroPersonalizadoException
extends Exception {
}

Exceções
Hierarquia de Classes
Throwable
Error Exception
RuntimeException
SQLException IOException
ArrayIndexOutOfBoundsException NumberFormatException NullPointerException
Verificadas e Não Verificadas

Exceções
• Exception
Categorias
– Erros esperados pelo programa
• RuntimeException
– Erros inesperados do programa
• Error
– Erros anormais, totalmente inesperados

Exceções
Tratar uma Exceção
void verificarNome(String nome) throws Exception {
if (nome == null) {
throw new Exception("Nome não preenchido!");
}
}
void meuMetodo() {
try {
verificarNome(null);
} catch(Exception e) {
e.printStackTrace();
}
}

Exceções
Repassar uma Exceção
void verificarNome(String nome) throws Exception {
if (nome == null) {
throw new Exception("Nome não preenchido!");
}
}
void meuMetodo() throws Exception {
}

Exceções
Ignorar uma Exceção Não Verificada
void verificarNome(String nome) {
if (nome == null) {
throw new RuntimeException(
"Nome não preenchido!");
}
}
void meuMetodo() {
}

Exceções
Exceções “Inesperadas”
• Por que ocorrem?
• Causas frequentes:
– Casos não previstos
– Falta de atenção ao codificar
– Suposições “ingênuas” sobre inputs

Exceções
Exceções “Inesperadas”
void criarVeiculo(char tipo) {
Veiculo veiculo = null;
if (tipo == 'C') {
veiculo = new Carro();
} else (tipo == 'M') {
veiculo = new Motocicleta();
}
veiculo.acelerar();
}
!?

Exercício 16
• Crie duas novas exceções:
– ValidacaoException (verificada)
– ParametroInvalidoException (não verificada)
• Implemente um método validarCPF que receba uma String
e lance a exceção verificada no caso dela não ter 11
caracteres e lance a exceção não-verificada se o parâmetro
for nulo
• Implemente outro método que chame a validação e trate
apenas a exceção verificada

Coleções
Listas
List<String> minhaLista = new ArrayList<String>();
minhaLista.add("Arroz");
minhaLista.add("Feijão");
minhaLista.add("Farinha");
System.out.println( minhaLista.get(0) );

Coleções
Listas
List minhaLista = new ArrayList();
minhaLista.add("Arroz");
minhaLista.add("Feijão");
minhaLista.add("Farinha");
System.out.println( minhaLista.get(0) );

Coleções
Conjuntos
Set<Integer> meuConjunto = new HashSet<Integer>();
meuConjunto.add(1);
meuConjunto.add(2);
meuConjunto.add(3);
meuConjunto.add(1);
System.out.println(meuConjunto);

Coleções
Mapas
Map<Integer, String> alunosPorMatricula =
new HashMap<Integer, String>();
alunosPorMatricula.put(1, "João");
alunosPorMatricula.put(2, "Maria");
alunosPorMatricula.put(3, "José");
System.out.println( alunosPorMatricula.get(1) );

Exercícios
17. Implemente uma classe Carrinho, contendo um carrinho
de compras. Use uma lista e tenha métodos para adicionar
itens no carrinho e contabilizar o total.
18. Implemente uma classe que receba dados estatísticos
contendo a idade de N pessoas e totalize as idades por faixas
etárias (0 a 10 anos, 11 a 20 anos, etc.). A classe deve ter um
método para recuperar o total de pessoas de uma
determinada faixa etária.

Programação Orientada a Objetos com Java

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Andere mochten auch

Andere mochten auch (20)

Programação Orientada a Objetos com Java