Aula 02

Prévia do material em texto

Programação Orientada a Eventos 
 
 
 
Alexandre Marcos C. Gitirana 
amcgitirana@yahoo.com.br 
 
2013.1 
Geral 
Da aula anterior, vimos: 
 
• Paradigmas 
 
• Evolução das Linguagens 
 
• Tipos de Linguagens: vantagens x desvantagens 
 
• POO x POE 
 
• Boas Práticas de Programação 
Conforme prometido, nossa avaliação: 
• 1 Prova Escrita (10,0) – 03/04 
• 1 Trabalho(7,0) – 22/05 
• 1 Prova Prática (10,0) – 05/06 
• Exercícios de sala de aula(3,0) 
Antes de Prosseguir, quero saber 
o que vocês acham da proposta 
de curso 
• Manipulação de Tipos 
• Manipulação de Arquivos 
• Integração com Banco 
• Swing e eventos 
• Padrões de Projeto 
 
Conhecendo Java 
• Bytecode é um formato de código intermediário entre o código fonte, o texto que o 
programador consegue manipular, e o código de máquina, que o computador consegue 
executar. 
• Na plataforma Java, o bytecode é interpretado por uma máquina virtual Java (JVM). A 
portabilidade do código Java é obtida à medida que máquinas virtuais Java estão 
disponíveis para diferentes plataformas. 
 
• A Máquina Virtual Java (JVM) é uma máquina de computação abstrata e um ambiente de 
execução independente de plataforma. Programas escritos em Java e que utilizem as 
funcionalidades definidas pelas APIs dos pacotes da plataforma Java executam nessa 
máquina virtual. 
• Executa os bytecodes, convertendo-os em programas executáveis 
 
• Todas as JVMs executarão programas da mesma forma 
 
 Proporciona portabilidade 
 
• Execução em ambiente próprio 
 
 Proporciona segurança 
 
• A arquitetura da JVM possui como principais componentes: 
 Classloader 
 Execution Engine 
 Runtime Data Areas 
 Native Method Interface 
 Garbage Collector 
Vantagens da JVM 
[Exercício] Para o dia 
06/03, trazer o 
conceito destes 
componentes. 
• Orientada a Objetos 
– Objetos e Classes 
– Encapsulamento de dados e operações 
– Polimorfismo 
– Reutilização de código (herança) 
– Facilidade de extensão e manutenção de código 
– Provê extensa biblioteca de classes (API) 
 
• Segurança 
– A JVM oferece um ambiente de execução seguro 
– Os bytecodes são verificados antes de serem executados 
– Inexistência de ponteiros 
– A coleta automática de lixo evita erros que os programadores 
cometem quando são obrigados a gerenciar diretamente a 
memória. 
Java 
• Robustez 
– Presença de mecanismos de tratamento de exceções 
 
• Coleta de Lixo 
 
– Sem necessidade de liberar memória alocada 
– Objetos sem referências são liberados da Memória 
 
• Eficiência 
 
– Criada para ser utilizada em computadores com pouca 
capacidade de processamento 
Java 
Portabilidade 
Portabilidade 
Revisão de Orientação a Objeto 
10 
Orientação a Objetos em Java 
• O ser humano se relaciona com o mundo através do conceito de objetos. 
 
• Estamos sempre identificando qualquer objeto ao nosso redor. 
 
• Para isso os nomeamos, e de acordo com suas características , os 
classificamos em grupos, ou seja, classes. 
• Conceitos: 
– Identidade. 
– Classificação. 
– Hereditariedade. 
– Encapsulamento. 
– Polimorfismo. 
– Ligação Dinâmica. 
 
11 
Classe 
Aluno 
Nome 
Matrícula 
Nota Média 
João 
193.31.098-7 
7,6 
Maria 
195.31.022-5 
8,7 
Orientação a Objetos em Java 
12 
• Objetos do mundo real possuem duas características: estado e 
comportamento. 
 
• Exemplos: 
 cachorros :estado: nome, cor, raça 
 comportamento: latir, correr 
 Bicicletas : estado: marcha atual, velocidade atual 
 comportamento: trocar marcha, aplicar freios 
 
 
Orientação a Objetos em Java 
13 
• Identificar o estado e o comportamento de objetos do mundo 
real é o primeiro passo para começar a pensar em 
programação OO. 
 
 
• Observe um objeto e pergunte: 
 
 Quais os possíveis estados que esse objeto pode estar? 
 
 Quais os possíveis comportamentos que ele pode 
executar? 
 
 
Orientação a Objetos em Java 
14 
• A unidade fundamental de programação em orientação a 
objetos (POO) é a classe. 
 
• Classes contém: 
 
– Atributos: determinam o estado do objeto; 
 
– Métodos: semelhantes a procedimentos em linguagens 
convencionais, são utilizados para manipular os atributos. 
 
Orientação a Objetos em Java 
15 
• As classes provêem a estrutura para a construção de objetos - 
estes são ditos instâncias das classes 
Classe 
Aluno 
Nome 
Matrícula 
Nota Média 
setNome(nome) 
getNome() 
... 
atributos 
métodos 
Instâncias 
João 
193.31.098-7 
7,6 
Maria 
195.31.022-5 
8,7 
Orientação a Objetos em Java 
16 
• Objetos 
 
– São instâncias da classe. 
– Sob o ponto de vista da programação orientada a objetos, 
um objeto não é muito diferente de uma variável normal. 
 
• Um programa orientado a objetos é composto por um 
conjunto de objetos que interagem entre si 
 
Orientação a Objetos em Java 
17 
• Objetos 
 
– Um objeto armazena seu estado em campos (variáveis) e expõe seu 
comportamento através de métodos (funções). 
 
– Encapsulamento: princípio de projeto pelo qual cada componente de 
um programa deve agregar toda a informação relevante para sua 
manipulação como uma unidade (uma cápsula). 
 
– Ocultação da Informação: princípio pelo qual cada componente deve 
manter oculta sob sua guarda uma decisão de projeto única. Para a 
utilização desse componente, apenas o mínimo necessário para sua 
operação deve ser revelado (tornado público) 
Orientação a Objetos em Java 
18 
Bicicleta 
Marcha atual 
Velocidade atual 
 
mudarMarcha() 
mudarVelocidade() 
... 
 campos 
(atributos) 
métodos 
Instâncias 
3ª 
20 km/h 
Bibicleta A 
7ª 
35 km/h 
Bibicleta B 
Orientação a Objetos em Java 
19 
Bibicleta B 
7º 
35 km/h 
Métodos operam no estado interno de um objeto e servem como 
mecanismo de comunicação entre objetos. 
João 
João 
30 anos 
mudarMarcha 
Orientação a Objetos em Java 
20 
 Qualificador_de_acesso class Nome_Da_Classe 
 { 
 // atributos da classe 
 // métodos da classe 
 } 
 
// Class Lampada 
public class Lampada 
{ 
// Atributos 
boolean acesa; 
// Métodos 
public void ligar() 
{ acesa = true; } 
public void desligar() 
{ acesa = false; } 
} 
Orientação a Objetos em Java 
21 
class Bicicleta { 
 int velocidade = 0; 
 int marcha = 1; 
 void mudarMarcha(int novoValor) { 
 marcha = novoValor; 
 } 
 void aumentarVelocidade(int incremento) { 
 velocidade = velocidade + incremento; 
 } 
 void aplicarFreios(int decremento) { 
 velocidade = velocidade - decremento; 
 } 
} 
Orientação a Objetos em Java 
22 
 
• É um princípio fundamental da OO: 
 
– Esconder o estado interno (valores dos atributos). 
 
– Obrigar que interações com os atributos sejam executadas 
através de métodos. 
 
 
• Com o encapsulamento um objeto determina a permissão que 
outros objetos terão para acessar seus atributos (estado). 
Encapsulamento 
23 
Proteger os 
atributos 
Permitir acesso 
aos atributos 
através dos 
métodos 
Encapsulamento 
24 
 
• Permite a uma classe herdar o estado (atributos) e o 
comportamento (métodos) de outra classe. 
 
• Herança : entre diferentes classes podem existir diversas 
semelhanças, ou seja, duas ou mais classes poderão 
compartilhar os mesmos atributos e/ou os mesmos métodos 
 
Herança 
25 
Pessoa
------------------------------------------------
nome
idade
Professor
------------------------------------------------------------------------------------
formação
área de interesse
Aluno
-------------------------------------------------------------------
curso
cr
Herança 
26 
Herança 
27 
Herança 
28 
Herança 
29 
João 
25 
Sistemas de Informação 
 
Instâncias de 
 Aluno 
Maria 
20 
Sistemas de Informação 
Herança 
30 
// SuperClass.java 
public class SuperClass 
{ 
 // Atributos e métodos 
} 
// SubClass.javapublic class SubClass EXTENDS SuperClass 
{ 
 // Atributos e métodos 
} 
 
class Aluno extends Pessoa { 
... 
} 
Herança 
31 
 
class Pessoa { 
 String nome; 
 int idade; 
 
 void definirNome(String valor) { 
 nome = valor; 
 } 
 
 String retornarNome() { 
 return nome; 
 } 
 
 void definirIdade(int valor) { 
 idade = valor; 
 } 
 
 int retornarIdade() { 
 return idade; 
 } 
} 
 
 
 
class Aluno extends Pessoa { 
 String curso; 
 
 void definirCurso(String valor) { 
 curso = valor; 
 } 
 
 String retornarCurso() { 
 return curso; 
 } 
 
} 
Herança 
32 
 
 
Aluno joao = new Aluno(); 
joao.definirNome(“João”); 
joao.definirIdade(25); 
joao.definirCurso(“Sistemas de 
Informação”); 
 
 
Aluno maria = new Aluno(); 
maria.definirNome(“Maria”); 
maria.definirIdade(20); 
maria.definirCurso(“Sistemas de 
Informação”); 
 
João 
25 
Sistemas de Informação 
Maria 
20 
Sistemas de Informação 
Herança 
33 
ELETRODOMÉSTICO 
Voltagem 
Garantia 
Ligar 
Desligar 
Liquidificador 
Fabricante 
Cor 
Auto Limpeza 
Velocidade 
Herança 
Classes Abstratas e Interfaces 
 
De forma objetiva, uma classe abstrata serve apenas como modelo para uma 
classe concreta (classe que comumente usamos). 
 
Como classes abstratas são modelos de classes, então, não podem ser instanciadas 
diretamente com o new, elas sempre devem ser herdadas por classes concretas. 
 
Outro fato importante de classes abstratas é que elas podem conter ou não 
métodos abstratos, que tem a mesma definição da assinatura de método 
encontrada em interfaces. Ou seja, uma classe abstrata pode implementar ou não 
um método. 
 
Os métodos abstratos definidos em uma classe abstrata devem obrigatoriamente 
ser implementados em uma classe concreta. Mas se uma classe abstrata herdar 
outra classe abstrata, a classe que herda não precisa implementar os métodos 
abstratos. 
Herança 
• Classes Abstratas X Classes Concretas 
– Uma classe abstrata é uma classe que não tem instâncias diretas, mas 
cujas classes descendentes podem ter instâncias diretas. 
– Uma classe concreta é uma classe que pode ser instanciada. 
 
• Classes Abstratas X Interfaces 
– A classe abstrata pode possuir métodos não abstratos, bastando ter 
apenas um método abstrato para ser considerada como tal. 
– Um interface apenas propõe os métodos que devem ser 
implementados pelas classes que desejarem. 
– Uma interface define um tipo. 
Herança 
Interfaces: 
· Uma interface não é considerada uma Classe e sim uma Entidade. 
· Não possui implementação, apenas assinatura, ou seja, apenas a definição dos seus métodos 
sem o corpo. 
· Todos os métodos são abstratos. 
· Seus métodos são implicitamente Públicos e Abstratos. 
· Não há como fazer uma instância de uma Interface e nem como criar um Construtor. 
· Funcionam como um tipo de "contrato", onde são especificados os atributos, métodos e 
funções que as classes que implementem essa interface são obrigadas a implementar. 
· Já que Java não suporta Heranças Múltiplas, as Interfaces são usadas para implementá-las. 
 
Classes Abstratas: 
· As classes abstratas devem conter pelo menos um método abstrato, que não tem corpo. 
· É um tipo especial de classe que não há como criar instâncias dela. 
· É usada apenas para ser herdada, funciona como uma super classe. 
· Uma grande vantagem é que força a hierarquia para todas as sub-classes. 
· É um tipo de contrato que faz com que as sub-classes contemplem as mesmas hierarquias 
e/ou padrões. 
Herança 
public abstract class Empregado { 
 public Empregado (String nome, double salario) { 
this.numero = ++contador; 
 this.nome = nome; 
 this.salario = salario; } 
 
public abstract void aumentaSalario(double percentual); 
} 
 
public class Vendedor extends Empregado{ 
 public void aumentaSalario (double percentualDeAumento) 
 { percComissao = percComissao * (1+percentualDeAumento/100);} 
} 
 
public class Gerente extends Empregado { 
 public void aumentaSalario(double percentual) { 
 double novoSalario = getSalario() * (1+2 * percentual/100); 
 setSalario(novoSalario); } 
} 
Herança 
public interface Ordenavel { 
 public int comparar(Ordenavel b); 
} 
 
public class Empregado implements Ordenavel { 
 ... 
 public int comparar(Ordenavel b) { 
 Empregado e = (Empregado)b; 
 if (salario < e.salario) return -1; 
 if (salario > e.salario) return 1; 
 return 0; 
 } ... 
} 
 
public class Ordenacao { 
 public static void ordena(Ordenavel[] a) 
 { ... if (a[i].comparar(a[i+]) > ) ...} 
} 
Herança 
• Polimorfismo é o termo definido em linguagens orientadas a objeto - 
como o Java - para a possibilidade de se usar o mesmo elemento de forma 
diferente. 
• Especificamente em Java, polimorfismo se encontra no fato de 
podemos modificar totalmente o código de um método herdado de 
uma classe diferente, ou seja, sobrescrevemos o método da classe 
pai. 
 
• Em linguagens fortemente tipadas o polimorfismo é implementado 
através de herança ou implementação de interfaces. 
Polimorfismo 
Polimorfismo 
• Determinam se atributos e métodos poderão ser acessados 
por outras classes 
 
– public (público) 
 
– private (privado) 
 
– protected (protegido) 
 
– modificador não explícito (package-private) 
Modificadores de Acesso 
• Uma classe pode ser: 
 
– public – acessado por qualquer outra classe. 
 
 
– nenhum modificador (package-private) – acessada 
somente dentro do seu pacote. 
 
Modificadores de Acesso 
• Atributos e métodos podem ser: 
 
– public – acessados por qualquer outra classe. 
 
– nenhum modificador (package-private) – acessados 
somente dentro do seu pacote 
 
– private – acessados somente dentro de suas próprias 
classes. 
 
– protected – acessados somente dentro do seus pacotes e 
por suas subclasses. 
Modificadores de Acesso 
Não Não Não Sim 
private 
Não Não Sim Sim 
nenhum 
Não Sim Sim Sim 
protected 
Sim Sim Sim Sim 
public 
todos subclasse pacote 
 
 
Classe/ 
Atributos ou 
métodos 
 
modificador 
Modificadores de Acesso 
Não Não Não Sim 
private 
Não Não Sim Sim 
nenhum 
Não Sim Sim Sim 
protected 
Sim Sim Sim Sim 
public 
todos subclasse pacote 
 
 
Classe/ 
Atributos ou 
métodos 
 
modificador 
Modificadores de Acesso 
Não Não 
Não 
 
Sim private 
Não Não Sim Sim nenhum 
Não Sim Sim Sim protected 
Sim Sim Sim Sim public 
Gamma AlphaSub Beta Alpha modificador 
Modificadores de Acesso 
47 
• Utilizados para a construção de objetos 
 
class Pessoa { 
 String nome; 
 int idade; 
 
 public Pessoa (String nome, int 
idade) { 
 this.nome = nome; 
 this.idade = idade; 
 } 
 
 public Pessoa () { 
 this.nome = “João”; 
 this.idade = 25; 
 } 
 
} 
 
 
 
 
 
Pessoa maria = 
 new Pessoa(“Maria”, 20); 
 
Pessoa joao = new 
Pessoa(); 
 
Construtores 
48 
• Devem ter o mesmo nome da classe que inicializam. 
 
 
• Podem ter parâmetros. 
 
 
• Não tem retorno. 
 
• Se não é declarado nenhum construtor, a linguagem provê um 
construtor padrão sem argumentos que não faz nada. 
Construtores 
49 
 
import java.util.*; 
 
public class AloMundo { 
 
 private String mensagem = “ ”; 
 
 public AloMundo () { 
 Date data = new Date(); 
 mensagem = "Alô, Mundo” + data.toString() ; 
 
 
 
} 
 public void mostrarMensagem () { 
 System.out.println( mensagem ); 
 } 
} 
 
Classe 
Pacotes 
Métodos 
Variáveis 
Construtores 
Construtores 
50 
public class Pessoa { 
 private String nome; 
 private int idade; 
 
 void definirNome(String valor) 
{ 
 nome = valor; 
 } 
 
 String retornarNome() { 
 return nome; 
 } 
 
 void definirIdade(int valor) { 
 idade= valor; 
 } 
 
 int retornarIdade() { 
 return idade; 
 } 
 
 public static void main (String[] args) { 
 Pessoa p1 = new Pessoa(); 
 p1.definirNome(“João”); 
 p1.definirIdade(25); 
 System.out.println( p1.retornarNome() 
+ 
 “ “ + p1.retornarIdade()); 
 
 Pessoa p2 = new Pessoa(); 
 p2.definirNome(“Maria”); 
 p2.definirIdade(20); 
 System.out.println(p2.retornarNome() 
+ 
 “ “ + p2.retornarIdade()); 
 } 
 
 } // fim da classe Pessoa 
Construtores 
51 
• Exercício1: Escreva um programa que implemente as 
classes abaixo conforme o diagrama de classes em UML 
 
Exercícios 
• Exercício2: Escreva um programa que implemente as classes abaixo conforme 
o diagrama de classes em UML 
Exercícios 
class Funcionario { 
 protected String nome; 
 protected String cpf; 
 protected double salario; 
 public double getBonificacao() { 
 
 return this.salario * 1.2; 
 
 } // outros métodos aqui 
} 
 
Boa semana para a todos ! 
Até quarta-feira que vem ! 
 
 
 
Programação Orientada a Eventos