Apostila Poo
Transcript of Apostila Poo
-
Programaa o Orientada a Objetos Curso de Sistemas de Informao
Este documento apresenta algumas notas de aula do curso de Programao Orientada a
Objetos. Este material no substitui o livro de referncia bsica do curso.
-
Sumrio Nota de aula 1 ............................................................................................................................... 1
Classe e objetos ......................................................................................................................... 1
Objetos ...................................................................................................................................... 5
Variveis de instncia ou Atributos ........................................................................................... 7
Varivel versus Atributo ............................................................................................................ 8
Declarando um atributo ............................................................................................................ 8
Tipos de dados .......................................................................................................................... 8
Tipo de retorno ......................................................................................................................... 9
Corpo do mtodo .................................................................................................................... 10
Prefixos set e get para mtodos.............................................................................................. 10
Exerccios tericos ................................................................................................................... 11
Nota de aula 2 ............................................................................................................................. 12
Linguagem de programao Java ............................................................................................ 12
Particularidades da linguagem ................................................................................................ 12
A plataforma de desenvolvimento Java .................................................................................. 14
Comandos bsicos da linguagem Java .................................................................................... 14
Interface grfica para entrada de dados ................................................................................. 15
Entrada de dados via teclado - console .................................................................................. 16
Estruturas de controle em Java ............................................................................................... 16
Estrutura condicional: if ...................................................................................................... 16
Estruturas de seleo mltipla: switch ............................................................................... 17
Estruturas de repetio: while ............................................................................................ 18
Estruturas de repetio: do/while ...................................................................................... 18
Estruturas de repetio: for ................................................................................................ 18
Exerccios ................................................................................................................................. 18
No laboratrio ..................................................................................................................... 18
Exerccios complementares................................................................................................. 20
Nota de aula 3 ............................................................................................................................. 22
Modificadores de acesso ......................................................................................................... 22
Construtores ............................................................................................................................ 25
A palavra static ........................................................................................................................ 28
-
Modificador de acesso - Protected ......................................................................................... 29
Exerccios ................................................................................................................................. 32
No laboratrio ..................................................................................................................... 34
Nota de aula4 .............................................................................................................................. 37
Herana ................................................................................................................................... 37
Construtor chamando construtor da superclasse ................................................................... 42
Construtor chamando outro construtor da mesma classe. .................................................... 44
Relacionamento "tem um" ou composio ............................................................................ 45
Importante ........................................................................................................................... 48
Exerccios ................................................................................................................................. 48
No laboratrio ..................................................................................................................... 50
Nota de aula 5 ............................................................................................................................. 51
Sobrecarga de mtodos .......................................................................................................... 51
Reescrita de mtodos.............................................................................................................. 52
Chamando o mtodo original ................................................................................................. 54
Exerccios ................................................................................................................................. 56
No laboratrio ..................................................................................................................... 57
Exerccios complementares................................................................................................. 57
Nota de aula 6 ............................................................................................................................. 60
Polimorfismo ........................................................................................................................... 60
Polimorfismo de incluso ........................................................................................................ 60
Leitura complementar ......................................................................................................... 62
Exerccios ................................................................................................................................. 62
No laboratrio ..................................................................................................................... 62
Nota de aula 7 ............................................................................................................................. 64
A Classes abstratas "existem" ................................................................................................. 64
Particularidades das classes abstratas. ................................................................................... 66
Exerccios ................................................................................................................................. 67
No laboratrio ..................................................................................................................... 67
Nota de aula 8 ............................................................................................................................. 68
Interfaces de classe ................................................................................................................. 68
final .......................................................................................................................................... 73
-
Exerccios ................................................................................................................................. 73
No laboratrio ..................................................................................................................... 74
Exerccios complementares................................................................................................. 75
Nota de aula 9 ............................................................................................................................. 76
Arrays ...................................................................................................................................... 76
Arrays multidimensionais ou matrizes .................................................................................... 80
Classes Wrappers - Embrulhos ................................................................................................ 81
Classes Wrappers .................................................................................................................... 82
A classe List ............................................................................................................................. 84
Ordenando uma lista ........................................................................................................... 85
Remover elemento de uma lista ......................................................................................... 86
Como saber o tamanho de uma lista. ................................................................................. 87
Mostrar um elemento que est em uma determinada posio ......................................... 88
Exerccios ................................................................................................................................. 89
No laboratrio ..................................................................................................................... 90
Exerccios complementares................................................................................................. 90
Nota de aula 10 ........................................................................................................................... 92
GUI - Interface grfica com o usurio ..................................................................................... 92
Inserindo componentes na tela. ............................................................................................. 95
Os Gerenciadores de Layout ................................................................................................... 96
BorderLayout ....................................................................................................................... 98
FlowLayout ........................................................................................................................ 101
Importante ......................................................................................................................... 102
Frames internos .................................................................................................................... 103
Exemplo de Mscara de entradas para componentes da interface grfica ......................... 105
Exerccios ............................................................................................................................... 108
No Laboratrio .................................................................................................................. 108
Nota de aula 11 ......................................................................................................................... 109
Painis ................................................................................................................................... 109
JScrollPane ......................................................................................................................... 112
Menus em Java ...................................................................................................................... 116
Submenus .............................................................................................................................. 118
-
Radio Button ......................................................................................................................... 120
Checkbox ............................................................................................................................... 121
Listas ...................................................................................................................................... 123
Password ............................................................................................................................... 125
ComboBox ............................................................................................................................. 126
Exerccios ............................................................................................................................... 128
Nota de aula 12 ......................................................................................................................... 129
Usando o MigLayout ............................................................................................................. 129
Adicionar componentes em uma grade ................................................................................ 129
Mesclar e dividir clulas ........................................................................................................ 130
Usando coordenadas absolutas ............................................................................................ 131
Exerccios ............................................................................................................................... 132
Nota de aula 13 ......................................................................................................................... 133
Manipuladores de Eventos em Java ...................................................................................... 133
Evento para JButton .......................................................................................................... 133
Evento para JTextField ...................................................................................................... 139
Evento para JMenuItem .................................................................................................... 141
Eventos para JList .............................................................................................................. 143
Eventos para ComboBox ................................................................................................... 146
Eventos para JRadioButton ............................................................................................... 148
Eventos para JCheckBox .................................................................................................... 150
Exerccios ............................................................................................................................... 153
No Laboratrio .................................................................................................................. 153
Mais informaes .............................................................................................................. 153
Nota de aula 14 ......................................................................................................................... 154
Eventos para JTable ............................................................................................................... 154
"Ouvindo" as mudanas ........................................................................................................ 158
Inserindo e excluindo linhas na tabela .............................................................................. 161
Exerccios ............................................................................................................................... 165
Nota de aula 15 ......................................................................................................................... 166
Manipulando excees ......................................................................................................... 166
Manipulando arquivos .......................................................................................................... 170
-
Escrevendo em arquivos ....................................................................................................... 171
Lendo um arquivo escrito ..................................................................................................... 173
Exerccios ............................................................................................................................... 174
Nota de aula 16 ......................................................................................................................... 175
Banco de dados em Java ....................................................................................................... 175
Criando um novo projeto no Eclipse ..................................................................................... 176
Criando uma classe no Eclipse .............................................................................................. 176
Acessando o MySQL no Eclipse ............................................................................................. 177
Consulta ................................................................................................................................. 179
Delete .................................................................................................................................... 180
Altera ..................................................................................................................................... 181
Usando o NetBeans ............................................................................................................... 183
Exerccios ............................................................................................................................... 183
REFERNCIAS ............................................................................................................................. 189
-
Quando se desenvolve uma aplicao
utilizando o paradigma de
programao Orientado a Objetos, as
aplicaes so desenvolvidas a partir
de objetos. "Na programao
orientada a objetos, programa-se um
conjunto de classes que definem os
objetos presentes no sistema de
software. Cada classe determina o
comportamento (definidos nos
mtodos) e estados possveis
(atributos) de seus objetos, assim
como o relacionamento com outros
objetos."[8]
Bem vindo Programao Orientada
a Objetos
-
Programao Orientada a Objetos 1
Nota de aula 1
Ao final da aula o aluno ser capaz de:
Conceituar classes
Diferenciar classes de objetos
Identificar as partes de uma classe
Conceituar mtodos construtores
Conceituar mtodos operacionais
Instanciar objetos
Diferenciar atributos de variveis
Utilizar tipos de retorno nos mtodos
Classe e objetos
Vamos pensar no mundo real olhando a nossa volta. Podemos ver mouses, carros,
cadeiras, pessoas, fichas cadastrais, rvores etc. Sabemos que cada um desses itens so
objetos. Esses objetos tm caractersticas e tambm funcionalidades (fazem alguma
coisa).
Vamos tomar como exemplo uma Pessoa. Temos vrias formas de vermos uma Pessoa.
Se o observador for um mdico em seu consultrio no horrio de trabalho, ir ver a
pessoa como um paciente ento ir observar somente o que importante para ele na
funo de profissional da sade. Ele no interessa em saber qual o nmero do CPF
dessa pessoa por exemplo.
Se o observador for um funcionrio de recursos humanos de uma empresa ele ir querer
saber informaes da pessoa tais como CPF, RG, PIS, nmero da conta bancria e no
ir se interessar pela presso arterial da Pessoa, por exemplo.
-
Programao Orientada a Objetos 2
Essas formas de ver o objeto Pessoa chamamos de Modelo Conceitual e para
desenvolver o modelo conceitual necessrio se concentrar no que mais relevante
para o problema.
Na Programao Orientada a Objetos temos que criar modelos conceituais de elementos
da natureza para construirmos os objetos. Os objetos no sero reais (objetos reais so
muito complexos) e sim um esboo de objetos com os dados mais relevantes para o
desenvolvimento do projeto.
A Programao Orientada a Objetos (POO) muda a forma de pensar em um programa.
Ela considerada um novo paradigma de programao. Geralmente construmos
programas pensando na soluo atravs de rotinas e funes.
Na POO devemos pensar em objetos e como esses objetos iro interagir entre si para
formar um programa. Um objeto dever ser capaz de "conversar" com outro objeto.
Quase tudo o que construirmos na POO sero objetos sendo assim devemos pensar:
Vou construir um objeto.
''O que esse objeto tem?"
"O que esse objeto faz?''
Para construir um objeto devemos montar primeiro o modelo conceitual e depois digitar
o cdigo em uma estrutura chamada classe. A classe um cdigo de programa que fica
armazenado no computador que depois de compilado ser o objeto.
Logo a classe pode ser entendida como um projeto de um objeto ou um molde para
construirmos objetos.
Quando escrevemos uma classe estamos criando a representao das propriedades e o
comportamento de um conjunto de objetos. Um sistema no possui somente uma
classe e sim vrias delas.
-
Programao Orientada a Objetos 3
Quando vamos construir um objeto pensamos o que esse objeto tem e o que esse
objeto poder fazer. O que o objeto tem chamado de atributo ou propriedade do
objeto. O que o objeto faz chamado de mtodo ou funcionalidade do objeto. Ento
se a classe o projeto de um objeto ento devemos colocar na classe o que o
objeto ter e o que o objeto far.
Exemplo:
Para construir um objeto Pessoa.
1. - Construir o modelo conceitual de Pessoa.
2. - Construir o cdigo do modelo conceitual na classe chamada Pessoa.
3. - Na classe Pessoa devemos definir o que essa pessoa tem (atributos).
4. - Na classe Pessoa devemos definir tambm o que o objeto Pessoa poder fazer
(mtodos)
Digamos que o objeto Pessoa possua:
nome
telefone
Ento nome e telefone so atributos da classe Pessoa que se tornar o objeto Pessoa
depois de compilado.
Vamos ver como ficar a classe Pessoa.
class Pessoa{
String nome;
String telefone;
}
Os atributos so as propriedades ou caractersticas da classe (que se tornar um objeto
depois de compilado).
-
Programao Orientada a Objetos 4
Observao:
Quando falamos da classe temos que ter em mente que ela ser o objeto depois de
compilada.
Bem esse objeto Pessoa dever fazer a recepo de um valor para o nome e um para
o telefone. Essa recepo indica o que ele capaz de fazer e neste caso receber
um nome e um telefone. Para que o objeto possa receber o nome ele deve ter
ummtodo que faa isso.
Vamos ver o cdigo.
class Pessoa{
String nome;
String telefone;
public String mostraNome() {
return nome;
}
public void recebeNome(String nome) {
this.nome = nome;
}
public String mostraTelefone() {
return telefone;
}
public void recebeTelefone(String telefone) {
this.telefone = telefone;
}
}
Veja que a classe acima possui os atributos nome e telefone do tipo String e possui
tambm os mtodos recebeNome(String nome), recebeTelefone(String telefone),
mostraNome() e mostraTelefone().
-
Programao Orientada a Objetos 5
Os mtodos recebeNome(String nome) e recebeTelefone(telefone) devero ter como
argumento um nome e um telefonerespectivamente. O argumento nome passado para
o mtodo recebeNome(String nome) e o argumento telefone passado para o mtodo
recebeTelefone(String telefone) e depois eles so enviados para os
atributos nome e telefone respectivamente atravs do comando this.nome =
nome e this.telefone = telefone.
O comando this.nome indica que para atribuir nome para o atributo nome desta
classe e o comando this.telefone indica que para atribuir o telefone para o
atributo telefone desta classe.
Assim temos nossa classe que se tornar um objeto depois de compilado.
Podemos concluir ento que uma classe possui as seguintes partes:
Objetos
Projetamos o objeto na classe. Para se ter realmente o objeto necessrio coloc-lo na
memria do computador, isto , instanci-lo.
O objeto a cpia dos atributos e mtodos de uma classe na memria do computador.
Vamos utilizar novamente a classe Pessoa (que o projeto do objeto Pessoa) como
exemplo:
class Pessoa{
String nome;
String telefone;
-
Programao Orientada a Objetos 6
public String mostraNome() {
return nome;
}
public void recebeNome(String nome) {
this.nome = nome;
}
public String mostraTelefone() {
return telefone;
}
public void recebeTelefone(String telefone) {
this.telefone = telefone;
}
}
Vamos agora instanciar o objeto Pessoa a partir da classe Pessoa:
public class AppPessoa {
public static void main(String[] args){
Pessoa p = new Pessoa();
p.recebeNome("Maria");
p.recebeTelefone("98780976");
System.out.println(p.mostraNome());
System.out.println(p.mostraTelefone());
}
}
Veja que no cdigo acima foi instanciada a classe Pessoa que ento passa a ser o objeto
Pessoa.
Pessoa p = new Pessoa();
-
Programao Orientada a Objetos 7
Esse objeto Pessoa possui como varivel de referncia a letra p. Atravs da varivel de
referncia p podemos ter acesso aos atributos e mtodos o objeto.
Observe que depois do operador new temos um mtodo (possui parnteses () ).
Observe tambm que esse mtodo no foi declarado na classe Pessoa.
Veja tambm que esse mtodo tem o mesmo nome da classe e por isso ele chamado
de mtodo construtor.
Temos dois tipos de mtodos que so:
Mtodos construtores: Utilizados para construir os objetos.
Mtodos operacionais: utilizados durante o ciclo de vida do objeto.
Depois que construmos um objeto no mais utilizaremos o mtodo construtor para esse
objeto. Usaremos ento os mtodos operacionais.
Ento:
Pessoa() um mtodo construtor
mostraNome() um mtodo operacional.
recebeNome(String nome) um mtodo operacional.
mostraTelefone() um mtodo operacional.
recebeTelefone(String telefone) um mtodo operacional.
O exemplo acima est escrito no linguagem de programao JAVA. Ento vamos
entender um pouco mais sobre essa linguagem de programao.
Variveis de instncia ou Atributos
As classes possuem os atributos, tambm conhecidos por variveis de instncia, que
armazenam valores para as classes. nome daclasse Pessoa um atributo. Quando
instanciamos a classe, e ela se torna um objeto, esse atributo pode ser chamado
devarivel de instncia pois pertence a uma classe instanciada.
A funo do atributo armazenar valores para os objetos na memria.
-
Programao Orientada a Objetos 8
Varivel versus Atributo
Uma varivel muito parecida com um atributo mas tem algumas diferenas que so:
Um atributo est no corpo da classe.
Uma varivel est no mtodo (como argumento ou no corpo do mtodo).
Um atributo ir ocupar memria somente quando uma instncia da classe for
executada.
Uma varivel ir ocupar memria quando a instruo que declara a varivel for
executada.
Variveis devem ser inicializadas.
Declarando um atributo
Em Java usamos:
Modificador (public, protected ou private)
Tipo de dados
Nome da varivel de instncia
Ponto-e-vrgula
Tipos de dados
Os tipos de dados informam o quanto de memria o computador ir alocar para
armazenar um dado.
A tabela abaixo mostra os tipos de dados primitivos utilizados em Java.
Tipo de dados Faixa de valores
byte -128 a 127
short (curto) -32.768 a 32.767
int (inteiro) -2.147.483.648 a 2.147.483.647
long (longo) -9.223.372.036.854.775.808 a 9.223.372.036.854.775.807
char (caractere) 65000
float (vrgula flutuante) 3.4e-038 a 3.4e+038
-
Programao Orientada a Objetos 9
double (duplo) 1.7e-308 a 1.7e+308
boolean (booleano) true (verdadeiro) ou false (falso)
Nome do atributo
Para nomearmos atributos devemos sempre utilizar letras minsculas.
Nome do mtodo
Para nomearmos um mtodo devemos sempre utilizar a primeira letra minscula e se ele
for composto a segunda letra dever ser maiscula sem espaos entre elas. Exemplo:
cadastroContas();
mostraNome();
mostraTelefone();
Os mtodos so as funcionalidades do objeto (o que o objeto pode fazer) e so divididos
em dois que so:
Mtodos construtores
Mtodos operacionais
Os mtodos so declarados como a seguir:
Modificador (public, private ou protected)
Tipo de retorno (se for operacional)
Nome do mtodo
Lista de argumentos do mtodo (opcional)
Corpo do mtodo delimitado por chaves
Tipo de retorno
Os mtodos que retornam valores so os mtodos operacionais. Mtodos sempre
manipulam os atributos e devem ter como tipo de retorno o mesmo tipo de retorno do
atributo.
A sintaxe para a construo de um mtodo :
-
Programao Orientada a Objetos 10
modificador tipo_de_retorno nomeDoMetodo([argumentos]);
Exemplo:
void recebeNome(String nome){
this.nome = nome;
}
Podemos ver que o tipo de retorno do mtodo acima vazio representado por void na
programao.
Corpo do mtodo
O corpo do mtodo composto por um bloco de cdigo onde inserimos as instrues
que dizem o que o mtodo ir fazer. Instrues como (if, for, while, case....) so usadas
sempre dentro do corpo de um mtodo.
Prefixos set e get para mtodos
Ao programar utilizando a linguagem Java iremos encontrar vrios mtodos com os
prefixos set e get. Esses prefixos no tm poder especial na programao, isto , no
fazem nada de especial eles somente dizem ao programador o que o mtodo ir fazer.
Um mtodo como pr-fixo set indica que esse mtodo ir atribuir (configurar, setar) um
valor para um atributo e mtodos com prefixos get dizem que o mtodo ir mostrar um
valor. Os mtodos com pr-fixo get geralmente possuem um retorno.
No exemplo da classe Pessoa podemos alterar os nomes dos mtodos recebeNome(),
recebeTelefone(), mostraNome() e mostraTelefone() por setNome(), setTelefone,
getNome() e getTelefone(). Vejamos o exemplo no cdigo abaixo:
class Pessoa{
String nome;
String telefone;
public String getNome() {
return nome;
-
Programao Orientada a Objetos 11
}
public void setNome(String nome) {
this.nome = nome;
}
public String getTelefone() {
return telefone;
}
public void setTelefone(String telefone) {
this.telefone = telefone;
}
}
Exerccios tericos
1. Defina o que um modelo conceitual
2. O que uma classe?
3. A afirmativa: "Um objeto construdo a partir de uma classe" verdadeira?
Justifique sua resposta.
4. Quantos o objetos podemos instanciar (criar) a partir de uma classe?
5. Para que servem os mtodos na orientao a objetos?
6. Quais as partes de uma classe?
7. O que devemos fazer para construir um objeto?
8. O que uma varivel de referncia?
9. O que um atributo?
10. Qual a diferena entre atributo e varivel?
11. Explique os passos necessrios para acionar um mtodo operacional.
12. Defina acesso direto a um atributo.
13. Defina acesso indireto ao um atributo.
14. Defina mtodo construtor.
15. Defina mtodo operacional.
-
Programao Orientada a Objetos 12
Nota de aula 2
Ao final da aula o aluno ser capaz de:
Utilizar comandos da linguagem Java para ler dados.
Utilizar comandos da linguagem Java para mostrar dados.
Utilizar estruturas de controle na linguagem Java.
Linguagem de programao Java
A linguagem Java :
Parcialmente Orientada a Objetos
uma linguagem de alto nvel
uma linguagem multithread
Possui arquitetura neutra
Linguagem multiplataforma
etc.
A tecnologia Java composta por uma linguagem de programao e uma mquina
virtual que permite seus cdigos serem executados em diversas plataformas.
Utilizamos um editor ASCII para escrever os cdigos da linguagem Java. Neste curso
iremos utilizar o Eclipse para escrever os cdigos porque ele disponibiliza vrias
facilidades para o programador.
Particularidades da linguagem
Java Case Sensitive (diferencia letras maisculas de minsculas).
Java fortemente tipada (deve declarar variveis).
Nome do arquivo deve ser o mesmo nome da classe.
Exemplo:
-
Programao Orientada a Objetos 13
Se tivermos a classe Pessoa ento o nome do arquivo deve ser Pessoa. Esse arquivo ter
que ter a extenso .java.
Depois de escrito o cdigo (classe) ento devemos compilar o cdigo (da classe).
Depois de compilado o cdigo (.java) gerado um cdigo .class que tambm chamado
de bytecode. O cdigo .class ento interpretado pela mquina virtual java e finalmente
executado.
Ento arquivos com extenso .java possuem o cdigo fonte e arquivos com
extenso class so os bytescodes que a mquina virtual java (JVM) ir interpretar.
Veja a figura abaixo que mostra todo o processo:
Podemos na figura acima que a linguagem Java compilada e interpretada. O cdigo
fonte (.java) depois de compilado se transforma em bytecodes (.class) que so
interpretados pela mquina virtual Java (JVM).
Podemos utilizar o mesmo cdigo (.class) em vrios sistemas operacionais desde que
cada sistema operacional tenha uma mquina virtual Java para interpretar esse cdigo.
-
Programao Orientada a Objetos 14
A plataforma de desenvolvimento Java
A plataforma Java possui dois componentes:
Java Virtual Machine - JVM ou Mquina Virtual Java (MVJ);
Java Application Programming Interface(API)
Comandos bsicos da linguagem Java
Para escrever uma mensagem no console em Java, utilizamos o comando
System.out.println("mensagem");
Ou
System.out.print("mensagem");
O primeiro comando imprime uma mensagem no console e salta uma linha (println), o
segundo imprime uma mensagem na tela e continua na mesma linha.
O programa abaixo escreve Programao Orientada a Objetos na tela.
public class EscreveNaTela{
public static void main(String[] args){
System.out.println("Programao Orientada a Objetos");
}
}
Veja que o programa est dentro de uma classe que se chama EscreveNaTela. Logo esse
arquivo deve ser gravado como EscreveNaTela.java. Depois de compilado ele ir gerar
um arquivo chamado EscreveNaTela.java e esse arquivo ser interpretado pela JVM.
-
Programao Orientada a Objetos 15
Observe tambm que temos a linha de comando
public static void main(String[] args){
Essa linha de comando (mtodo) prprio da linguagem java e indica que esse
programa uma aplicao (pode ser executado). Na programao orientada a objetos
temos vrios objetos que comunicam entre si mas geralmente somente um objeto o
executvel e para ser executvel necessrio que ele tenha o mtodo abaixo:
public static void main(String[] args){
Interface grfica para entrada de dados Para utilizar a interface grfica da linguagem Java importamos (import) o pacote
javax.swing que j est na API da linguagem.
import javax.swing.*;
public class Aula{
public static void main(String[] args){
//declara x do tipo inteiro
int x;
//declara sx do tipo string
String sx;
//faz a leitura e grava em sx
sx = JOptionPane.showInputDialog("Digite o valor de x");
//converte sx(string)inteiro
x = Integer.parseInt(sx);
//mostra o resultado na janela grfica.
JOptionPane.showMessageDialog(null,"Valor de x: " +x);
}
}
-
Programao Orientada a Objetos 16
Entrada de dados via teclado - console
O programa abaixo mostra a entrada de dados via teclado utilizando o console e mostra
as informaes tambm no console.
import javax.swing.*;
import java.util.Scanner;
public class EntradaDeDados{
public static void main(String[] args){
String nome;
int idade;
Scanner s = new Scanner(System.in);
System.out.println("Idade:");
idade = s.nextInt();
s.nextLine();
System.out.println("Nome:");
nome = s.nextLine();
System.out.println("Nome: "+nome);
System.out.println("Idade: "+idade);
}
}
Estruturas de controle em Java
Estrutura condicional: if
if(condio){
-
Programao Orientada a Objetos 17
//comandos;
}
Ou
if(condio){
//comandos1;
}
else{
//comandos2;
}
Estruturas de seleo mltipla: switch
switch(opo){
//opo pode ser do tipo byte, short, int ou char
case opcao1:
comandos1;
break;
case opcao2:
comandos2;
break;
. .
.
case opcaon:
comandosn;
break;
default:
comandos;
}
-
Programao Orientada a Objetos 18
Estruturas de repetio: while
while(condio){
comandos;
}
Estruturas de repetio: do/while
do{
comandos;
}while(condio);
Estruturas de repetio: for
for(inicializa; condio; incremento){
comandos;
}
Consulte o livro "Java: Como Programar" - Deitel nos captulos 4 e 5 para revisar as
estruturas de controle.
Exerccios
No laboratrio
1. Escrever um programa em Java que mostre seu nome na tela utilizando o
console.
2. Escrever uma classe chamada Calculadora que contenha os atributos rSoma,
rSub, rDiv, rMult sendo todos do tipo float.
a) Sua classe dever ter tambm os mtodos setSoma, setSubtrai, setDivide
e setMultiplica.
-
Programao Orientada a Objetos 19
b) Cada mtodo dever possuir dois argumentos (num1 e num2).
c) O mtodo setSoma dever somar os dois argumentos e coloc-los no
atributo rSoma.
d) O mtodo setSubtrai dever subtrair os dois argumentos e coloc-los no
atributo rSub.
e) O mtodo setDivide dever Dividir os dois argumentos e coloc-los no
atributo rDiv. Verifique se o denominador diferente de zero.
f) O mtodo setMultiplica dever multiplicar os dois argumentos e coloc-
los no atributo rMult.
g) Sua Classe dever ter tambm os mtodos getSoma, getSubtrai,
getDivide e getMultiplica e cada mtodo dever retornar o valor da
soma, subtrao, diviso e multiplicao respectivamente.
3. Escrever um programa em Java que mostre a soma de dois nmeros quaisquer.
Os nmeros podem ser inseridos no cdigo do programa.
4. Escrever um programa para mostrar os nmeros de 1 a 100 na tela utilizando a
estrutura de repetio while.
5. Escrever um programa para mostrar os nmeros de 1 a 100 na tela utilizando a
estrutura de repetio do while.
6. Escrever um programa para mostrar os nmeros de 1 a 100 na tela utilizando a
estrutura de repetio for.
7. Escrever um programa para ler um nmero e verificar se ele positivo ou
negativo. Utilize o console para fazer a leitura.
8. Escreva um programa que solicite o nome de uma pessoa utilizando a interface
grfica. Mostre o nome digitado utilizando a interface grfica.
9. Escreva um programa que solicite o nome de uma pessoa utilizando o console.
Mostre o nome digitado utilizando o console.
10. Escreva um programa que mostre a figura abaixo na tela - no necessrio
utilizar comandos de repetio para este exerccio.
*
***
-
Programao Orientada a Objetos 20
*****
*******
*********
10. Escreva o programa anterior utilizando os comandos de repetio.
Exerccios complementares
1. Escreva um programa para calcular o n-simo termo da srie de Fibonacci. A
entrada dever ser utilizando a janela grfica
2. Escreva um programa para calcular a diviso de dois nmeros quaisquer,
utilizando a entrada grfica.
3. A empresa RGS Ltda. concedeu um bnus de 20 por cento do valor do salrio a
todos os funcionrios com tempo de trabalho na empresa igual ou superior a
cinco anos e dez por cento aos demais. Calcular e exibir o valor do bnus.
4. Ler o cdigo de um produto e exibir o seu nome de acordo com a tabela abaixo:
Cdigo do produto Nome do produto
1 Caderno
2 Lpis
3 Borracha
5. Ler 280 nmeros fornecidos pelo usurio calcular e exibir a mdia. (utilize do-
while)
6. Ler 280 nmeros fornecidos pelo usurio calcular e exibir a mdia. (utilize
while)
7. Ler 280 nmeros fornecidos pelo usurio calcular e exibir a mdia. (utilize for)
8. Um aluno realizou trs provas de uma disciplina. Considerando o critrio
abaixo, faa um programa que mostre se ele ficou para exame; em caso positivo,
qual nota esse aluno precisa tirar no exame para passar.
-
Programao Orientada a Objetos 21
mdia = (prova1 + prova2 + prova3)/3 A mdia deve ser maior ou igual a 7,0. Se no
conseguir, a nova mdia deve ser: final = (mdia + exame)/2 Nesse caso, a mdia final
deve ser maior ou igual a 5.
9. A srie de RICCI difere da srie de FIBONACCI porque os dois primeiros
termos so fornecidos pelo usurio. Os demais termos so gerados da mesma
forma que a srie de FIBONACCI. Criar um programa que imprima os N
primeiros termos da srie de RICCI e a soma dos termos impressos, sabendo-se
que para existir esta srie sero necessrios pelo menos trs termos.
-
Programao Orientada a Objetos 22
Nota de aula 3
Ao final da aula o aluno ser capaz de:
Utilizar os modificadores de acesso public, private e protected.
Difenciar os tipos dos modificadores de acesso.
Utilizar mtodos construtores.
Utilizar variveis e mtodos estticos.
Modificadores de acesso Os modificadores de acesso manipulam a visibilidade de um atributo ou mtodo da
classe.
Temos trs tipos de modificadores de acesso que so:
public - modificador de acesso pblico
protected - modificador de acesso intermedirio entre o modificador public e o
modificador private
private - modificador de acesso privado
O modificador public torna diponvel para acesso os atributos e mtodos de uma classe
para todas as classes do sistema. Quando um atributo possui um atributo public isso
significa que ele pode ser acessado diretamente como mostra o exemplo abaixo:
public class Pessoa{
public String nome;
public int idade;
}
O cdigo acima diz que os atributos nome e idade da classe Pessoa so pblicos e
sendo assim podem ser acessados diretamente.
Vejamos:
-
Programao Orientada a Objetos 23
public class AcessoPublico{
public static void main (String[] args){
//instancia o objeto Pessoa
Pessoa p = new Pessoa();
//Acessando diretamente o atributo nome
p.nome = "Ana";
//fazendo acesso direto ao atributo idade;
p.idade = 39;
}
}
No cdigo acima acessamos diretamente os atributos nome e idade'. Quando fazemos
um acesso direto, qualquer valor atribudo ao atributo ser aceito. Sabemos que a idade
de uma pessoa no pode ser negativa. Quando fazemos um acesso direto ao atributo
idade possvel inserir qualquer valor para a idade sendo eles positivos ou negativos.
Para solucionar esse problema temos que "proteger" o atributo idade. Para fazermos
isso devemos colocar a frente o tipo do atributo a palavra private. Veja o cdigo
abaixo:
Vejamos o cdigo:
public class Pessoa {
private String nome;
private int idade;
void setIdade(int idade){
if (idade >= 0) {
this.idade = idade;
}
else{
System.out.print("Idade invlida");
-
Programao Orientada a Objetos 24
}
}
}
No cdigo acima foi implementado o mtodo void setIdade(String idade) que ir validar
se a idade da pessoa positiva.
Agora se o programador tentar acessar diretamente o atributo idade o compilador ir
emitir o seguinte erro:
Exception in thread "main" java.lang.Error: Unresolved compilation problems:
Syntax error, insert "AssignmentOperator Expression" to complete Expression
The field Pessoa.idade is not visible
at mateiralaula.AppPessoa.main(AppPessoa.java:10)
O erro acima diz que o atributo idade no est visvel.
Para atribuir um valor ao atributo idade necessrio fazer um acesso indireto, isto ,
utilizando o mtodo como mostra o exemplo abaixo:
public class Pessoa {
private String nome;
private int idade;
void setIdade(int idade){
if (idade >= 0) {
this.idade = idade;
}
else{
System.out.print("Idade invlida");
}
}
-
Programao Orientada a Objetos 25
int getIdade(){
return this.idade;
}
}
Veja que foi necessrio escrever um mtodo (int 'getIdade()) para retornar a idade que
est gravada no atributo idade'. Sem esse mtodo no possvel ler o que est gravado
em um atributo privado.
Veja no cdigo abaixo como atribuir um valor para o atributo idade e como mostrar o
valor atribudo a esse atributo.
public class AppPessoa {
public static void main(String[] args) {
Pessoa p = new Pessoa();
p.setIdade(34);
System.out.println("A idade "+p.getIdade());
}
}
Veja que para podermos mostrar a idade na tela devemos utilizar o
comando System.out.println() da linguagem Java.
Construtores O mtodo construtor utilizado somente para construir objetos. Depois de construdo
um objeto o mtodo construtor no mais utilizado.
Veja o cdigo abaixo:
Pessoa p = new Pessoa();
O construtor incializa os atributos quando um objeto construdo. Se o atributo for:
Tipo String inicializado com null;
Tipo numrico inicializado com zero
-
Programao Orientada a Objetos 26
Tipo booleano inicializado com false
Tipo objeto inicializado com null.
public class Pessoa{//declarao de atributos
static String nome;
static int idade;
static boolean ativa;
public static void main(String[] args){
System.out.println("Nome: "+Pessoa.nome);
System.out.println("Idade: "+Pessoa.idade);
System.out.println("Est na ativa: "+Pessoa.ativa);
}
}
A sada ser
Nome: null
Idade: 0
Est na ativa: false
Se voc escrever o cdigo de uma classe em Java e no escrever o cdigo do construtor
a linguagem Java cria um automaticamente para voc. O construtor criado pela
linguagem Java possui o seguinte cdigo:
Pessoa(){}
O cdigo acima mostra o construtor criado pela linguagem Java se voc no cri-lo.
Caso voc escreva o cdigo para um construtor, usando argumentos por exemplo, o
construtor padro (mostrado acima) no poder mais ser utilizado automaticamente.
Voc deve ento criar seu construtor com argumentos e o construtor padro.
Uma boa dica de programao voc sempre criar o construtor padro nos seus
cdigos.
Exemplo:
-
Programao Orientada a Objetos 27
public class Pessoa {
private String nome;
private int idade;
Pessoa(int idade){
this.idade = idade;
}
void setIdade(int idade){
if(idade >= 0){
this.idade = idade;
}
else{
System.out.print("Idade invlida");
}
}
}
Se tentarmos criar um objeto da classe Pessoa acima utilizando o cdigo:
public class AppPessoa {
public static void main(String[] args){
Pessoa p = new Pessoa();
p.setIdade(39);
p.idade = 34;
}
}
Isso ir gerar um erro como mostrado abaixo:
Exception in thread "main" java.lang.Error: Unresolved compilation problems:
The constructor Pessoa() is undefined
The method setIdade(int) is undefined for the type Pessoa
-
Programao Orientada a Objetos 28
at mateiralaula.AppPessoa.main(AppPessoa.java:5)
A palavra static A palavra static cria uma varivel nica (neste caso numeroDePessoas) que
ser compartilhada por todos os objetos dessa classe. Vamos lembrar que tendo uma
classe ns podemos instanciar vrios objetos. Se a classe tem um atributo esttico
(static) ento esse atributo poder ser compartilhado por todos os objetos que foram
instanciados dessa classe.
Vejamos:
public class Pessoa {
private String nome;
private int idade;
public static int numeroDePessoas;
Pessoa(){
numeroDePessoas++;
}
Pessoa(String nome){
this.nome = nome;
}
Pessoa(int idade){
this.idade = idade;
}
Pessoa(String nome, int idade){
this(nome);
-
Programao Orientada a Objetos 29
this.idade = idade;
}
}
public class AppPessoa {
public static void main(String[] args){
Pessoa p1 = new Pessoa();
Pessoa p2 = new Pessoa();
Pessoa p3 = new Pessoa();
Pessoa p4 = new Pessoa();
Pessoa p5 = new Pessoa();
System.out.println("Total de pessoas: "+p4.numeroDePessoas);
}
}
A sada do cdigo acima ser:
Total de pessoas: 5
Se voc usar qualquer objeto para mostrar o nmero de pessoas o resultado ser o
mesmo porque o atributo numeroDePessoasest compartilhado com todos os objetos
dessa classe.
Modificador de acesso - Protected Vamos agora verificar o comportamento do modificador de acesso protected nas
classes. Vejamos o cdigo abaixo que possui uma classe chamada Classe1 e esta classe
est em um pacote chamado p1. Lembre-se que um pacote muito parecido com uma
pasta do sistema de arquivos do Windows. O cdigo da classe Classe1 est dentro do
pacote p1.
package p1;
public class Classe1 {
protected int x;
-
Programao Orientada a Objetos 30
}
Veja que a primeira linha do cdigo acima o package p1 isso faz com que a
clsse Classe1 seja criada dentro do pacote p1.
Veja tambm que o atributo x do tipo inteiro e est com o modificador de
acesso protected. Isso significa que se quisermos acessar esse atributo x de um outro
pacote ento devemos criar na Classe1 um mtodo que permita o acesso.
Vamos analisar a figura abaixo:
Veja que a classe Classe2 est em um pacote chamado p2. O pacote p1 foi importado
(import) porque nele est a classe Classe1mas quando tentamos acessar o atributo x da
classe Classe1 que est protegido (protected) o compilador sugere que:
O atributo int x seja modificado para public ou
Que seja criado um mtodo getter (get) e um mtodo setter (set) para acessar o
atributo x.
Os mtodos get e set sugeridos pelo compilador devem ser criados na
classe Classe1 como mostra o cdigo abaixo.
package p1;
public class Classe1 {
-
Programao Orientada a Objetos 31
protected int x;
void setX(int z){
this.x = z;
}
int getX(){
return this.x;
}
}
Agora quando quisermos utilizar o atributo x devemos utiliza os mtodos getX e setX.
Veja agora o cdigo abaixo:
package p1;
public class Classe3 {
public static void main(String[] args){
Classe1 c3 = new Classe1();
c3.x = 10;
}
}
O cdigo acima est no mesmo pacote que a Classe1 e ele acessou diretamente o
atributo x sem problemas.
Ento podemos concluir que quando um atributo possui o modificador de
acesso protected, esse atributo pode ser acessadodiretamente por classes que
estejam no mesmo pacote e classes que esto em pacotes diferentes devem utilizar os
mtodos set e get da classe que possui o atributo protected para poer ter acesso.
-
Programao Orientada a Objetos 32
Quando no colocamos nenhum modificador de acesso, dizemos que o atributo tem
acesso default que no o mesmo que acesso pblico. O acesso default no permite
acesso de pacotes diferentes.
Exerccios
1. Pela conveno, qual o prefixo utilizado em mtodos que retornam boolean?
2. Quais as principais caractersticas de um construtor?
3. Qual a sintaxe para acessar um atributo esttico dentro de um mtodo esttico
4. Escreva um exemplo que utilize um mtodo esttico
5. Qual a funo do modificador public
6. Escreva um exemplo (classe) que utiliza o modificador private e public
7. Qual a funo de um mtodo que possui get como prefixo no nome?
8. Escreva um programa que utilize um mtodo get.
9. Atributos do tipo String e atributos do tipo de uma classe (objetos) so
inicializados com null. Por qu?
10. Qual a funo do modificador private?
11. Escreva um exemplo que utilize o modificador private
12. O que um atributo static?
13. O que acontece, em java, quando criamos uma classe e no definimos um
construtor para ela?
14. Qual a funo de um mtodo que possui set como prefixo no nome?
15. Escreva um programa que utilize um mtodo set.
16. Quais so os trs tipod de modificadores de acesso?
17. O que um "acesso direto"?
18. O que um construtor?
19. O que acontece com o construtor padro quando criamos um construtor na
classe?
20. Atributos so inicializados autmoaticamente. Qual o valor inicial para tipos
numricos primitivos, String, objetos e boolean?
-
Programao Orientada a Objetos 33
21. Uma classe chamada ClasseA possui o construtor ClasseA(int x). A ClasseB
herda da ClasseA e quer utilizar o construtor da ClasseA passando como
argumento o valor 10. Para que isso acontea, qual a linha de comando dever
ser escrita pelo desenvolvedor?
a) super(ClasseA());
b) super.ClasseA(10);
c) super(10);
d) ClasseA(10);
e) n.d.a.
22. Faa o rastreio do cdigo abaixo:
public class ExemploStatic {
int x;
public static void main(String[] args){
int y;
y = 93;
x = y % 2;
System.out.println("O valor de x ser: "+x);
}
}
a) 1
b) 0
c) Apresenta um erro porque x deve ser esttico
d) apresenta um erro porque y deve ser esttico
e) n.d.a.
23. Escreva qual o tipo de relacionamento ( um ou tem um) existe entre as classes
abaixo:
a) Classe Imvel e classe Casa ______________________________
b) Classe Casa e classe Endereco ____________________________
c) Classe Conta e classe Cliente _____________________________
d) Classe Cliente e classe PessoaFsica _______________________
-
Programao Orientada a Objetos 34
e) Classe Professor e classe Alunos __________________________
24. A melhor definio para modificadores de acesso :
a) O modificador de acesso compartilha o atributo para todos os objetos da classe.
b) Todos os modificadores de acesso no permitem que o atributo seja herdado
pelas subclasses da classe que o contm.
c) O modificador de acesso faz com que mtodos devam ser reescritos na classe
filha.
d) Os modificadores de acesso manipulam a visibilidade de um atributo ou mtodo
da classe.
e) n.d.a.
25. Quanto aos tipos de acesso a um atributo podemos afirmar que:
a) Acesso direto feito utilizando-se a varivel de referncia a um objeto, o
operador ponto e o nome do atributo.
b) Acesso direto feito utilizando-se a varivel de referncia, ponto e o mtodo que
acesso o atributo private.
c) Acesso direto feito utilizando-se a varivel de referncia, ponto e o nome do
atributo private.
d) Acesso direto feito utilizando-se a varivel de referncia, ponto e o nome do
atributo public.
e) n.d.a.
No laboratrio
1. Inicie o Eclipse e escreva o cdigo abaixo:
package br.aula.pacote;
public class Conta {
public float saldo;
}
2. Agora construa outra classe chamada AppConta e escreva o cdigo abaixo:
package br.aula.pacote;
public class AppConta {
-
Programao Orientada a Objetos 35
public static void main(String[] args){
Conta c = new Conta();
c.saldo = 100;
System.out.println("Saldo: "+c.saldo);
}
}
Veja que as duas classes esto no mesmo pacote (br.aula.pacote). Qual foi a sada do
programa?
3. Agora escreva o cdigo abaixo:
package br.aula.pacote2;
import br.aula.pacote.Conta;
public class AppConta3 {
public static void main(String[] args) {
Conta c2 = new Conta();
c2.saldo = 100;
System.out.println("Saldo: "+c2.saldo);
}
}
Observe que este cdigo est em outro pacote que o br.aula.pacote2 e que foi
importado a classe Conta do pacote pacote na linha import br.aula.pacote. Qual foi a
sada do cdigo acima? Se apresentou um erro, qual a soluo para o erro?
4. Construa uma classe chamada Cliente com os atributos nome e telefone. Crie os
mtodos get e set para configurar os atributos. Leve em considerao o
encapsulamento dos dados.
5. Construa uma classe chamada Conta que possui os seguintes atributos privados
saldo, limite do tipo double e dono do tipo String. Construa os getters e setters
para os todos atributos. Crie um programa para testar sua classe.
-
Programao Orientada a Objetos 36
6. Na classe Conta adicione um construtor que quando utilizado mostra a
mensagem "Construindo uma conta" na tela.
7. Faa com que seu construtor alm de mostrar a mensagem na tela, acumule em
um atributo totalContas a quantidade de conta abertas.
8. Crie a classe Funcionario com os atributos salario (float), empresa (string) , setor
(string), nome (string)
9. Adicione o modificador de visibilidade (private se necessrio) para cada atributo
e mtodo da classe Funcionario. Crie uma classe chamada MeuFuncionario,
instancie um funcionrio qualquer e tente modificar ou ler um de seus atributos
privados. O que acontece?
10. Crie os getters e setters necessrios da sua classe Funcionario
11. Modifique a sua classe MeuFuncionario que acessam e modificam atributos de
um Funcionario para utilizar getters e setters.
12. Adicione um atributo na classe Funcionario do tipo int que se chama
identificador. Esse identificador deve ter um valor nico para cada instncia do
tipo Funcionario.
13. Crie um getter para o identificador. Voc deve criar um setter? Justifique.
14. Crie a classe PessoaFisica. Queremos ter a garantia que todas as pessoas
instanciadas que o cpf invlido no seja criada e que pessoas que no tenham cpf
tambm no sejam criadas. Nesse caso, o cpf vlido aquele que tenha 11
dgitos. Utilize o m todo length() da classe String.
-
Programao Orientada a Objetos 37
Nota de aula4
Ao final da aula o aluno ser capaz de:
Conceituar herana.
Diferenciar o relacionamento um do relacionamento tem um.
Utilizar o modificador de acesso protected.
Herana
Na orientao a objetos possvel relacionar as classes. Uma das formas de
relacionamento entre classes a herana. Esse relacionamento muito importante pois
aumenta a reusabilidade do cdigo. Neste relacionamento (herana) uma classe
chamada de classe me ou superclasse e a outra chamada de
classe filha ou subclasse. Quando uma classe herda de outra classe ela poder utilizar
"todos" os atributos e mtodos da classe me.
Em Java a palavra extends representa essa herana. Vejamos:
public class Pessoa{
public String nome;
public String telefone;
public void setNome(String n){
this.nome = n;
}
public String getNome(){
return this.nome;
}
public void setTelefone(String tel){
-
Programao Orientada a Objetos 38
this.telefone = tel;
}
public String getTelefone(){
return this.telefone;
}
}
A classe Pessoa representa uma pessoa. Esse conceito de pessoa muito genrico
porque a pessoa pode ser fsica ou jurdica.
Vamos especializar a classe pessoa criando uma classe PessoaFisica por exemplo.
public class PessoaFisica extends Pessoa {
private String cpf;
void setCPF(String cpf){
//...cdigo de validao do cpf
this.cpf = cpf;
}
String getCPF(){
return this.cpf;
}
}
Vejamos que na classe PessoaFisica uma Pessoa mais especializada e ela tem um
CPF.
A herana feita pelo comando extends e nos diz que a classe PessoaFisica
uma 'Pessoa sendo assim ela pode utilizar os atributos e mtodos (pblicos) da
classe Pessoa.
-
Programao Orientada a Objetos 39
Agora poderemos acessar os atributos e mtodos da classe Pessoa instanciando apenas a
classe PessoaFisica.
Veja o cdigo:
public class AppPessoa {
public static void main(String[] args){
PessoaFisica pf = new PessoaFisica();
pf.nome = "Joana";
pf.telefone = "3188439844";
System.out.println("Nome: "+pf.nome);
System.out.println("Telefone: "+pf.telefone);
pf.setNome("Joana");
pf.setTelefone("3188439844");
System.out.println("Nome: "+pf.getNome());
System.out.println("Telefone: "+pf.getTelefone());
pf.setCPF("90878765487");
System.out.println("CPF: "+pf.getCPF());
}
}
Veja que foi possvel acessar os atributos nome e telefone da
classe Pessoa instanciando um objeto da classe PessoaFisica isto porque os atributos
so pblicos (public). Se encapsularmos os atributos nome e telefone da
classe Pessoa ento no ser mais possvel fazer o acesso direto a esses atributos como
mostra o cdigo abaixo:
public class Pessoa{
-
Programao Orientada a Objetos 40
private String nome;
private String telefone;
public void setNome(String n){
this.nome = n;
}
public String getNome(){
return this.nome;
}
public void setTelefone(String tel){
this.telefone = tel;
}
public String getTelefone(){
return this.telefone;
}
}
Veja que agora os atributos nome e telefone da classe Pessoa so privados e que
quando queremos instanciar a classePessoaFisica que herda de Pessoa no possvel
acessar os atributos privados como mostra a figura abaixo:
-
Programao Orientada a Objetos 41
Assim podemos concluir que atributos privados de superclasses no so herdados para
as subclasses.
A representao na UML de um relacionamento de herana mostrada na figura abaixo.
-
Programao Orientada a Objetos 42
Construtor chamando construtor da superclasse
Os construtores so utilizados para construir objetos e depois de um objeto construdo
ele no mais utilizado. Os construtores podem ter assinaturas (argumentos) e tambm
podem chamar outro construtor para construir um objeto.
Em uma classe filha possvel chamar o construtor da classe pai imediatamente
superior utilizando a palavra super que vem de super-classe.
Na classe Pessoa abaixo temos dois construtores, sendo um o construtor padro e o
outro o construtor que utiliza um valor Stringcomo argumento. Esse construtor ir
verificar se o telefone da Pessoa possui oito dgitos. Veja o cdigo.
public class Pessoa {
private String nome;
private String telefone;
Pessoa(){}
Pessoa(String tel){
if(tel.length() == 8){
this.telefone = tel;
}
else{
System.out.print("Nmero de telefone invlido");
}
}
void setId(String tel){
this.telefone = tel;
}
void setSaldo(String nome){
this.nome = nome;
-
Programao Orientada a Objetos 43
}
String getTelefone(){
return this.telefone;
}
String getNome(){
return this.nome;
}
}
Vamos construir uma classe chamada PessoaFisica que herda da
classe Pessoa e chama o construtor da classe Pessoa no seu construtor.
public class PessoaFisica extends Pessoa{
private String cpf;
PessoaFisica(){}
PessoaFisica(String tel, String cpf){
super(tel);
this.cpf = cpf;
}
void setCPF(String cpf){
this.cpf = cpf;
}
String getCPF(){
return this.cpf;
}
-
Programao Orientada a Objetos 44
}
Veja que o mtodo construtor PessoaFisica(String tel, String CPF) possui na primeira
linha o comando super(tel). Veja que o mtodo construtor Pessoa(String tel) da
classe Pessoa possui como argumento tambm um String tel. Agora quando um objeto
for instanciado utilizando o construtor PessoaFisica(String tel, String cpf) o valor
de tel passado ser utilizado como argumento de super(tel) e ser enviado para o
construtor Pessoa(String tel) da super-classe Pessoa. O valor de tel ser validado no
mtodo Pessoa(String tel) da classe Pessoa e o objeto PessoaFisica ser instanciado.
importante ressaltar que super deve ser sempre a primeira linha do construtor.
Construtor chamando outro construtor da mesma classe.
Uma classe pode ter mais de um construtor (chamado de sobrecarga de mtodos) e um
construtor pode chamar outro construtor da mesma classe. Vejamos o cdigo abaixo:
public class Pessoa {
private String nome;
private int idade;
Pessoa(){ }
Pessoa(String nome){
this.nome = nome;
}
Pessoa(int idade){
this.idade = idade;
}
Pessoa(String nome, int idade){
this(nome);
this.idade = idade;
-
Programao Orientada a Objetos 45
}
}
Veja que o cdigo acima possui trs construtores todos com o mesmo nome e com
assinaturas diferentes. Isso chamado desobrecarga de mtodos. Veja que o
construtor Pessoa(String nome, int idade) possui uma linha chamada this(nome) que
chama o construtor Pessoa(String nome). Essa linha deve ser a primeira linha dentro
do cdigo do construtor. Quando o compilador "v" o comando this(nome) ele procura
um construtor que possua uma argumento do tipo igual ao solicitado nos argumentos do
construtor.
Em resumo podemos chamar um construtor dentro de outro construtor da mesma
classe usando a palavra this(argumento) e chamar o construtor dentro de outro
construtor em classes diferentes (na herana) utilizando a palavra super(argumento).
Relacionamento "tem um" ou composio Acima vimos que PessoaFsica uma Pessoa por isso herda as caractersticas
(atributos) e funcionalidades (mtodos) da classePessoa. Existe outro relacionamento
entre as classes que o tem um. Como exemplo podemos citar o Endereo. Uma
Pessoatem um Endereo. Assim vamos construir uma classe chamada Endereco como
mostra o cdigo abaixo:
public class Endereco {
private String rua, bairro;
public String getRua() {
return rua;
}
public void setRua(String rua) {
this.rua = rua;
-
Programao Orientada a Objetos 46
}
public String getBairro() {
return bairro;
}
public void setBairro(String bairro) {
this.bairro = bairro;
}
}
Veja que a classe acima uma classe que possui atributos e mtodos.
O cdigo abaixo mostra como ser feito o relacionamento tem um entre a
classe Pessoa e a classe Endereco.
package br.atenac.com;
public class Pessoa {
private String nome ;
private String telefone ;
public Endereco end = new Endereco();
Pessoa(){}
Pessoa(String tel){
this.telefone = tel;
}
public String getNome() {
return nome;
}
-
Programao Orientada a Objetos 47
public void setNome(String nome) {
this.nome = nome;
}
public String getTelefone() {
return telefone;
}
public void setTelefone(String telefone) {
this.telefone = telefone;
}
public void setBairro(String bairro){
end.setBairro(bairro);
}
public String getBairro(){
return end.getBairro();
}
public void setRua(String rua){
end.setRua(rua);
}
public String getRua(){
return end.getRua();
}
}
-
Programao Orientada a Objetos 48
Importante
Veja que ao declarar o atributo end do tipo Endereco j foi feita tambm a instanciao
dele. Isso poderia tambm ser feito para os atributos do tipo String. Observe a
linha public Endereco end; que faz o relacionamento entre as
classes Pessoa e Endereco.
Para podermos utilizar as funcionalidades (mtodos) da classe Endereco devemos, no
programa principal instanciar a classeEndereco. Vejamos
package br.atenac.com;
public class AppPessoa {
public static void main(String[]args){
Pessoa p = new Pessoa();
p.setNome("Ana");
p.setTelefone("90994949");
p.setBairro("Bairro A");
p.setRua("Rua a");
System.out.println("Nome: "+p.getNome());
System.out.println("Telefone: "+p.getTelefone());
System.out.println("Bairro: "+p.getBairro());
System.out.println("Rua: "+p.getRua());
}
}
Veja que para utilizar os mtodos setBairro(String
bairro), getBairro(), getRua() e setRua(String rua) usamos a varivel de referncia
do objeto Pessoa porque esses mtodo foram construdos na classe Pessoa.
Exerccios
1. Escrever os exemplos deste Nota de aulae analisar os resultados.
-
Programao Orientada a Objetos 49
2. Escreva uma classe chamada ClasseA que possua um mtodo chamado
metodoA que retorna "eu sou o mtodo A".
3. Escreva uma classe chamada ClasseB que estende da ClasseA e possua um
mtodo chamado metodoB que retorna "eu sou o mtodo B".
4. Crie uma aplicao, em Java, que instancie um objeto da ClasseB e imprimima
utilizando o console o retorno dos dois mtodos criados.
5. Crie uma classe chamada Animal que possua os atributos peso e cor. O
construtor dessa classe dever atribuir o peso e a cor para o animal no momento
da instanciao. Crie os mtodos para configurar e ler esses atributos (mtodos
set e get). Um mtodo chamado mostraAnimal dever ser criado para mostrar o
peso do animal e a cor do animal. O mtodo mostraAnimal dever escrever na
janela gr fica "O animal tem cor " +cor+ "e pesa: " +peso+ " kilos."
6. Crie uma classe chamada Cachorro que estende a classe Animal e coloque os
atributos nome e raa. Crie um construtor para atribuir o nome e a raa do
animal. No corpo do construtor chame o construtor da superclasse para atribuir
peso e cor ao animal instanciado. Crie um outro construtor que atribua somente
o nome do animal ao atributo nome no momento em que o objeto for
instanciado. Crie mtodos para configurar e mostrar os atributos nome e raa.
Nesse caso quando for mostrar o animal, utilize return. No coloque comandos
para imprimir graficamente nem no console.
7. Crie uma classe chamada Cox que estende de Cachorro. Coloque como atributo
tosa do tipo booleano. Crie um construtor que tenha como argumentos o peso,
cor e tosa. Os argumentos peso e cor devero ser passados para o construtor da
super classe e tosa dever ser atribudo ao atributo tosa. Crie um mtodo
chamado mostraAnimal que dever escrever na janela "Este cachorro est
tosado!" se tosa for verdadeiro (true)e a frase "Voc precisa tosar o cachorro!" se
tosa for falsa (false).
8. Crie uma classe chamada Zoologico para implementar criar um objeto de
Cachorro e um objeto de Cox. Utilize os mtodos criados comentando-os.
-
Programao Orientada a Objetos 50
No laboratrio
1. Implemente o exerccio anterior no Java utilizando somente sada grfica.
2. Desenvolver um programa que efetue a soma de todos os nmeros mpares que
se encontram no conjunto dos nmeros inteiros. Construa um mtodo que
possua o nmero inicial e o nmero final. A entrada de dados dever ser feita via
teclado utilizando a interface grfica.
3. Altere o programa anterior para que sejam mostrados os nmeros pares no
intervalo.
-
Programao Orientada a Objetos 51
Nota de aula 5
Ao final da aula o aluno ser capaz de:
Utilizar a sobrecarga de mtodos;
Utilizar reescrita de mtodos;
Diferenciar sobrecarga de reescrita de mtodos;
Sobrecarga de mtodos
Na orientao a objetos podemos utilizar mtodos com mesmo nome mas com
assinaturas diferentes dentro de uma mesma classe. Isso se chama sobrecarga de
mtodos.
Mtodo operacionais e construtores podem ser sobrecarregados em suas classes.
A assinatura do mtodo dada pelos seus argumentos. As assinaturas se diferem de
acordo com a posio e o tipo de dados utilizados.
Vejamos um exemplo:
setRel(String titulo, int pag){}
setRel(int pag, int num_linhas){}
setRel(int titulo, int num_linhas){}
Os mtodos operacionais acima foram todos sobrecarregados pois, possuem o mesmo
nome e as assinaturas so diferentes. Podemos tambm sobrecarregar os mtodos
construtures da mesma forma que sobrecarregamos os mtodos operacionais.
Veja que se tivermos o mtodo abaixo
setRel(String rodape, int pag){}
-
Programao Orientada a Objetos 52
junto com os mtodos acima no temos aqui a sobrecarga de mtodos pois o mtodo
possui assinatura igual ao primeiro mtodo da lista. Veja que ele tem como assinatura
um tipo string e um tipo int igual ao primeiro mtodo da lista acima.
Reescrita de mtodos A reescrita de mtodo depende da herana. Podemos reescrever os mtodos da classe
me. Reescrever um mtodo significa escrever o tipo de retorno do mtodo, o nome do
mtodo e os argumentos (assinatura) conforme o mtodo original. O que ir mudar
somente o corpo do mtodo, isto , o que est entre as chaves {}
Vejamos a classe Conta abaixo:
public class Conta {
public String id;
private float saldo;
Conta(){}
Conta(String id){
if(id.length() == 6){
this.id = id;
}
else{
System.out.print("Nmero de Id invlido");
}
}
public void setId(String id){
if(id.length() == 6){
this.id = id;
}
else{
System.out.print("Nmero de Id invlido");
-
Programao Orientada a Objetos 53
}
}
void setSaldo(float s){
this.saldo = s;
}
String getId(){
return this.id;
}
float getSaldo(){
return this.saldo;
}
}
Veja que ela possui um mtodo operacional que configura o id da conta com 6
caracteres.
Vamos reescrever esse mtodo na classe ContaPF que herda da classe Conta
public class ContaPF extends Conta{
private String cpf;
ContaPF(){}
void setId(String id){
if(id.length() == 8){
this.id = id;
}
-
Programao Orientada a Objetos 54
else{
System.out.println("Valor incorreto para Pessoa Fsica");
}
}
public void setCpf(String cpf) {
this.cpf = cpf;
}
public String getCpf() {
return cpf;
}
}
Veja que na classe ContaPF o mtodo setId no mais valida a id da conta com 6
caracteres e sim com 8 caracteres. Observe que o mtodo setId foi reescrito na
classe ContaPF.
Chamando o mtodo original
Caso queiramos chamar o mtodo original que foi reescrito utilizamos a
palavra super um operador . e o nome do mtodo que queremos chamar.
Vejamos:
public class Conta {
public String id;
Conta(){}
void setId(String id){
if(id.length() == 6){
this.id = id;
}
else{
-
Programao Orientada a Objetos 55
System.out.print("Nmero de Id invlido");
}
}
String getId(){
return this.id;
}
}
A classe ContaPF ir utilizar o mtodo getId() da classe Conta.
Veja o cdigo:
public class ContaPF extends Conta{
private String cpf;
ContaPF(){}
void setId(String id){
if(id.length() == 8){
this.id = id;
}
else{
System.out.println("Valor incorreto para Pessoa Fsica");
}
}
public String getId(){
return super.getId() + "AA";
}
-
Programao Orientada a Objetos 56
public void setCpf(String cpf) {
this.cpf = cpf;
}
public String getCpf() {
return cpf;
}
}
Veja que o mtodo getId() da classe ContaPF chamou o mtodo getId() da
classe Conta utilizando a palavra super um operador .e o nome do mtodo da super
classe. Depois de chamado o mtodo da superclasse foi adicionado os caracteres AA ao
final do retorno do mtodo.
Exerccios
1. Qual a vantagem da reescrita de mtodos?
2. O mtodo de qual classe ser chamado pelo comando super.NomeDoMetodo()?
3. Escreva uma classe chamada Pessoa que possua nome e e-mail como atributos
privados. Crie os mtodos para configurar e mostrar os valores dos atributos.
4. Escreva uma classe que se chama Aluno que herda de Pessoa. Adicione ao aluno
um atributo privado chamado srie, um atributo privado do tipo boolean
chamado aprovado, os atributos privados chamado nota1, nota2, nota3, nota4 e
mdia. Construa os mtodos:
setSerie (pode aceitar nmeros de 1 a 8, caso contrrio zero dever ser atribudo ao
atributo)
seAprovado (aceita valores true ou false)
setNota1(aceita nmeros positivos de 1 a 10, caso contrrio zero dever ser atribudo
ao atributo)
setNota2(aceita nmeros positivos de 1 a 10, caso contrrio zero dever ser atribudo
ao atributo)
-
Programao Orientada a Objetos 57
setNota3(aceita nmeros positivos de 1 a 10, caso contrrio zero dever ser atribudo
ao atributo)
setNota4(aceita nmeros positivos de 1 a 10, caso contrrio zero dever ser atribudo
ao atributo)
setMdia(dever fazer verificar se (n1+n2+n3+n4)/4 >=7. Caso a mdia seja >=7
ento o atributo aprovado dever receber (true) caso contrrio dever receber
(false)).
getSerie(dever retornar a srie)
isAprovado(dever retornar true ou false)
getNota1 (dever retornar a nota1)
getNota2 (dever retornar a nota2)
getNota3 (dever retornar a nota3)
getNota4 (dever retornar a nota4)
5. Crie uma classe chamada AlunoFaculdade que herda de Aluno e reescreva o
mtodo setMedia() de forma que a mdia mude de 7 para 8. Reescreva o mtodo
setSerie para que o aluno se enquadre na faixa de 1 a 3. Construa uma aplicao
para executar as classes acima.
No laboratrio
1. Faa os exerccios anteriores utilizando entradas e sa das grficas do Java
Exerccios complementares
1. Escreva uma classe chamada Pedido. A classe Pedido dever possuir os
atributos privados: cliente, numeroDoPedido, quantidadeDeItens. Crie um
construtor que utilize como parmetro o nome do cliente. Um outro construtor
dever possuir o nome do cliente e o nmero do pedido e um outro construtor
dever possuir como argumento o nome do cliente a quantidadeDeItens e o
nmero do pedido. Insira os mtodos para mostrar cada atributo da classe Pedido
2. Escreva uma aplicao que instancie 3 objetos sendo que cada um utilize um
construtor criado. Mostre todos os atributos para cada objeto instanciado.
-
Programao Orientada a Objetos 58
3. Crie uma classe Conta, que possua um saldo, e os mtodos para configurar
saldo, depositar, e retirar. Siga o esqueleto abaixo:
class Conta {
private double saldo;
void deposita(double x){
//..
}
void retira(double x) {
//..
}
double getSaldo() {
//..
}
}
4. Preencha o esqueleto conforme exemplos vistos no decorrer dos m dulos. Crie
o mtodo retira() que retira um valor da conta e retorne um boolean indicando o
sucesso da operao.
5. Adicione um mtodo na classe Conta, que atualiza essa conta de acordo com a
taxa selic fornecida.
void atualiza(double taxaSelic) {
this.saldo = this.saldo * (1 + taxaSelic);
}
6. Crie duas subclasses da classe Conta: ContaCorrente e ContaPoupanca. Ambas
tero o mtodo atualiza reescrito: A ContaCorrente deve atualizar-se com o
dobro da taxaSelic, porm subtraindo 15 reais de taxa bancria. A
ContaPoupanca deve atualizar-se com 75% da taxaSelic. Alm disso, a
ContaCorrente deve reescrever o mtodo deposita, afim de retirar a CPMF de
0.38% a cada depsito.
class ContaCorrente extends Conta {
-
Programao Orientada a Objetos 59
void atualiza(double taxaSelic){
// fazer conforme enunciado
}
void deposita(double valor) {
// o deposito deve depositar apenas 99.62% do valor
}
}
class ContaPoupanca extends Conta {
void atualiza(double taxaSelic){
// fazer conforme enunciado
}
}
Compila? Executa? O que muda? Qual a utilidade disso?
-
Programao Orientada a Objetos 60
Nota de aula 6
Ao final da aula o aluno ser capaz de:
Instanciar objetos utilizando polimorfismo
Escrever mtodos polimrficos;
Utilizar mtodos polimrfico;
Polimorfismo
Poli significa muitas e morfos significa formas logo a palavra polimorfismo
significa muitas formas. O polimorfismo permite que um objeto assuma um
comportamento diferente daquele definido em sua classe.
A linguagem Java possui dois tipos de polimofismo:
Incluso: quando utilizamos a classe me para instanciar uma classe filha.
Sobrecarga: onde dois mtodos possuem mesmo nome mas assinaturas diferentes.
Polimorfismo de incluso
A reescrita de mtodos deve ser entendida como polimorfismo de incluso. Para
reescrever um mtodo necessrio que tenhamos uma relao de herana entre duas ou
mais classes. O mtodo que ser reescrito deve existir na classe me. Ao reescrever o
mtodo ele dever ter o mesmo tipo de retorno, mesmo nome e mesma assinatura. O
mtodo na classe filha ir fornecer apenas uma nova funcionalidade para o mtodo da
classe me, ou seja, o corpo do mtodo ser escrito de forma diferente da classe me.
O exemplo abaixo possui uma classe chamada Figura que tem um mtodo public float
calcularArea(float p1, float p2). O corpo do mtodo retorna zero (no sabemos de qual
figura ser calculada a rea ainda. Mas sabemos que necessrio ter dois argumentos).
public class Figura {
public float calcularArea(float p1, float p2){
return 0;
-
Programao Orientada a Objetos 61