Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
1
Centro Paula Sousa
Orientação a objetos
com java
Celio Assunção
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
2
1.7.
Introdução
Breve história do Java
Java Virtual Machine
Java lento? Hotspot e JIT
Bibliotecas de classes
Linguagens
Plataformas similares
07
07
08
09
09
10
10
2.1
2.2
2.3
Algoritmo e Implementação
Compilando o primeiro programa
Exercícios: Modificando o Hello World
10
11
12
3.1
3.2
3.3
Variáveis primitivas e Controle de fluxo
Outros tipos primitivos
Exercícios: Variáveis e tipos primitivos
12
14
14
4.1
4.2
4.3
4.4
4.5
O If-Else
O laço While
O laço For
Escopo das variáveis
Exercícios: Fixação de sintaxe
14
15
15
17
18
5.1
5.2
5.3
5.4
5.5
5.6
5.7
5.8
5.9
5.10
Orientação a objetos básica
Exercícios
Classes
Exercícios classes e subclasses
Classes, Atributos e Métodos
Objetos são acessados por referências
O Método transfere()
Para saber mais: Uma Fábrica de Carros
Exercícios: Orientação a Objetos
Exercício de fixação
21
24
24
24
25
26
27
28
31
32
6.1
6.2
Construção De Programas Em Java
Métodos Construtores e Overloading
36
37
1.1.
1.2.
1.3.
1.4.
1.5.
1.6.
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
3
6.14
Utilização das API’s
39
Utilizando gestores de erro
39
Entrada dados com GET
40
Conceito De Pacote
41
Métodos: Públicos, Privados E Protegidos 41
Exercícios de fixação
41
Chamando método de outra classe
42
Passando valores por parâmetro
42
Função retorna valores
42
Usando o conceito de pacote
44
Desafio
44
Fixando o conhecimento
45
7.1.
7.2.
7.3.
7.4.
7.5.
7.6.
7.7.
7.8.
7.9.
7.10.
7.11.
7.12.
7.13.
7.14.
Programação orientada a objetos
Criando nova classe para Vendas
Exercício de fixação
Modificadores de acesso
Encapsulamento
Exemplo com encapsulamento
Alterando uma variável private
Getters e Setters
Construtores
A necessidade de um construtor
Exemplo usando construtor
Implementando vários Construtores
Atributos de Classe
Exercícios: Encapsulamento
46
46
47
47
50
51
52
52
54
55
56
57
60
61
8.1.
8.2.
8.3.
8.4.
8.5.
8.6.
8.7.
Composição e Herança
Construindo exemplo Herança
Criando classe filha
Classe sistema void
Método para private
Exercício de fixação
Polimorfismo
62
62
64
64
65
67
68
6.3
6.4
6.5
6.6
6.7
6.8
6.9
6.10
6.11
6.12
6.13
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
4
8.8.
8.9.
Implementando polimorfismo
Outro exemplo polimorfismo
70
70
9.1.
9.2.
9.3.
9.4.
9.5.
Formulários
Jframe setSize/setLocation
Jfrane setDefautCloseOperation/ setResizable
Manipulando cores getContentPane
Inserindo mais componentes
Dicas Eclipse
72
73
73
74
74
76
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
5
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
6
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
7
1.1 Introdução
Plataforma Java é o nome dado ao ambiente computacional, ou plataforma, da
empresa estadunidense Sun Microsystems. A plataforma permite desenvolver aplicativos
utilizando qualquer uma das linguagens criadas para a plataforma Java, sendo a linguagem
padrão a que leva seu próprio nome: Linguagem Java. Uma grande vantagem da plataforma é a
de não estar presa a um único sistema operacional ou hardware, pois seus programas rodam
através de uma máquina virtual que pode ser emulada em qualquer sistema que suporte
a linguagem C++.
1.2 Breve história do Java
A Sun criou um time (conhecido como Green Team) para desenvolver inovações
tecnológicas em 1992. Esse time foi liderado por James Gosling, considerado o pai do Java. O
time voltou com a ideia de criar um interpretador (já era uma máquina virtual, veremos o que é
isso mais a frente) para pequenos dispositivos, facilitando a reescrita de software para aparelhos
eletrônicos, como vídeo cassete, televisão e aparelhos de TV a cabo.
A ideia não deu certo. Tentaram fechar diversos contratos com grandes fabricantes de
eletrônicos, como Panasonic, mas não houve êxito devido ao conflito de interesses e custos.
Hoje, sabemos que o Java domina o mercado de aplicações para celulares com mais de 2.5
bilhões de dispositivos compatíveis, porém em 1994 ainda era muito cedo para isso.
Com o advento da web, a Sun percebeu que poderia utilizar a idéia criada em 1992 para
rodar pequenas aplicações dentro do browser. A semelhança era que na internet havia uma
grande quantidade de sistemas operacionais e browsers, e com isso seria grande vantagem poder
programar numa única linguagem, independente da plataforma. Foi aí que o Java 1.0 foi lançado:
focado em transformar o browser de apenas um cliente fino (thin client ou terminal burro) para
uma aplicação que possa também realizar operações, não apenas renderizar html.
Atualmente os applets realmente não são o foco da Sun. É curioso notar que a tecnologia
Java nasceu com um objetivo em mente, foi lançado com outro, mas, no final, decolou mesmo no
desenvolvimento de aplicações do lado do servidor. Sorte?
Você pode ler a história da linguagem Java em: http://www.java.com/en/javahistory/
E um vídeo interessante: http://tinyurl.com/histjava
Em 2009 a Oracle comprou a Sun, fortalecendo a marca. A Oracle sempre foi, junto com
a IBM, uma das empresas que mais investiram e fizeram negócios através do uso da plataforma
Java.
No Brasil, diversos grupos de usuários se formaram para tentar disseminar o
conhecimento da linguagem.
Um deles é o GUJ (http://www.guj.com.br), uma comunidade virtual com artigos,
tutoriais e fórum para tirar dúvidas, o maior em língua portuguesa com mais de cem mil usuários
e 1 milhão de mensagens.
Encorajamos todos os alunos a usar muito os fóruns do mesmo, pois é uma das melhores
maneiras para achar soluções para pequenos problemas que acontecem com grande frequência.
O universo Java é um vasto conjunto de tecnologias, composto por três plataformas
principais que foram criadas para segmentos específicos de aplicações:
• Java SE (Java Platform, Standard Edition). É a base da plataforma; inclui o ambiente de
execução e as bibliotecas comuns.
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
8
• Java EE (Java Platform, Enterprise Edition). A edição voltada para o desenvolvimento de
aplicações corporativas e para internet.
• Java ME (Java Platform, Micro Edition). A edição para o desenvolvimento de aplicações
para dispositivos móveis e embarcados.
• JavaFX. Plataforma para desenvolvimento de aplicações multimídia em desktop/web
(JavaFX Script) e dispositivos móveis (JavaFX Mobile).
Tecnologias Java
A plataforma Java é constituída de um grande número de tecnologias, cada uma provê
uma porção distinta de todo o ambiente de desenvolvimento e execução de software. Os usuários
finais, tipicamente, interagem com a máquina virtual Java (Java Virtual Machine, ou JVM) e um
conjunto padrão de bibliotecas de classe.
Existe um grande número de maneiras de se utilizar uma aplicação Java, incluindo
applets embutidas em páginas web, aplicativos de uso geral em desktops, aplicativos
em aparelhos celulares e em servidores de aplicações para Internet.
Os desenvolvedores de aplicações em Java utilizam um conjunto de ferramentas de
desenvolvimento, o JDK.
Um programa escrito para a plataforma Java necessita de dois componentes para ser
executado: a máquina virtual Java, e um conjunto de bibliotecas de classe que disponibilizam um
série de serviços para esse programa. O pacote de software que contém a máquina virtual e esta
biblioteca de classes é conhecido como JRE (Java Runtime Environment).
1.3 Java Virtual Machine
Em uma linguagem de programação como C e Pascal, temos a seguinte situação quando
vamos compilar um programa:
Codigo Binário para
compilador
Codigo Fonte em C
Determinado SO
O código fonte é compilado para código de máquina específico de uma plataforma e
sistema operacional.
Muitas vezes o próprio código fonte é desenvolvido visando uma única plataforma!
Esse código executável (binário) resultante será executado pelo sistema operacional e,
por esse motivo, ele deve saber conversar com o sistema operacional em questão.
Instituto Paula Sousa –
Codigo Binario
Orientação a objetos com
Parajava
Windows
Celio Assunção
9
Aplicação
Windows
Sistema Operacional
Codigo Binario
Para Linux
Linux
Isto é, temos um código executável para cada sistema operacional. É necessário compilar
uma vez para Windows, outra para o Linux, e assim por diante, caso a gente queira que esse
nosso software possa ser utilizado em várias plataformas. Esse é o caso de aplicativos como o
OpenOffice, Firefox e outros.
Como foi dito anteriormente, na maioria das vezes, a sua aplicação se utiliza das
bibliotecas do sistema operacional, como, por exemplo, a de interface gráfica para desenhar as
“telas”. A biblioteca de interface gráfica do Windows é bem diferente das do Linux: como criar
então uma aplicação que rode de forma parecida nos dois sistemas operacionais?
Precisamos reescrever um mesmo pedaço da aplicação para diferentes sistemas
operacionais, já que eles não são compatíveis.
Já o Java utiliza do conceito de máquina virtual, onde existe, entre o sistema operacional
e a aplicação, uma camada extra responsável por “traduzir” - mas não apenas isso - o que sua
aplicação deseja fazer para as respectivas chamadas do sistema operacional onde ela está
rodando no momento:
Bytecode java
Bytecode java
Maquina Virtual java
Para Linux
Maquina Virtual java
Para Windows
Linux
Windows
Dessa forma, a maneira com a qual você abre uma janela no Linux ou no Windows é a
mesma: você ganha independência de sistema operacional. Ou, melhor ainda, independência de
plataforma em geral: não é preciso se preocupar em qual sistema operacional sua aplicação está
rodando, nem em que tipo de máquina, configurações, etc.
Repare que uma máquina virtual é um conceito bem mais amplo que o de um
interpretador. Como o próprio nome diz, uma máquina virtual é como um “computador de
mentira": tem tudo que um computador tem. Em outras palavras, ela é responsável por gerenciar
memória, threads, a pilha de execução, etc.
Sua aplicação roda sem nenhum envolvimento com o sistema operacional! Sempre
conversando apenas com a Java Virtual Machine (JVM).
1.4 - Java lento? Hotspot e JIT
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
10
Hotspot é a tecnologia que a JVM utiliza para detectar os pontos mais utilizados da sua
aplicação: código que é executado muito, provavelmente dentro de um ou mais loops. Quando a
JVM julgar necessário, ela vai compilar estes códigos para instruções realmente nativas, em
linguagem de máquina da plataforma, tendo em vista que isso vai provavelmente melhorar a
performance da sua aplicação. Esse compilador é o JIT: Just inTime Compiler, o compilador que
aparece “bem na hora” que você precisa.
1.5 Bibliotecas de classes
Na maioria dos sistemas operacionais modernos, um corpo formado por código reusável é
organizado e disponibilizado para simplificar o trabalho do programador. Este código encontrase, normalmente, na forma de bibliotecas dinâmicas que a aplicação utiliza durante a sua
execução. Como a plataforma Java não é dependente de qualquer sistema operacional, as
aplicações não podem depender das bibliotecas destes sistemas. Ao contrário, a plataforma
Java disponibiliza um grande conjunto padronizado de bibliotecas de classe, que contém
praticamente o mesmo número de funções encontradas nos sistemas operacionais modernos.
Uma classe de biblioteca Java serve a três propósitos dentro da plataforma Java. Como
outras bibliotecas padrão, elas disponibilizam ao programador um conjunto de funções bem
conhecidas que realizam tarefas comuns, como a manutenção de listas de elementos ou
manipulação de strings. Em adição, a biblioteca contém uma interface para tarefas que
dependem do hardware e do sistema operacional. Tarefas como acesso a rede e a arquivos são
altamente dependentes das capacidades nativas do ambiente.
As bibliotecas java.net e java.io implementam o código necessário internamente, e
disponibilizam uma interface padrão para que as aplicações Java possam executar estas tarefas.
Finalmente, se alguma plataforma não suportar alguma função que uma aplicação Java necessita,
as bibliotecas implementam esta funcionalidade usando os recursos disponíveis, ou
disponibilizam um meio consistente para que a aplicação verifique a presença de determinada
funcionalidade.
1.6 Linguagens
A palavra Java usualmente é uma referência a linguagem de programação Java, que é
a primeira linguagem criada pela Sun Microsystems para a JVM. A segunda linguagem criada
pela Sun Microsystems para a JVM é chamada de Groovy, uma linguagem mais dinâmica,
inspirada em linguagens como Python, Ruby e Smalltalk. Também existem implementações para
a linguagem Python, a Jython, e para a linguagem Ruby, a JRuby.
1.7
Plataformas similares
O sucesso da plataforma Java e o seu conceito write once, run anywhere levaram a outros
esforços similares. O mais notável destes esforços é a plataforma .NET, da Microsoft, que
utilizou muitos dos conceitos e inovações da plataforma Java sem, contudo, implementar os
recursos de portabilidade entre sistemas operacionais e plataformas que a plataforma Java possui
2.1 - Algoritmo e Implementação
Um algoritmo é uma sequência de passos que resolve algum problema ou alcança algum
objetivo, . É importante salientar que um algoritmo simplesmente diz o que deve ser feito.
Considere o problema de descobrir a altura da pessoa mais alta de um grupo de pessoas. Suponha
Figura 2.1: Fila de pessoas
que estas pessoas estão em sequência, como em uma fila de banco, e que esta fila não está vazia.
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
11
Vamos elaborar uma estratégia para resolver este problema. Uma solução bem simples seria
fazer o seguinte:
1) Pegue a altura da primeira pessoa. A única informação que você tem é que esta altura é a
máxima até o momento. Então, “guarde” em algum lugar esta informação.
2) Percorra cada uma das próximas pessoas e faça o seguinte:
1) Pegue a altura da pessoa, esta é a altura atual.
2) Compare a altura atual com a máxima até o momento. Esta comparação pode resultar em três
possibilidades: a altura atual é menor, é igual ou é maior.
3) Se a altura atual for maior, então faça o valor da altura máxima ser igual a atual.
Será que este procedimento é bom? Nesse caso temos de percorrer todas as pessoas da fila até ter
certeza que encontramos a maior pessoa, pois a única invariante que temos, a cada passo do
procedimento, é que até aquele momento todas as pessoas percorridas tem tamanho igual ou
menor a um determinado número.
Existe solução melhor? E se tivéssemos as pessoas organizadas de alguma maneira especial,
chegaríamos a solução em um menor tempo? E se houveram empates, quais outras pessoas são
tão altas quanto essa nossa resposta?
2.2 - Compilando o primeiro programa
Vamos para o nosso primeiro código! O programa que imprime uma linha simples.
Para mostrar uma linha, podemos fazer:
System.out.println("Minha primeira aplicação Java!");
Mas esse código não será aceito pelo compilador java. O Java é uma linguagem bastante
burocrática, e precisa de mais do que isso para iniciar uma execução. Veremos os detalhes e os
porquês durante os próximos capítulos. O mínimo que precisaríamos escrever é algo como:
class MeuPrograma {
public static void main(String[] args) {
System.out.println("Minha primeira aplicação Java!");
}
}
Após digitar o código acima, grave-o como MeuPrograma.java em algum diretório. Para
compilar, você deve pedir para que o compilador de Java da Sun, chamado javac, gere o
bytecode correspondente ao seu código Java.
Os procedimentos para executar seu programa são muito simples. O javac é o compilador
Java, e o java é o responsável por invocar a máquina virtual para interpretar o seu programa.
1 class MeuPrograma {
2
public static void main(String[] args) {
3
4
// miolo do programa começa aqui!
5
System.out.println("Minha primeira aplicação Java!!");
Instituto Paula Sousa –
6
Orientação a objetos com java
Celio Assunção
12
// fim do miolo do programa
7
8
}
9}
O miolo do programa é o que será executado quando chamamos a máquina virtual. Por
enquanto, todas as linhas anteriores, onde há a declaração de uma classe e a de um método, não
importam para nós nesse momento. Mas devemos saber que toda aplicação Java começa por um
ponto de entrada, e este ponto de entrada é o método main.
Ainda não sabemos o que é método, mas veremos no capítulo 4. Até lá, não se preocupe
com essas declarações. Sempre que um exercício for feito, o código que nos importa sempre
estará nesse miolo.
2.3 Exercícios: Modificando o Hello World
1) Altere seu programa para imprimir uma mensagem diferente.
2) Altere seu programa para imprimir duas linhas de texto usando duas linhas de código
System.out.
3) Sabendo que os caracteres \n representam uma quebra de linhas, imprima duas linhas de
texto usando uma única linha de código System.out.
3.1.
Variáveis primitivas e Controle de fluxo
Declarando e usando variáveis
Dentro de um bloco, podemos declarar variáveis e usá-las. Em Java, toda variável tem um tipo
que não pode ser mudado, uma vez que declarado
tipoDaVariavel nomeDaVariavel;
Por exemplo, é possível ter uma idade que guarda um número inteiro:
int idade;
Com isso, você declara a variável idade, que passa a existir a partir daquela linha. Ela é do tipo
int, que guarda um número inteiro. A partir daí, você pode usá-la, primeiramente atribuindo
valores.
A linha a seguir é a tradução de: “idade deve valer quinze”.
Idade = 15;
Além de atribuir, você pode utilizar esse valor. O código a seguir declara novamente a variável
idade com valor 15 e imprime seu valor na saída padrão através da chamada a
System.out.println.
// declara a idade
int idade;
idade = 15;
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
13
// imprime a idade
System.out.println(idade);
Por fim, podemos utilizar o valor de uma variável para algum outro propósito, como alterar ou
definir uma segunda variável. O código a seguir cria uma variável chamada
idadeNoAnoQueVem com valor de idade mais um.
// calcula a idade no ano seguinte
int idadeNoAnoQueVem;
idadeNoAnoQueVem = idade + 1;
No mesmo momento que você declara uma variável, também é possível inicializá-la por
praticidade:
int idade = 15;
Você pode usar os operadores +, -, / e * para operar com números, sendo eles responsáveis pela
adição, subtração, divisão e multiplicação, respectivamente. Além desses operadores básicos, há
o operador % (módulo) que nada mais é que o resto de uma divisão inteira. Veja alguns
exemplos:
int quatro = 2 + 2;
int tres = 5 – 2;
int oito = 4 * 2;
int dezesseis = 64 / 4;
int um = 5 % 2; // 5 dividido por 2 dá 2 e tem resto 1;
// o operador % pega o resto da divisão inteira
Representar números inteiros é fácil, mas como guardar valores reais, tais como frações de
números inteiros e outros? Outro tipo de variável muito utilizado é o double, que armazena um
número com ponto flutuante (e que também pode armazenar um número inteiro).
double pi = 3.14;
double x = 5 * 10;
O tipo boolean armazena um valor verdadeiro ou falso, e só: nada de números, palavras ou
endereços, como em algumas outras linguagens.
boolean verdade = true;
true e false são palavras reservadas do Java. É comum que um boolean seja determinado através
de uma expressão booleana, isto é, um trecho de código que retorna um booleano, como o
exemplo:
int idade = 30;
boolean menorDeIdade = idade < 18;
O tipo char guarda um, e apenas um, caractere. Esse caractere deve estar entre aspas simples.
Não se esqueça dessas duas características de uma variável do tipo char! Por exemplo, ela não
pode guardar um código como ” pois o vazio não é um caractere!
char letra = ’a’;
System.out.println(letra);
Instituto Paula Sousa –
3.2.
Orientação a objetos com java
Celio Assunção
14
Outros tipos primitivos
Vimos aqui os tipos primitivos que mais aparecem. O Java tem outros, que são o byte, short, long
e float.
Cada tipo possui características especiais que, para um programador avançado, podem fazer
muita diferença
3.3.
Exercícios: Variaveis primitivas
1) Na empresa onde trabalhamos, há tabelas com o quanto foi gasto em cada mês. Para fechar o
balanço do primeiro trimestre, precisamos somar o gasto total. Sabendo que, em Janeiro, foram
gastos 15000 reais, em Fevereiro, 23000 reais e em Março, 17000 reais, faça um programa que
calcule e imprima o gasto total no trimestre. Siga esses passos:
a) Crie uma classe chamada BalancoTrimestral com um bloco main, como nos exemplos
anteriores;
b) Dentro do main (o miolo do programa), declare uma variável inteira chamada gastosJaneiro e
inicialize-a com 15000;
c) Crie também as variáveis gastosFevereiro e gastosMarco, inicializando-as com 23000 e
17000, respectivamente, utilize uma linha para cada declaração;
d) Crie uma variável chamada gastosTrimestre e inicialize-a com a soma das outras 3 variáveis:
int gastosTrimestre = gastosJaneiro + gastosFevereiro + gastosMarco;
e) Imprima a variável gastosTrimestre.
2) Adicione código (sem alterar as linhas que já existem) na classe anterior para imprimir a
média mensal de gasto, criando uma variável mediaMensal junto com uma mensagem.
Para isso, concatene a String com o valor, usando "Valor da média mensal = "+ mediaMensal.
Agora aquela perguntinha que não quer calar, Entenderam???
Durante o curso veremos outros tipos de variáveis primitivas, não se preocupem que chegaremos
lá.
4.1.
O if – elese
A sintaxe do if no Java é a seguinte:
if (condicaoBooleana) {
codigo;
}
Uma condição booleana é qualquer expressão que retorne true ou false. Para isso, você
pode usar os
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
15
operadores <, >, <=, >= e outros. Um exemplo:
int idade = 15;
if (idade < 18) {
System.out.println("Não pode entrar");
}
Além disso, você pode usar a cláusula else para indicar o comportamento que deve ser executado
no caso da expressão booleana ser falsa:
int idade = 15;
if (idade < 18) {
System.out.println("Não pode entrar");
} else {
System.out.println("Pode entrar");
}
Você pode concatenar expressões booleanas através dos operadores lógicos “E” e “OU”. O “E” é
representado pelo && e o “OU” é representado pelo ||.
Um exemplo seria verificar se ele tem menos de 18 anos e se ele não é amigo do dono:
int idade = 15;
boolean amigoDoDono = true;
if (idade < 18 && amigoDoDono == false) {
System.out.println("Não pode entrar");
}
else {
System.out.println("Pode entrar");
}
Esse código poderia ficar ainda mais legível, utilizando-se o operador de negação, o !. Esse
operador transforma o resultado de uma expressão booleana de false para true e vice versa.
1 int idade = 15;
2 boolean amigoDoDono = true;
3 if (idade < 18 && !amigoDoDono) {
4
System.out.println("Não pode entrar");
5}
else {
7
System.out.println("Pode entrar");
8
}
Repare na linha 3 que o trecho amigoDoDono == false virou !amigoDoDono. Eles têm o mesmo
valor.
Para comparar se uma variável tem o mesmo valor que outra variável ou valor, utilizamos o
operador ==.
Repare que utilizar o operador = dentro de um if vai retornar um erro de compilação, já que o
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
16
operador = é o de atribuição.
int mes = 1;
if (mes == 1) {
System.out.println("Você deveria estar de férias");
4.2.
O laço while
O while é um comando usado para fazer um laço (loop), isto é, repetir um trecho de código
algumas vezes.
A idéia é que esse trecho de código seja repetido enquanto uma determinada condição
permanecer verdadeira.
int idade = 15;
while (idade < 18) {
System.out.println(idade);
idade = idade + 1;
}
O trecho dentro do bloco do while será executado até o momento em que a condição idade < 18
passe a ser falsa. E isso ocorrerá exatamente no momento em que idade == 18, o que não o fará
imprimir 18.
int i = 0;
while (i < 10) {
System.out.println(i);
i = i + 1;
}
Já o while acima imprime de 0 a 9.
4.3.
O laço For
Outro comando de loop extremamente utilizado é o for. A idéia é a mesma do while: fazer um
trecho de código ser repetido enquanto uma condição continuar verdadeira. Mas além disso, o
for isola também um espaço para inicialização de variáveis e o modificador dessas variáveis. Isso
faz com que fiquem mais legíveis, as variáveis que são relacionadas ao loop:
for (inicializacao; condicao; incremento) {
codigo;
}
Um exemplo é o a seguir:
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
17
for (int i = 0; i < 10; i = i + 1) {
System.out.println("olá!");
}
Repare que esse for poderia ser trocado por:
int i = 0;
while (i < 10) {
System.out.println("olá!");
i = i + 1;
}
4.4.
Escopo das variáveis
No Java, podemos declarar variáveis a qualquer momento. Porém, dependendo de onde você as
declarou, ela vai valer de um determinado ponto a outro.
// aqui a variável i não existe
int i = 5;
// a partir daqui ela existe
O escopo da variável é o nome dado ao trecho de código em que aquela variável existe e onde é
possível acessá-la.
Quando abrimos um novo bloco com as chaves, as variáveis declaradas ali dentro só valem até o
fim daquele bloco.
// aqui a variável i não existe
int i = 5;
// a partir daqui ela existe
while (condicao) {
// o i ainda vale aqui
int j = 7;
// o j passa a existir
}
// aqui o j não existe mais, mas o i continua dentro do escopo
No bloco acima, a variável j pára de existir quando termina o bloco onde ela foi declarada. Se
você tentar acessar uma variável fora de seu escopo, ocorrerá um erro de compilação.
O mesmo vale para um if:
if (algumBooleano) {
int i = 5;
}
else {
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
18
int i = 10;
}
System.out.println(i); // cuidado!
Aqui a variável i não existe fora do if e do else! Se você declarar a variável antes do if, vai haver
outro erro de compilação: dentro do if e do else a variável está sendo redeclarada! Então o
código para compilar e fazer sentido fica:
int i;
if (algumBooleano) {
i = 5;
}
else {
i = 10;
}
System.out.println(i);
Uma situação parecida pode ocorrer com o for:
for (int i = 0; i < 10; i++) {
System.out.println("olá!");
}
System.out.println(i); // cuidado!
Neste for, a variável i morre ao seu término, não podendo ser acessada de fora do for, gerando
um erro de compilação. Se você realmente quer acessar o contador depois do loop terminar,
precisa de algo como:
int i;
for (i = 0; i < 10; i++) {
System.out.println("olá!");
}
System.out.println(i);
4.5.
Exercícios de fixação: Sintaxe
Mais exercícios de fixação de sintaxe. Para quem já conhece um pouco de Java, pode ser
muito simples; mas recomendamos fortemente que você faça os exercícios para se acostumar
com erros de compilação, mensagens do javac, convenção de código, etc...
Apesar de extremamente simples, precisamos praticar a sintaxe que estamos aprendendo.
Para cada exercício, crie um novo arquivo com extensão .java, e declare aquele estranho
cabeçalho, dando nome a uma classe e com um bloco main dentro dele:
class ExercicioX
{
public static void main(String[] args)
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
19
{
// seu exercicio vai aqui
}
}
NÃO copie e cole de um exercício já existente! Aproveite para praticar.
Quando você estiver familiarizado com os procedimentos tudo bem, por enquanto escreva os
códigos. Tá bom?
1) Imprima todos os números de 150 a 300.
2) Imprima a soma de 1 até 1000.
3) Imprima todos os múltiplos de 3, entre 1 e 100.
4) Imprima os fatoriais de 1 a 10.
O fatorial de um número n é n * n-1 * n-2 ... até n = 1. Lembre-se de utilizar os parênteses.
O fatorial de 0 é 1
O fatorial de 1 é (0!) * 1 = 1
O fatorial de 2 é (1!) * 2 = 2
O fatorial de 3 é (2!) * 3 = 6
O fatorial de 4 é (3!) * 4 = 24
Faça um for que inicie uma variável n (número) como 1 e fatorial (resultado) como 1 e
varia n de 1 até 10:
for (int n = 1, fatorial = 1; n <= 10; n++) {
}
5) Aumente a quantidade de números que terão os fatoriais impressos, até 20, 30, 40. Em um
determinado momento, além desse cálculo demorar, vai começar a mostrar
respostas completamente erradas. Porque?
Mude de int para long, e você poderá ver alguma mudança.
6) (opcional) Imprima os primeiros números da série de Fibonacci até passar de 100. A série de
Fibonacci é a seguinte: 0, 1, 1, 2, 3, 5, 8, 13, 21, etc... Para calculá-la, o primeiro e segundo
elementos valem 1, daí por diante, o n-ésimo elemento vale o (n-1)-ésimo elemento somado ao
(n-2)-ésimo elemento (ex: 8 = 5 + 3).
7) (opcional) Escreva um programa que, dada uma variável x (com valor 180, por exemplo),
temos y de acordo com a seguinte regra:
# se x é par, y = x / 2
# se x é impar, y = 3 * x + 1
# imprime y
# O programa deve então jogar o valor de y em x e continuar até que y tenha o valor final
de 1. Por
exemplo, para x = 13, a saída será:
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
20
40 -> 20 -> 10 -> 5 -> 16 -> 8 -> 4 -> 2 -> 1
Imprimindo sem pular linha
Um detalhe importante é que uma quebra de linha é impressa toda vez que chamamos
println.
Para não pular uma linha, usamos o código a seguir:
System.out.print(variavel);
8) (opcional) Imprima a seguinte tabela, usando fors encadeados:
1
24
369
4 8 12 16
n n*2 n*3 .... n*n
Fazer esses exercícios é importante para praticar algoritmos. Mais exercícios de algoritmos
peça para o e-mail ([email protected]) assunto exercícios algoritmo
Instituto Paula Sousa –
5.1.
Orientação a objetos com java
Celio Assunção
21
Orientação a objetos básica
O Que São Objetos ?
Quando temos um problema e queremos resolvê-lo usando um computador,
necessariamente temos que fazer um programa. Este nada mais é do que uma serie de instruções
que indicam ao computador como proceder em determinadas situações. Assim, o grande desafio
do programador é estabelecer a associação entre o modelo que o computador usa e o modelo que
o problema lhe apresenta.
Isso geralmente leva o programador a modelar o problema apresentado para o modelo
utilizado em alguma linguagem. Se a linguagem escolhida for LISP, o problema será traduzido
como listas encadeadas. Se for Prolog, o problema será uma cadeia de decisões. Assim, a
representação da solução para o problema é característica da linguagem usada, tornando a escrita
difícil.
A orientação a objetos tenta solucionar esse problema. A orientação a objetos é geral o
suficiente para não impor um modelo de linguagem ao programador, permitindo a ele escolher
uma estratégia, representando os aspectos do problema em objetos. Assim, quando se "lê" um
programa orientado a objeto, podemos ver não apenas a solução, mas também a descrição do
problema em termos do próprio problema. O programador consegue "quebrar" o grande
problema em pequenas partes que juntas fornecem a solução.
Olhando à sua volta é possível perceber muitos exemplos de objetos do mundo real: seu
cachorro, sua mesa, sua televisão, sua bicicleta. Esses objetos tem duas características básicas,
que são o estado e o comportamento.
Por exemplo, os cachorros tem nome, cor, raça (estados) e eles balançam o rabo, comem,
e latem (comportamento). Uma bicicleta tem 18 marchas, duas rodas, banco (estado) e elas
brecam, aceleram e mudam de marcha (comportamento).
De maneira geral, definimos objetos como um conjunto de variáveis e métodos, que
representam seus estados e comportamentos.
Veja a ilustração:
Variáveis
Métodos
Temos aqui representada (de maneira lógica) a idéia que as linguagens orientadas a objeto
utilizam. Tudo que um objeto sabe (estados ou variáveis) e tudo que ele podem fazer
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
22
(comportamento ou métodos) está contido no próprio objeto.
No exemplo da bicicleta, poderemos representar o objeto como no exemplo abaixo:
10 Mpm
Modificar
Engrenagens
freios
50 rpm
5th eqp
Modificar
marchas
Temos métodos para mudar a marcha, a cadência das pedaladas, e para brecar. A
utilização desses métodos altera os valores dos estados. Ao brecar, a velocidade diminui. Ao
mudar a marcha, a cadência é alterada.
Note que os diagramas mostram que as variáveis do objeto estão no centro do mesmo. Os
métodos cercam esses valores e os “escondem” de outros objetos. Deste modo, só é possível ter
acesso a essas variáveis através dos métodos. Esse tipo de construção é chamada de
encapsulamento, e é a construção ideal para objetos.
Exercício
- Imagine um exemplo de objeto diferente dos vistos até agora. Para esse objeto, relacione
possíveis métodos e atributos.
Mas um objeto sozinho geralmente não é muito útil. Ao contrário, em um programa
orientado a objetos temos muitos objetos se relacionando entre si. Uma bicicleta encostada na
garagem nada mais é que um pedaço de ferro e borracha. Por si mesma, ela não tem capacidade
de realizar nenhuma tarefa. Apenas com outro objeto (você) utilizando a bicicleta, ela é capaz de
realizar algum trabalho.
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
23
A interação entre objetos é feita através de mensagens. Um objeto “chama” os métodos
de outro, passando parâmetros quando necessário. Quando você passa a mensagem “mude de
marcha” para o objeto bicicleta você precisa dizer qual marcha você deseja.
A figura a seguir mostra os três componentes que fazem parte de uma mensagem:
· objeto para o qual a mensagem é dirigida (bicicleta)
· nome do método a ser executado (mudamarcha)
· os parâmetros necessários para a execução do método.
Mudar marcha
(Torre de
engrenagens)
voce
Sua Bicicleta
A troca de mensagens nos fornece ainda um benefício importante. Como todas as
interações são feitas através delas, não importa se o objeto faz parte do mesmo programa; ele
pode estar até em outro computador. Existem maneiras de enviar essas mensagens através da
rede, permitindo a comunicação remota entre objetos.
Assim, um programa orientado a objetos nada mais é do que um punhado de objetos
dizendo um ao outro o que fazer. Quando você quer que um objeto faca alguma coisa, você envia
a ele uma "mensagem" informando o que quer fazer, e o objeto faz. Se ele precisar de outro
objeto que o auxiliar a realizar o "trabalho", ele mesmo vai cuidar de enviar mensagem para esse
outro objeto. Deste modo, um programa pode realizar atividades muito complexas baseado
apenas em uma mensagem inicial.
Você pode definir vários tipos de objetos diferentes para seu programa. Cada objeto terá
suas próprias características, e saberá como interpretar certos pedidos. A parte interessante é que
objetos de mesmo tipo se comportam de maneira semelhante. Assim, você pode ter funções
genéricas que funcionam para vários tipos diferentes, economizando código.
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
24
Vale lembrar que métodos são diferentes de procedimentos e funções das linguagens
procedurais, e é muito fácil confundir os conceitos. Para evitar a confusão, temos que entender o
que são classes.
5.2 Exercícios
– Imagine dois objetos que se relacionam. Mostre como é possível através de mensagens o
relacionamento entre eles.
5.3 Classes
Até agora, comentamos sobre o que é um objeto e como ele se relaciona com outros
objetos. Falaremos agora a respeito de classes.
Sua bicicleta é apenas uma das várias que existem. A sua bicicleta específica foi feita por um
fabricante, e tem certas características que seguem uma linha ou modelo. Assim, é possível ir a
uma loja e comprar várias unidades de bicicletas essencialmente idênticas. Mas não podemos
dizer que todas são o mesmo objeto, simplesmente por serem parecidas.
Em orientação a objetos, dizemos que um (ou mais) objetos pertencem a uma classe
quando eles são muito semelhantes, de acordo com certos padrões. Assim, dependendo da
situação, alguém pode dizer que sua bicicleta é um veículo, pois ele anda sobre rodas e carrega
uma pessoa. Se seguirmos esse padrão, uma motocicleta também é um veículo, assim como um
automóvel ou até um avião (ué, não anda sobre rodas quando decola ou pousa ? Não carrega uma
pessoa ?). Na verdade, quando programamos em linguagens orientadas a objetos, antes de tudo
nós construímos as classes, os modelos, para depois usá-las na criação de objetos daquele tipo.
Voltando ao nosso exemplo das bicicletas. Quando elas são construídas, os fabricantes tiram
vantagem do fato que elas tem as mesmas características, e podem construir várias delas a partir
de uma mesma planta. Seria muito custoso fazer um novo projeto para cada bicicleta que eles
fossem construir.
6.1
Exercícios classes e subclasses
- Agrupe em classes os objetos abaixo:
avião elefante computador tigre calculadora motocicleta formiga Na orientação a objetos,
quando programamos, tentamos visualizar os objetos necessários para resolver um problema. Se
eu estou criando um programa de controle de estoque, eu vou necessitar de uma classe que
represente os itens que tenho nesse estoque. Outra classe que represente as ordens de compra. E
assim por diante.
Nota: A classe é um modelo ou protótipo, que define as variáveis e comportamentos em
comum que um certo tipo de objeto específico contém.
No nosso exemplo, depois de criada a classe bicicleta, nos é possível criar a partir dela
objetos que serão cópias idênticas da classe, mas cada uma delas terá seus próprios estados. O
modelo pode fornecer dados que serão compartilhados entre todos os objetos ou permitir que
estes tenham dados própiros.
Nota: Objetos “derivados” de uma classe são chamados instância de classe.
Para tornar o entendimento mais fácil, vamos ver um exemplo mais fácil e prático.
Inicialmente vamos pensar em um objeto bem simples, como uma lâmpada.
As lâmpadas podem ter diversos formatos, cores e tamanhos, mas basicamente elas tem
apenas uma função, que é iluminar o ambiente. Assim, imagine uma classe lâmpada.
Essa classe pressupõe apenas 2 estados. Um objeto derivado dessa classe pode estar
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
25
ligado ou desligado. Mas a lâmpada por si só não decide quando vai ligar ou desligar. Quem
liga ou desliga esse objeto lâmpada é um interruptor, acionado normalmente por uma pessoa.
Para resolver esse problema, teremos que definir um objeto baseado na classe lâmpada.
Teremos ainda um objeto da classe interruptor e outro da classe pessoa. Pessoa irá enviar
uma mensagem ao interruptor que por sua vez irá enviar uma mensagem para a lâmpada.
Uma coisa interessante é que não interessa para a pessoa que está ligando a lâmpada
como o interruptor funciona: importa que quando pressionado, a lâmpada acenda. Esta é uma das
grandes vantagens de se utilizar o conceito de objetos em informática. Um objeto é como uma
caixa preta: não me importa como ele faz as coisas, apenas o que tenho que fazer para que as
coisas aconteçam.
Ou seja, a classe é o construtor de objetos, eu defino o objeto como sendo o ente físico
que possui todas as propriedades da classe a qual pertence.
Voltando ao exemplo da lâmpada, em Java eu poderia definir uma lâmpada assim:
lampada sala_de_aula = new lampada();
Se eu quiser ligar a lâmpada, é só informar a ela o meu desejo, através de uma
mensagem:
sala_de_aula.ligar();
E a lâmpada vai acender. Não me importa como ela fez isso, me importa apenas que ela
faça
Exemplo 2
Construa um código java que leia duas notas, calcule a média e apresente o resultado.
Double.parseDouble é um metodo que transforma String em double.
import javax.swing.JOptionPane;//biblioteca javax.swing
public class EntradaDadosMedia{
public static void main(String[] args) {
double nota1,nota2,media;
nota1 = Double.parseDouble(JOptionPane.showInputDialog("Digite
nota1:"));
nota2 = Double.parseDouble(JOptionPane.showInputDialog("digite
nota2:"));
media = (nota1+nota2)/2;
JOptionPane.showMessageDialog(null, "media : " + media);
}
}
Classes instanciação
Não basta um objeto estar definido para ser utilizado. Se eu pretendo usar um objeto, eu
preciso cria-lo, e atribuir o controle desse objeto a um nome. A criação de objetos em Java é
sempre necessária, e é chamada de instanciação (por isso o objeto é chamado de instância).
Quando eu crio o objeto sala_de_aula, eu digo que ele é do tipo lâmpada e que eu quero
que ele seja instanciado nesse momento (new lampada()). A partir de agora, sala_de_aula é um
objeto do tipo definido e tem como funções tudo que uma lâmpada pode fazer.
Instituto Paula Sousa –
5.5
Orientação a objetos com java
Celio Assunção
26
Classes, Atributos e Métodos
Uma das grandes vantagens do Java e nosso propósito de estudo é a capacidade de você
definir seus próprios objetos. Como já comentado, um objeto contém atributos (dados) e métodos
(funções para manipulação dos dados). Esses objetos irão ajudá-lo a resolver o problema
apresentado e tornarão seu trabalho mais fácil.
Vamos inicialmente criar um objeto simples, que contenha apenas dados.
class meuObjeto
{
String nome;
int idade;
String telefone;
}
Você acabou de definir um objeto chamado meuObjeto. Temos nome, idade e telefone
como dados deste objeto.
Mas não basta defini-lo para que ele nos seja útil. Para isso, você deve instanciá-lo,assim:
meuObjeto amigo = new meuObjeto();
A partir de agora, meu objeto amigo pode ser utilizado para guardar dados. Eu posso
incluir dados assim:
amigo.nome = "Joao";
amigo.idade = 33;
amigo.telefone = "2223311";
E quando eu precisar dos valores, eu simplesmente os imprimo.
Nota: para facilitar nosso aprendizado, o comando para imprimir um dado é System.out.println,
e pode ser utilizado assim:
System.out.println (amigo.nome) ou usando JOptionPane
Vamos agora criar um método para o meuObjeto. Esse método vai se chamar aniversario, e ele
serve para aumentar em 1 ano a idade do objeto. Então, meu objeto ficaria:
class meuObjeto
{
String nome;
int idade;
String telefone;
public void aniversario()
{
idade = idade + 1;
}
}
Agora, para um teste, poderíamos fazer:
meuObjeto amigo = new meuObjeto();
amigo.nome = "Joao";
amigo.idade = 33;
amigo.telefone = "2223311";
System.out.println ("Idade antiga"+amigo.idade);
amigo.aniversario();
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
27
System.out.println ("Nova idade"+amigo.idade);
Percebam que o valor da idade foi alterado.
5.6.
Objetos são acessados por referências
Quando declaramos uma variável para associar a um objeto, na verdade, essa variável não
guarda o objeto, e sim uma maneira de acessá-lo, chamada de referência.
É por esse motivo que, diferente dos tipos primitivos como int e long, precisamos dar
new depois de declarada a variável:
1 public static void main(String args[]) {
2
Conta c1;
3
c1 = new Conta();
4
5
Conta c2;
6
c2 = new Conta();
7}
O correto aqui, é dizer que c1 se refere a um objeto. Não é correto dizer que c1 é um
objeto, pois c1 é uma variável referência, apesar de, depois de um tempo, os programadores Java
falarem “Tenho um objeto c do tipo Conta”, mas apenas para encurtar a frase “Tenho uma
referência c a um objeto do tipo Conta”.
Basta lembrar que, em Java, uma variável nunca é um objeto. Não há, no Java, uma
maneira de criarmos o que é conhecido como “objeto pilha” ou “objeto local”, pois todo objeto
em Java, sem exceção, é acessado por uma variável referência.
Esse código nos deixa na seguinte situação:
Conta c1;
c1 = new Conta();
Conta c2;
c2 = new Conta();
Conta
Conta
Memória
c1
c2
Internamente, c1 e c2 vão guardar um número que identifica em que posição da memória
aquela Conta se encontra. Dessa maneira, ao utilizarmos o “.” para navegar, o Java vai acessar a
Conta que se encontra naquela posição de memória, e não uma outra.
Para quem conhece, é parecido com um ponteiro, porém você não pode manipulá-lo
como um número e nem utilizá-lo para aritmética, ela é tipada.Um outro exemplo:
1 class TestaReferencias {
2
public static void main(String args[]) {
3
Conta c1 = new Conta();
4
c1.deposita(100);
5
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
28
6
Conta c2 = c1; // linha importante!
7
c2.deposita(200);
8
9
System.out.println(c1.saldo);
10
System.out.println(c2.saldo);
11
}
12 }
Qual é o resultado do código acima? O que aparece ao rodar?
O que acontece aqui? O operador = copia o valor de uma variável. Mas qual é o valor da
variável c1? É o objeto? Não. Na verdade, o valor guardado é a referência (endereço) de onde o
objeto se encontra na memória principal.
Na memória, o que acontece nesse caso:
Conta c1 = new Conta();
Conta c2 = c1;
Conta
Memória
c1
c2
Quando fizemos c2 = c1, c2 passa a fazer referência para o mesmo objeto que c1
referencia nesse instante.
Então, nesse código em específico, quando utilizamos c1 ou c2 estamos nos referindo
exatamente ao mesmo objeto! Elas são duas referências distintas, porém apontam para o mesmo
objeto! Compará-las com “==” irá nos retornar true, pois o valor que elas carregam é o mesmo!
Outra forma de perceber, é que demos apenas um new, então só pode haver um objeto
Conta na memória.
Atenção: não estamos discutindo aqui a utilidade de fazer uma referência apontar pro mesmo
objeto que outra. Essa utilidade ficará mais clara quando passarmos variáveis do tipo referência
como argumento para métodos.
new
O que exatamente faz o new?
O new executa uma série de tarefas, que veremos mais adiante.
Mas, para melhor entender as referências no Java, saiba que o new, depois de alocar a
memória para esse objeto, devolve uma “flecha”, isto é, um valor de referência. Quando você
atribui isso a uma variável, essa variável passa a se referir para esse mesmo objeto.
Podemos então ver outra situação:
1
2
3
4
5
6
7
8
9
public static void main(String args[]) {
Conta c1 = new Conta();
c1.dono = "Duke";
c1.saldo = 227;
Conta c2 = new Conta();
c2.dono = "Duke";
c2.saldo = 227;
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
29
10
if (c1 == c2) {
11
System.out.println("Contas iguais");
12
}
13 }
O operador == compara o conteúdo das variáveis, mas essas variáveis não guardam o
objeto, e sim o endereço em que ele se encontra. Como em cada uma dessas variáveis guardamos
duas contas criadas diferentemente, eles estão em espaços diferentes da memória, o que faz o
teste no if valer false. As contas podem ser equivalentes no nosso critério de igualdade, porém
elas não são o mesmo objeto. Quando se trata de objetos, pode ficar mais fácil pensar que o ==
compara se os objetos (referências, na verdade) são o mesmo, e não se são iguais.
dono Celio
saldo 12000
limite 20000
c1
c2
dono
Celio
saldo 12000
limite 20000
Para saber se dois objetos têm o mesmo conteúdo, você precisa comparar atributo por
atributo. Veremos uma solução mais elegante para isso também
5.7 O Método transfere()
E se quisermos ter um método que transfere dinheiro entre duas contas? Podemos ficar tentados
a criar um método que recebe dois parâmetros: conta1 e conta2 do tipo Conta. Mas cuidado:
assim estamos pensando de maneira procedural.
A ideia é que, quando chamarmos o método transfere, já teremos um objeto do tipo Conta (o
this), portanto o método recebe apenas um parâmetro do tipo Conta, a Conta destino (além do
valor):
class Conta {
// atributos e metodos...
void transfere(Conta destino, double valor) {
this.saldo = this.saldo - valor;
destino.saldo = destino.saldo + valor;
}
Conta
+ numero : int
+ saldo: double
+ limite: double
+ nome: String
+ saca (valor : double) :boolean
+ deposita (valor double)
+ transfere (destino : Conta, valor:
double
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
30
}
Para deixar o código mais robusto, poderíamos verificar se a conta possui a quantidade a ser
transferida disponível. Para ficar ainda mais interessante, você pode chamar os métodos deposita
e saca já existentes para fazer essa tarefa:
class Conta {
// atributos e metodos...
boolean transfere(Conta destino, double valor) {
boolean retirou = this.saca(valor);
if (retirou == false) {
// não deu pra sacar!
return false;
}
else {
destino.deposita(valor);
return true;
}
}
}
Conta
+ numero : int
+ saldo: double
+ limite: double
+ nome: String
+ saca (valor : double) :boolean
+ deposita (valor double)
+ transfere (destino : Conta, valor:
double): boolean
Quando passamos uma Conta como argumento, o que será que acontece na memória?
Será que o objeto é clonado?
No Java, a passagem de parâmetro funciona como uma simples atribuição como no uso
do “=”. Então, esse parâmetro vai copiar o valor da variável do tipo Conta que for passado como
argumento. E qual é o valor de uma variável dessas? Seu valor é um endereço, uma referência,
nunca um objeto. Por isso não há cópia de objetos aqui.
Esse último código poderia ser escrito com uma sintaxe muito mais sucinta. Como?
Vamos lá façam esse exercício, tá bom?
5.8 Transfere Para
Perceba que o nome deste método poderia ser transferePara ao invés de só transfere. A
chamada do método fica muito mais natural, é possível ler a frase em português que ela tem um
sentido:
conta1.transferePara(conta2, 50);
A leitura deste código seria “Conta1 transferePara Conta2 50 reais”.
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
31
5.9. Para saber mais: Uma Fábrica de Carros
Além do Banco que estamos criando, vamos ver como ficariam certas classes
relacionadas a uma fábrica de carros. Vamos criar uma classe Carro, com certos atributos, que
descrevem suas características, e com certos métodos, que descrevem seu comportamento.
1 class Carro {
2
String cor;
3
String modelo;
4
double velocidadeAtual;
5
double velocidadeMaxima;
6
7
//liga o carro
8
void liga() {
9
System.out.println("O carro está ligado");
10
}
11
12
//acelera uma certa quantidade
13
void acelera(double quantidade) {
14
double velocidadeNova = this.velocidadeAtual + quantidade;
15
this.velocidadeAtual = velocidadeNova;
16
}
17
18
//devolve a marcha do carro
19
int pegaMarcha() {
20
if (this.velocidadeAtual < 0) {
21
return -1;
22
}
23
if (this.velocidadeAtual >= 0 && this.velocidadeAtual < 40) {
24
return 1;
25
}
26
if (this.velocidadeAtual >= 40 && this.velocidadeAtual < 80 {
27
return 2;
28
}
29
return 3;
30
}
31 }
Vamos testar nosso Carro em um novo programa:
1 class TestaCarro {
2
public static void main(String[] args) {
3
Carro meuCarro;
4
meuCarro = new Carro();
5
meuCarro.cor = "Verde";
6
meuCarro.modelo = "Fusca";
7
meuCarro.velocidadeAtual = 0;
8
meuCarro.velocidadeMaxima = 80;
9
10
// liga o carro
11
meuCarro.liga();
12
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
32
13
// acelera o carro
14
meuCarro.acelera(20);
15
System.out.println(meuCarro.velocidadeAtual);
16
}
17 }
Nosso carro pode conter também um Motor:
1 class Motor {
2
int potencia;
3
String tipo;
4}
1 class Carro {
2
String cor;
3
String modelo;
4
double velocidadeAtual;
5
double velocidadeMaxima;
6
Motor motor;
7
8
// ..
9}
5.10 - Exercícios: Orientação a Objetos
O modelo de funcionários a seguir será utilizado para os exercícios de alguns dos
posteriores capítulos.
O objetivo aqui é criar um sistema para gerenciar os funcionários do Banco.
Os exercícios desse capítulo são extremamente importantes.
1) Modele um funcionário. Ele deve ter o nome do funcionário, o departamento onde trabalha,
seu salário (double), a data de entrada no banco (String), seu RG (String) e um valor booleano
que indique se o funcionário ainda está ativo na empresa ou se já foi mandado embora.
Você deve criar alguns métodos de acordo com sua necessidade. Além deles, crie um
método bonifica que aumenta o salario do funcionário de acordo com o parâmetro passado como
argumento. Crie, também, um método demite, que não recebe parâmetro algum, só modifica o
valor booleano indicando que o funcionário não trabalha mais aqui.
A idéia aqui é apenas modelar, isto é, só identifique que informações são importantes e o
que um funcionário faz. Desenhe no papel tudo o que um Funcionario tem e tudo que ele faz.
2) Transforme o modelo acima em uma classe Java. Teste-a, usando uma outra classe que tenha o
main. Você deve criar a classe do funcionário chamada Funcionario, e a classe de teste você pode
nomear como quiser.
A de teste deve possuir o método main.
Um esboço da classe:
class Funcionario {
double salario;
// seus outros atributos e métodos
void bonifica(double aumento) {
// o que fazer aqui dentro?
}
void demite() {
// o que fazer aqui dentro?
}
}
Você pode (e deve) compilar seu arquivo java sem que você ainda tenha terminado sua
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
33
classe Funcionario.
Isso evitará que você receba dezenas de erros de compilação de uma vez só. Crie a classe
Funcionario,
coloque seus atributos e, antes de colocar qualquer método, compile o arquivo java.
Funcionario.class será gerado, não podemos “executá-la” pois não há um main, mas assim
verificamos que nossa classe Funcionário já está tomando forma.
Funcionario
+ nome : String
+ departamento : String
+ salario : double
+ dataEntrada : String
+ rg : String
+ cpf : String
+ bonifica(aumento double)
+ demite( )
Esse é um processo incremental. Procure desenvolver assim seus exercícios, para não
descobrir só no fim do caminho que algo estava muito errado.
Um esboço da classe que possui o main:
1
class TestaFuncionario {
2
3
public static void main(String[] args) {
4
Funcionario f1 = new Funcionario();
5
6
f1.nome = "Gesebelo Silva";
7
f1.salario = 100;
8
f1.bonifica(50);
9
10
System.out.println("salario atual:" + f1.salario);
11
12
}
13
}
Incremente essa classe. Faça outros testes, imprima outros atributos e invoque os métodos
que você criou a mais, tá bom?.
Lembre-se de seguir a convenção java, isso é importantíssimo. Isto é, nomeDeAtributo,
nomeDeMetodo, nomeDeVariavel, NomeDeClasse, etc...
Todas as classes no mesmo arquivo?
Por enquanto, você pode colocar todas as classes no mesmo arquivo e apenas compilar
esse arquivo. Ele vai gerar os dois .class.
Porém, é boa prática criar um arquivo .java para cada classe e, em determinados casos,
você será obrigado a declarar uma classe em um arquivo separado, como veremos no
parte 2. Isto não é importante para o aprendizado no momento.
5.11 Exercício de fixação
Digitem o exemplo acima e façam o mesmo funcionar.
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
34
Nota: o esquema geral para a definição de um método é
tipo_do_dados_de_retorno nome_do_metodo (argumentos)
{
corpo_do_metodo
}
No caso do método aniversario definido acima, não temos nenhum tipo de retorno, por
isso ele é do tipo void.
Se precisarmos algum resultado de retorno, temos que indicar qual o tipo desse resultado.
Vamos definir outro método, que me retorna o numero de meses baseado na idade. O
método poderia ser definido assim:
int idadeEmMeses()
{
return (idade * 12);
}
A instrução return vai indicar qual o valor a ser retornado na chamada do método. Como
temos um retorno, ele dever ser utilizado ou apresentado. Podemos apresentá-lo assim:
System.out.println (amigo.idadeEmMeses());
Nota: Se o valor for utilizado para outros fins, devemos definir uma variável do mesmo
tipo do retorno para conter o resultado:
int idade_em_meses = amigo.idadeEmMeses();
Às vezes, necessitamos do envio de argumentos (também chamados parâmetros) para um
método para que ele possa executar seu trabalho. A passagem de parâmetro é feita na hora da
chamada, e temos que criar o método já levando em consideração a quantidade de parâmetros
que iremos passar.
Assim, caso eu queira alterar ao atributo idade do objeto, eu poderia criar um método
assim:
void alteraIdade(int nova_idade)
{
idade = nova_idade;
}
E a chamada ao método ficaria:
amigo.alteraIdade(30);
- Implemente o exemplo acima.
Nota: Caso eu tenha mais de um argumento, eles devem ser separados por virgulas.
Nota2: Na definição do método com mais de um argumento, eu tenho que prever as variáveis a
serem recebidas.
Exemplo:
void qualquerCoisa (String nome, int idade, String telefone)
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
A chamada é amigo.qualquerCoisa ("paulo", 24, "2221133");
Exemplo 2
escreva métodos para a classe EntradaDadosMedia
import javax.swing.JOptionPane;
public class MetodosSimples
{
static double nota1,nota2,media;
public static void main(String[] args)
{
LerNotas();
CalculaMedia();
Mensagem();
}
public static void LerNotas(){
nota1 = Double.parseDouble(JOptionPane.showInputDialog("Digite
nota1:"));
nota2 = Double.parseDouble(JOptionPane.showInputDialog("digite
nota2:"));
}
public static void CalculaMedia(){
media = (nota1+nota2)/2;
}
public static void Mensagem(){
JOptionPane.showMessageDialog(null, "media : " + media);
}
}
35
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
36
6.1
Construção De Programas Em Java
Vocês podem estar se perguntando qual a finalidade de criar métodos para alterar valores
dentro de um objeto. Nesses exemplos fica fácil perceber que é muito mais fácil fazer uma
atribuição simples (amigo.idade=34) do que criar um método só para alterar a idade. Mas isso
tem sentido de ser, em linguagens orientadas a objetos.
A idéia é que o objeto deve gerenciar seus próprios dados, que só devem ser acessíveis ao
"mundo exterior" através de seus métodos (excetuando-se aqui os métodos e variáveis estáticas).
Então, pelo menos em teoria, cada atributo do meu objeto deve ter um método para
gravar dados e outro para devolver o dado gravado. Isso vai permitir que esse objeto seja
utilizado por qualquer um, a qualquer tempo.
Vamos passar então um pequeno código de um programa completo em Java para que
possamos ir comentando e esclarecendo.
import java.util.*;
public class Propriedades
{
public static void main (String[] args)
{
System.out.println ("Bom dia... Hoje é dia\n");
System.out.println ("Bom dia... Hoje é dia\n");
System.out.println(new Date());
}
}
Logo na primeira linha temos "import...". É normal nas primeiras linhas de um programa
em Java a colocação da instrução import. Essa instrução serve para que nosso programa possa
utilizar qualquer classe externa que ele necessite. No caso, meu programa usa uma função que
retorna a data do sistema, e essa função faz parte de java.util. Assim, eu preciso importar essas
funções para que meu programa funcione. Isso será explicado melhor quando falarmos a respeito
de API's.
Na segunda linha, definimos o nome desse objeto (em Java, chamado de classe). É
importante notar que o objeto deve ter o mesmo nome do arquivo no disco, caso contrário o
programa não irá funcionar.
Notamos ainda nessa mesma linha que essa classe é do tipo publica (public). Isso quer
dizer que esse objeto é acessível por outros objetos, que ele pode ser importado e usado.
Na próxima linha, temos a definição do método main. Vemos novamente o public, e a
palavra static, indicando que esse método não pode ser instanciado, apenas usado do jeito que
esta. Vemos que o método main admite uma lista de Strings como argumentos (chamado de
args). Esses argumentos não são necessários nesse programa, mas caso necessitássemos de
passar algum tipo de informação para o programa, essas informações estariam armazenadas na
variável args.
Na próxima linha, temos a impressão de umtexto na tela. Aúnica novidade é a presença
de um sinal \n no final do texto. Ele indica ao Java para pular de linha depois de escrever o texto
indicado.
Na ultima linha temos outra impressão. Dessa vez, temos a instanciação de um objeto do
tipo Date, e seu valor é imediatamente impresso. Como não necessitamos do objeto, apenas
queremos um valor impresso, não é necessário criar uma variável apenas para isso. Note que
nem sempre isso é possível.
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
37
6.2
Métodos Construtores e Overloading
Como já apresentado, é sempre necessário instanciar um objeto para poder utilizá-lo.
Existe um método especial em uma classe que fornece instruções a respeito de como
devemos instanciar o objeto. Esse método é chamado de construtor.
A função do construtor é garantir que o objeto associado à variável definida será inciada
corretamente. Sempre é necessário ter um construtor, e como na maioria das vezes esse
construtor não faz nada (além de instanciar o objeto), não é necessário declará-lo. O Java faz isso
automaticamente para nos.
Nota: O método construtor tem exatamente o mesmo nome da classe. Assim, no exemplo:
class meuObjeto
{
String nome;
int idade;
String telefone;
public void aniversario()
{
idade = idade + 1;
}
}
Não temos construtor definido.
Mas existem casos onde teremos necessidade de um construtor que faz algo, como na
definição de String. Eu posso definir uma String assim:
String nome = new String();
Ou assim:
Stirng nome = new String ("Joao");
Isso quer dizer que o objeto String tem pelo menos 2 construtores; um que inicia o objeto
sem argumentos e outro que inicia com argumentos. Esse tipo de artificio é chamado de
sobrecarga (em inglês, Overloading).
Se eu quiser que meuObjeto tenha o mesmo tipo de funcionalidade do String, eu defino
dois construtores, assim:
class meuObjeto
{
String nome;
int idade;
String telefone;
meuObjeto() // Esse é o construtor sem argumentos
{
}
meuObjeto(String _nome, int _idade, String _telefone) // Construtor com
argumentos
{
nome = _nome;
idade = _idade;
telefone = _telefone;
}
public void aniversario()
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
38
{
idade = idade + 1;
}
}
Agora meuObjeto pode ser instanciado como
meuObjeto amigo = new meuObjeto();
ou
meuObjeto amigo = new meuObjeto("Joao", 32, "2223311");
A sobrecarga é um dos recursos mais interessantes da orientação a objetos. E não esta
restrito aos construtores; podermos definir o mesmo nome de método para qualquer método.
Assim, tornamos o programa mais legível e temos menos nomes para "inventar".
Nota: Como os dois (ou mais) métodos tem o mesmo nome, a diferenciação de qual método é
executado depende da quantidade e do tipo dos argumentos enviados.
Nota2: Quando não definimos construtores, o Java cria um sem argumentos para nos. Quando eu
escolho definir o construtor, tenho que definir para todos os tipos, inclusive o sem argumentos.
Para entender melhor o conceito de sobrecarga vamos fazer alguns exercícios.
import javax.swing.JOptionPane;
public class MetodosSimples
{
static double nota1,nota2,media;
public static void main(String[] args)
{
LerNotas();
CalculaMedia();
Mensagem();
}
public static void LerNotas(){
nota1 = Double.parseDouble(JOptionPane.showInputDialog("Digite
nota1:"));
nota2 = Double.parseDouble(JOptionPane.showInputDialog("digite
nota2:"));
}
public static void CalculaMedia(){
media = (nota1+nota2)/2;
}
public static void Mensagem(){
JOptionPane.showMessageDialog(null, "media : " + media);
}
}
Na classe MetodosSimples use uma estrutura de repetição para que o programa seja
executado mais de uma vez.
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
39
import javax.swing.JOptionPane;
public class MetodosSimples2
{
static double nota1,nota2,media;
public static void main(String[] args)
{
for (int i = 0;i<3;i++){
LerNotas();
CalculaMedia(nota1,nota2);
Mensagem(media);
}
}
public static void LerNotas(){
nota1 = Double.parseDouble(JOptionPane.showInputDialog("Digite
nota1:"));
nota2 = Double.parseDouble(JOptionPane.showInputDialog("digite
nota2:"));
}
public static void CalculaMedia(double nt1,double nt2){
media = (nt1+nt2)/2;
}
public static void Mensagem(double CalculoMedia){
JOptionPane.showMessageDialog(null, "media : " + CalculoMedia);
}
}
observe que neste caso o programa será executado tantas vezes quantas eu queira.
6.3
Utilização das API’s
Como já falado, existem muitos objetos prontos que a linguagem Java nos proporciona.
Como todos os objetos, eles podem conter dados e tem vários métodos para que
possamos usa-los.
É importante para um programador Java conhecer o máximo desses objetos que puder;
eles facilitam o trabalho na medida que evitam que nos tenhamos o trabalho de inventar algo que
já está pronto. Lembre que normalmente nós não temos acesso aos atributos dessa classe; apenas
a seus métodos.
Quando executamos um import ... no inicio do nosso programa, estamos informando ao
compilador Java quais as classes que desejamos usar.
Assim, um import java.util.*; quer dizer: "eu vou utilizar alguns objetos do pacote
java.util". Um programa pode ter tantos import quanto necessário.
Isso permite que você utilize componentes de pacotes baixados da Internet, com
utilização mais restrita.
Nota: Uma lista completa das API's existentes pode ser achada na lista de links no final do
documento.
6.4
Utilizando gestores de erro
O java tem a facilidade de excluir erros comuns gerados por imperícia dos usuários, uma das
formas é o try catch. Veja no exemplo a seguir.
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
6.5
Entrada dados com GET
import javax.swing.JOptionPane;
import java.io.*;;
public class EntradaDadosComGet {
public static void main(String[] args) {
double nota1=0,nota2=0,media=0;
BufferedReader dadoEntrada;
String notaDigitada;
try{// trecho principal sem erros
System.out.println("digite n1");
dadoEntrada = new BufferedReader(new
InputStreamReader(System.in));
notaDigitada = dadoEntrada.readLine();
nota1 = Double.parseDouble(notaDigitada);
System.out.println("digite n2");
dadoEntrada = new BufferedReader(new
InputStreamReader(System.in));
notaDigitada = dadoEntrada.readLine();
nota2 = Double.parseDouble(notaDigitada);
media = (nota1+nota2)/2;
System.out.println("a media é"+media);
}
catch(IOException erroIO){
System.out.println("erro entrada de dados "+erroIO);
}
catch(NumberFormatException erroNumber){
//caso digite numero invalido
System.out.println("digite caracter valido
"+erroNumber.getMessage());
System.out.println("digite caracter valido
"+erroNumber.getStackTrace());
}
//o que estiver no finally [e rodado mesmo com o catch, n'ao cai fora
finally{
JOptionPane.showMessageDialog(null,"fim da aplicação Media sem
tratamento");
}
}
}
40
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
41
6.6
Conceito De Pacote
Um pacote pode ser entendido como uma serie de objetos agrupados por afinidade. Eles
ficam "juntos" pois tem funções semelhantes (como por exemplo manipular texto).
Quando nós vamos criar nossos próprios objetos para resolver um problema,
normalmente esses objetos ficam todos no mesmo sub-diretorio; entre eles estabelecemos uma
relação de "amizade", e podemos considera-los como parte do mesmo pacote (default). Estando
no mesmo sub-diretorio, certas restrições de acesso entre esses objetos mudam. Explicamos
restrição de acesso no tópico a seguir.
6.7
Tipos De Métodos: Públicos, Privados E Protegidos
As restrições de acesso em Java existem por dois motivos. O primeiro é não permitir que
o programador utilize meus objetos da maneira que quiser. Eu dito o que pode e o que não pode
ser utilizado. E o segundo motivo é que tudo que não for publico (e consequentemente não
permite acesso) pode ser alterado na hora que eu quiser. Contanto que os métodos de acesso (que
são públicos) fiquem inalterados, ninguém vai perceber a diferença.
Como exemplo, vejamos o objeto String. O String na verdade é um vetor de caracteres.
Eu não tenho permissão para acessar os conteúdos internos desses caracteres; eu tenho
que fazer isso utilizando um método. Assim, existem situações onde é interessante que meus
objetos tenham um certo controle sobre o que o programador pode fazer com eles, para que não
ocorram problemas. Para isso, temos três tipos de acesso a métodos e atributos.
Quando utilizamos a palavra public, liberamos o acesso do atributo/método para ser
utilizado por qualquer um que importe o pacote ou o objeto.
No caso do private, ninguém pode acessar o método/atributo daquele objeto, nem mesmo
os objetos daquele pacote ou objetos que herdam suas características. Isso evita que certos
métodos sejam acessados diretamente, evitando erros.
Métodos/atributos protected podem ser herdados, mas não alterados. Iremos comentar a
respeito de herança mais à frente.
Exemplo:
class exemplo
{
public metodo1() { ... }
private metodo2() { ... }
}
Nessa classe, o metodo1 pode ser executado por qualquer outro objeto. O método
metodo2 só pode ser executado pelo próprio objeto.Primeiramente criaremos um método simples
como exemplo, calcular uma soma simples
6.8
Exercícios de fixação
Construa uma classe CalculaSoma implemente vários métodos e chame de outra classe chamada
ChamaMetodosDeOutraClasse
Este exercício possibilita chamar um método em outra classe. Primeiramente criaremos um
método simples como exemplo, calcular uma soma simples.
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
42
6.9
Chamando método de outra classe
public class CalculaSoma
{
static double soma=0, valor1=0,valor2=0;
public static void somar()
{
soma = valor1+valor2;
}
}
Uma classe chama método de outra classe que vai utilizar o método criado na primeira classe,
veja que utilizamos o static para ser usado em todo procedimento.
import javax.swing.JOptionPane;
public class MetodoOutraClasseSemParametro {
public static void main(String[] args) {
CalculaSoma.valor1 = 12;
CalculaSoma.valor2 = 15;
CalculaSoma.somar();
JOptionPane.showMessageDialog(null, "a soma é "+CalculaSoma.soma);
}
}
6.10
Passando valores por parâmetro
Agora vamos fazer outro método passando por parâmetro os dois valores
import javax.swing.JOptionPane;
public class MetodoOutraClasseSemParametro {
public static void main(String[] args) {
CalculaSoma.valor1 = 12;
CalculaSoma.valor2 = 15;
CalculaSoma.somar();
JOptionPane.showMessageDialog(null, "a soma é
"+CalculaSoma.soma);
CalculaSoma.somar(8,55);
JOptionPane.showMessageDialog(null, "a soma
com parametro é "+CalculaSoma.soma);
}
}
6.11
Função retorna valores
Posso agora fazer o método retornar um valor, vou ter uma função que vai retornar um double,
neste caso posso deixar de executar
public class CalculaSoma
{
static double soma=0, valor1=0,valor2=0;
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
43
public static void somar()
{
soma = valor1+valor2;
}
public static void somar(double vl1,double vl2)
{
soma = vl1+vl2;
}
public static double retornaSoma(double vl1,double vl2)
{
return vl1+vl2;
}
}
import javax.swing.JOptionPane;
public class ChamaMetodoDeOutraClasseComRetorno {
public static void main(String[] args)
{
CalculaSoma.valor1=Double.parseDouble(JOptionPane.showInputDialog("digite
parcela 1"));
CalculaSoma.valor2=Double.parseDouble(JOptionPane.showInputDialog("digite
parcela 2"));
CalculaSoma.somar();
JOptionPane.showMessageDialog(null, "A soma é:
"+CalculaSoma.soma);
CalculaSoma.somar(3,2);
JOptionPane.showMessageDialog(null, "A soma com parametro é:
"+CalculaSoma.soma);
JOptionPane.showMessageDialog(null, "A soma com retorno do metodo
é: "+CalculaSoma.retornaSoma(12,33));
}
}
veja como em um único exemplo eu posso usar diversos métodos, muito facil, né?
6.12
Usando o conceito de pacote
Agora vamos abrir um pacote (package) para organizar melhor meu diretório
package MetodosClass;
import javax.swing.JOptionPane;
public class ChamaMetodoDeOutraClasse {
public static void main(String[] args)
{
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
44
CalculaSoma.valor1=Double.parseDouble(JOptionPane.showInputDialog("digite
parcela 1"));
CalculaSoma.valor2=Double.parseDouble(JOptionPane.showInputDialog("digite
parcela 2"));
CalculaSoma.somar();
JOptionPane.showMessageDialog(null, "A soma é:
"+CalculaSoma.soma);
CalculaSoma.somar(3,2);
JOptionPane.showMessageDialog(null, "A soma com parametro é:
"+CalculaSoma.soma);
//JOptionPane.showMessageDialog(null, "A soma com retorno do metodo
é: "+CalculaSoma.retornaSoma(12,33));
}
}
vai dar um erro pois o CalculaSoma não esta no pacote devo mudar
package MetodosClass;
public class CalculaSoma
{
static double soma=0, valor1=0,valor2=0;
public static void somar()
{
soma = valor1+valor2;
}
public static void somar(double vl1,double vl2)
{
soma = vl1+vl2;
}
}
6.13
DESAFIO
1) Um método pode chamar ele mesmo. Chamamos isso de recursão. Você pode resolver
a série de fibonacci usando um método que chama ele mesmo. O objetivo é você criar uma
classe, que possa ser usada da seguinte maneira:
Fibonacci fibo = new Fibonacci();
int i = fibo.calculaFibonacci(6);
System.out.println(i);
Aqui imprimirá 8, já que este é o sexto número da série.
Este método calculaFibonacci não pode ter nenhum laço, só pode chamar ele mesmo
como método.
Pense nele como uma função, que usa a própria função para calcular o
resultado.
2) Por que o modo acima é extremamente mais lento para calcular a série do que o modo
iterativo (que se usa um laço)?
3) Escreva o método recursivo novamente, usando apenas uma linha. Para isso, pesquise
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
45
sobre o operador condicional ternário. (ternary operator)
6.14
Fixando o conhecimento
O objetivo dos exercícios a seguir é fixar o conceito de classes e objetos, métodos e
atributos. Dada a
estrutura de uma classe, basta traduzí-la para a linguagem Java e fazer uso de um objeto da
mesma em um programa simples.
Se você está com dificuldade em alguma parte desse capítulo, aproveite e treine tudo o que
vimos nos
pequenos programas abaixo:
1) Programa 1
Classe: Pessoa Atributos: nome, idade. Método: void fazAniversario()
Crie uma pessoa, coloque seu nome e idade iniciais, faça alguns aniversários
(aumentando a idade) e
imprima seu nome e sua idade.
2) Programa 2
Classe: Porta Atributos: aberta, cor, dimensaoX, dimensaoY, dimensaoZ Métodos: void
abre(), void fecha(), void pinta(String s), boolean estaAberta()
Crie uma porta, abra e feche a mesma, pinte-a de diversas cores, altere suas dimensões e
use o método
estaAberta para verificar se ela está aberta.
3) Programa 3
Classe: Casa Atributos: cor, porta1, porta2, porta3 Método: void pinta(String s), int
quantasPortasEstaoAbertas()
Crie uma casa e pinte-a. Crie três portas e coloque-as na casa; abra e feche as mesmas
como desejar.
Utilize o método quantasPortasEstaoAbertas para imprimir o número de portas abertas.
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
46
7.1 PROGRAMAÇÃO ORIENTADA A OBJETOS
Agora vamos criar um novo folder POO (new folder POO) onde iremos instanciar
novos objetos e um new folder POO_class onde ficarão os arquivos .class.
7.2 Criando nova classe para Vendas
iniciamos colocando a classe dentro do pacote, a classe venda deve ter o cliente, o produto e o
valor pago
package POO;
public class Vendas {
String cliente,produto;
double valor;
}
Vamos criar a classe VendaEfetuada que deve ter o main, posso criar um objeto para
manipular os atributos criados
package POO;
public class vendaEfetuada {
public static void main(String[] args) {
Vendas objVendas;
objVendas = new Vendas();
}
}
Pronto o objeto foi criado e instanciado para ser usado
Agora posso manipular as três variáveis
package POO;
public class VendaEfetuada {
public static void main(String[] args) {
Vendas objVendas;
objVendas = new Vendas();
objVendas.cliente = "Celio Assunção";
objVendas.produto = "Placa de video";
objVendas.valor = 1600;
//Vamos gerar um relatório
javax.swing.JOptionPane.showMessageDialog(null, "Comprador" +
objVendas.cliente+
"\nproduto "+ objVendas.produto+
"\nvalor "+ objVendas.valor);
}
}
Poderia ter importado o javax.swing mas funciona do mesmo jeito
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
47
7.3 Exercício de fixação
repita o procedimento para mais de um cliente/produto.
Vou repetir o procedimento para outra venda efetuada
package POO;
public class VendaEfetuada1 {
public static void main(String[] args) {
Vendas1 objVendas1;
objVendas1 = new Vendas1();
objVendas1.cliente = "Maneu Rocha";
objVendas1.produto = "Placa de som";
objVendas1.valor = 800;
javax.swing.JOptionPane.showMessageDialog(null, "Comprador
"+objVendas1.cliente+
"\nproduto "+objVendas1.produto+
"\nvalor
"+ objVendas1.valor);
}
}
devo mudar minha classe construtora de objeto
package POO;
public class Vendas1 {
String cliente,produto;
double valor;
}
como se pode ver não é um procedimento recomendável, vamos ver se podemos melhorar isto
7.4 Modificadores de acesso
Modificadores de acesso e atributos de classe Controlando o acesso
Um dos problemas mais simples que temos no nosso sistema de contas é que o método saca
permite sacar mesmo que o limite tenha sido atingido. A seguir você pode lembrar como está a
classe Conta:
class Conta {
int numero;
Cliente titular;
double saldo;
double limite;
// ..
void saca(double quantidade) {
this.saldo = this.saldo - quantidade;
}
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
48
}
A classe a seguir mostra como é possível ultrapassar o limite usando o método saca:
class TestaContaEstouro1 {
public static void main(String args[]) {
Conta minhaConta = new Conta();
minhaConta.saldo = 1000.0;
minhaConta.limite = 1000.0;
minhaConta.saca(50000); // saldo + limite é só 2000!!
}
}
Podemos incluir um if dentro do nosso método saca() para evitar a situação que resultaria em
uma conta em estado inconsistente, com seu saldo abaixo do limite. Fizemos isso no capítulo de
orientação a objetos básica.
Apesar de melhorar bastante, ainda temos um problema mais grave: ninguém garante que
o usuário da classe vai sempre utilizar o método para alterar o saldo da conta. O código a seguir
ultrapassa o limite diretamente:
class TestaContaEstouro2 {
public static void main(String args[]) {
Conta minhaConta = new Conta();
minhaConta.limite = 100;
minhaConta.saldo = -200; //saldo está abaixo dos 100 de limite
}
}
Como evitar isso? Uma idéia simples seria testar se não estamos ultrapassando o limite
toda vez que formos alterar o saldo:
class TestaContaEstouro3 {
public static void main(String args[]) {
// a Conta
Conta minhaConta = new Conta();
minhaConta.limite = 100;
minhaConta.saldo = 100;
// quero mudar o saldo para -200
double novoSaldo = -200;
// testa se o novoSaldo ultrapassa o limite da conta
if (novoSaldo < -minhaConta.limite) { //
System.out.println("Não posso mudar para esse saldo");
} else {
minhaConta.saldo = novoSaldo;
}
}
}
Esse código iria se repetir ao longo de toda nossa aplicação e, pior, alguém pode esquecer
de fazer essa comparação em algum momento, deixando a conta na situação inconsistente. A
melhor forma de resolver isso seria forçar quem usa a classe Conta a invocar o método saca e
não permitir o acesso direto ao atributo. É o mesmo caso da validação de CPF.
Para fazer isso no Java, basta declarar que os atributos não podem ser acessados de fora
da classe através da palavra chave private:
class Conta {
private double saldo;
private double limite;
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
49
// ...
}
private é um modificador de acesso (também chamado de modificador de visibilidade).
Marcando um atributo como privado, fechamos o acesso ao mesmo em relação a todas as
outras classes, fazendo com que o seguinte código não compile:
class TestaAcessoDireto {
public static void main(String args[]) {
Conta minhaConta = new Conta();
//não compila! você não pode acessar o atributo privado de outra classe
minhaConta.saldo = 1000;
}
}
aparece este erro
Na orientação a objetos, é prática quase que obrigatória proteger seus atributos com
private. (discutiremos outros modificadores de acesso em outros capítulos).
Cada classe é responsável por controlar seus atributos, portanto ela deve julgar se aquele
novo valor é válido ou não! Esta validação não deve ser controlada por quem está usando a
classe e sim por ela mesma, centralizando essa responsabilidade e facilitando futuras mudanças
no sistema. Muitas outras vezes nem mesmo
queremos que outras classes saibam da existência de determinado atributo, escondendo-o por
completo, já que ele diz respeito ao funcionamento interno do objeto.
Repare que, quem invoca o método saca não faz a menor idéia de que existe um limite
que está sendo checado. Para quem for usar essa classe, basta saber o que o método faz e não
como exatamente ele o faz (o que um método faz é sempre mais importante do que como ele faz:
mudar a implementação é fácil, já mudar a assinatura de um método vai gerar problemas).
A palavra chave private também pode ser usada para modificar o acesso a um método. Tal
funcionalidade é utilizada em diversos cenários: quando existe um método que serve apenas para
auxiliar a própria classe e quando há código repetido dentro de dois métodos da classe são os
mais comuns. Sempre devemos expôr o mínimo possível de funcionalidades, para criar um baixo
acoplamento entre as nossas classes.
Da mesma maneira que temos o private, temos o modificador public, que permite a todos
acessarem um determinado atributo ou método :
class Conta {
//...
public void saca(double quantidade) {
if (quantidade > this.saldo + this.limite){ //posso sacar até saldo+limite
System.out.println("Não posso sacar fora do limite!");
} else {
this.saldo = this.saldo - quantidade;
}
E quando não há modificador de acesso?
Até agora, tínhamos declarado variáveis e métodos sem nenhum modificador como
private e public.
Quando isto acontece, o seu método ou atributo fica num estado de visibilidade
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
50
intermediário entre o private e o public, que veremos mais pra frente, no capítulo de pacotes.
É muito comum, e faz todo sentido, que seus atributos sejam private e quase todos seus
métodos sejam public (não é uma regra!). Desta forma, toda conversa de um objeto com outro é
feita por troca de mensagens, isto é, acessando seus métodos. Algo muito mais educado que
mexer diretamente em um atributo que não é seu!
Melhor ainda! O dia em que precisarmos mudar como é realizado um saque na nossa
classe Conta, adivinhe onde precisaríamos modificar? Apenas no método saca, o que faz pleno
sentido. Como exemplo, imagine cobrar CPMF de cada saque: basta você modificar ali, e
nenhum outro código, fora a classe Conta, precisará ser recompilado. Mais: as classes que usam
esse método nem precisam ficar sabendo de tal modificação! Você precisa apenas recompilar
aquela classe e substituir aquele arquivo .class. Ganhamos muito em esconder o funcionamento
do nosso método na hora de dar manutenção e fazer modificações.
7.5 Encapsulamento
O que começamos a ver nesse capítulo é a idéia de encapsular, isto é, esconder todos os
membros de uma classe (como vimos acima), além de esconder como funcionam as rotinas (no
caso métodos) do nosso sistema.
Encapsular é fundamental para que seu sistema seja sucetível a mudanças: não
precisaremos mudar uma regra de negócio em vários lugares, mas sim em apenas um único
lugar, já que essa regra está encapsulada.
(veja o caso do método saca)
O conjunto de métodos públicos de uma classe é também chamado de interface da classe,
pois esta é a única maneira a qual você se comunica com objetos dessa classe.
Programando voltado para a interface e não para a implementação É sempre bom
programar pensando na interface da sua classe, como seus usuários a estarão utilizando, e não
somente em como ela irá funcionar.
A implementação em si, o conteúdo dos métodos, não tem tanta importância para o
usuário dessa classe, uma vez que ele só precisa saber o que cada método pretende fazer, e não
como ele faz, pois isto pode mudar com o tempo.
Sempre que vamos acessar um objeto, utilizamos sua interface. Existem diversas
analogias fáceis no mundo real:
Todos os celulares fazem a mesma coisa (interface), eles possuem maneiras (métodos) de
discar, ligar, desligar, atender, etc. O que muda é como eles fazem (implementação), mas repare
que para o usuário comum pouco importa se o celular é GSM ou CDMA, isso fica encapsulado
na implementação (que aqui são os circuitos).
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
51
Já temos conhecimentos suficientes para resolver aquele problema da validação de CPF:
class Cliente {
private String nome;
private String endereco;
private String cpf;
private int idade;
public void mudaCPF(String cpf) {
validaCPF(cpf);
this.cpf = cpf;
}
private void validaCPF(String cpf) {
// série de regras aqui, falha caso nao seja válido
}
// ..
}
Se alguém tentar criar um Cliente e não usar o mudaCPF para alterar um cpf diretamente,
vai receber um erro de compilação, já que o atributo CPF é privado. E o dia que você não
precisar verificar o CPF de quem tem mais de 60 anos? Seu método fica o seguinte:
public void mudaCPF(String cpf) {
if (this.idade <= 60) {
validaCPF(cpf);
}
this.cpf = cpf;
}
O controle sobre o CPF está centralizado: ninguém consegue acessá-lo sem passar por aí, a
classe Cliente é a única responsável pelos seus próprios atributos!
Alguns modificadores
publico: permite que atributos sejam acessados por qualquer outra classe
diretamente, o que fere o conceito de encapsulamento. (não tem restrição)
Privado significa que os atributos e métodos só podem ser acessados de dentro da
classe a qual pertencem
Padrão Quando não possui modificadores.
7.6 Exemplo com encapsulamento
Vamos usar um modificador na classe Vendas1 encapsulando o atributo VALOR, ou seja
proibindo que seja modificado.
Só funciona se eu retirar o valor
package POO;
public class VendaEfetuada1 {
public static void main(String[] args) {
Vendas1 objVendas1;
objVendas1 = new Vendas1();
objVendas1.cliente = "Maneu Rocha";
objVendas1.produto = "Placa de som";
//objVendas1.valor = 800;
javax.swing.JOptionPane.showMessageDialog
(null, "Comprador "+objVendas1.cliente+
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
52
"\nproduto "+objVendas1.produto);
//"\nvalor "+ objVendas1.valor);
}
}
7.7 Alterando uma variável private
Não posso modificar uma variável private de fora da classe mas posso fazer isso de
dentro da classe através de um método.
Vou criar o método
package POO;
public class Vendas1 {
public String cliente,produto;
private double valor;
public double alteraValor(double valorParametro){
valor = valorParametro;
return valor;
}
}
devo chamar o método diretamente
package POO;
public class VendaEfetuada1 {
public static void main(String[] args) {
Vendas1 objVendas1;
objVendas1 = new Vendas1();
objVendas1.cliente = "Maneu Rocha";
objVendas1.produto = "Placa de som";
//objVendas1.alteraValor (663);não preciso desta linha
javax.swing.JOptionPane.showMessageDialog
(null, "Comprador "+objVendas1.cliente+
"\nproduto "+objVendas1.produto+
"\nvalor "+ objVendas1.alteraValor(650));//insiro parametro 650
}
}
7.8 Getters e Setters
O modificador private faz com que ninguém consiga modificar, nem mesmo ler, o
atributo em questão.
Com isso, temos um problema: como fazer para mostrar o saldo de uma Conta, já que
nem mesmo podemos acessá-lo para leitura?
Precisamos então arranjar uma maneira de fazer esse acesso. Sempre que precisamos
arrumar uma maneira de fazer alguma coisa com um objeto, utilizamos de métodos! Vamos
então criar um método, digamos pegaSaldo, para realizar essa simples tarefa:
public class Conta {
private double saldo;
// outros atributos omitidos
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
53
private double pegaSaldo() {
return this.saldo;
}
// deposita() saca() e transfere() omitios
}
Para acessarmos o saldo de uma conta, podemos fazer:
class TestaAcessoComPegaSaldo {
public static void main(String args[]) {
Conta minhaConta = new Conta();
minhaConta.deposita(1000);
System.out.println("Saldo: " + minhaConta.pegaSaldo());
}
}
Para permitir o acesso aos atributos (já que eles são private) de uma maneira controlada, a
prática mais comum é criar dois métodos, um que retorna o valor e outro que muda o valor.
A convenção para esses métodos é de colocar a palavra get ou set antes do nome do
atributo. Por exemplo, a nossa conta com saldo, limite e titular fica assim, no caso da gente
desejar dar acesso a leitura e escrita a todos os atributos:
public class Conta {
private double saldo;
private double limite;
private Cliente titular;
public double getSaldo() {
return this.saldo;
}
public void setSaldo(double saldo) {
this.saldo = saldo;
}
public double getLimite() {
return this.limite;
}
public void setLimite(double limite) {
this.limite = limite;
}
public Cliente getTitular() {
return this.titular;
}
public void setTitular(Cliente titular) {
this.titular = titular;
}
}
É uma má prática criar uma classe e, logo em seguida, criar getters e setters para todos
seus atributos.
Você só deve criar um getter ou setter se tiver a real necessidade. Repare que nesse
exemplo setSaldo não deveria ter sido criado, já que queremos que todos usem deposita() e
saca().
Outro detalhe importante, um método getX não necessariamente retorna o valor de um
atributo que chama X do objeto em questão. Isso é interessante para o encapsulamento. Imagine
a situação: queremos que o banco sempre mostre como saldo o valor do limite somado ao saldo
(uma prática comum dos bancos que costuma iludir seus clientes). Poderíamos sempre chamar
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
54
c.getLimite() + c.getSaldo(), mas isso poderia gerar uma situação de “replace all” quando
precisássemos mudar como o saldo é mostrado. Podemos encapsular isso em um método e,
porque não, dentro do próprio getSaldo? Repare:
public class Conta {
private double saldo;
private double limite;
private Cliente titular;
public double getSaldo() {
return this.saldo + this.limite;
}
// deposita() saca() e transfere() omitidos
public Cliente getTitular() {
return this.titular;
}
public void setTitular(Cliente titular) {
this.titular = titular;
}
}
O código acima nem possibilita a chamada do método getLimite(), ele não existe. E nem
deve existir enquanto não houver essa necessidade. O método getSaldo() não devolve
simplesmente o saldo... e sim o que queremos que seja mostrado como se fosse o saldo. Utilizar
getters e setters não só ajuda você a proteger seus atributos, como também possibilita ter de
mudar algo em um só lugar... chamamos isso de encapsulamento, pois esconde a maneira como
os objetos guardam seus dados. É uma prática muito importante.
Nossa classe está totalmente pronta? Isto é, existe a chance dela ficar com menos dinheiro
do que o limite? Pode parecer que não, mas, e se depositarmos um valor negativo na conta?
Ficaríamos com menos dinheiro que o permitido, já que não esperávamos por isso. Para nos
proteger disso basta mudarmos o método deposita() para que ele verifique se o valor é
necessariamente positivo.
Depois disso precisaríamos mudar mais algum outro código? A resposta é não, graças ao
encapsulamento dos nossos dados.
7.9 Construtores
Quando usamos a palavra chave new, estamos construindo um objeto. Sempre quando o
new é chamado, ele executa o construtor da classe. O construtor da classe é um bloco declarado
com o mesmo nome que a classe:
class Conta {
int numero;
Cliente titular;
double saldo;
double limite;
// construtor
Conta() {
System.out.println("Construindo uma conta.");
}
// ..
}
Então, quando fizermos:
Conta c = new Conta();
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
55
A mensagem “construindo uma conta” aparecerá. É como uma rotina de inicialização que
é chamada sempre que um novo objeto é criado. Um construtor pode parecer, mas não é um
método.
O construtor default
Até agora, as nossas classes não possuíam nenhum construtor. Então como é que era
possível dar new, se todo new chama um construtor obrigatoriamente?
Quando você não declara nenhum construtor na sua classe, o Java cria um para você.
Esse construtor é o construtor default, ele não recebe nenhum argumento e o corpo dele
é vazio.
A partir do momento que você declara um construtor, o construtor default não é mais
fornecido.
O interessante é que um construtor pode receber um argumento, podendo assim
inicializar algum tipo de informação:
class Conta {
int numero;
Cliente titular;
double saldo;
double limite;
// construtor
Conta(Cliente titular) {
this.titular = titular;
}
// ..
}
Esse construtor recebe o titular da conta. Assim, quando criarmos uma conta, ela já terá
um determinado titular.
Cliente carlos = new Cliente();
carlos.nome = "Carlos";
Conta c = new Conta(carlos);
System.out.println(c.titular.nome);
7.10
A necessidade de um construtor
Tudo estava funcionando até agora. Para que utilizamos um construtor?
A ideia é bem simples. Se toda conta precisa de um titular, como obrigar todos os objetos
que forem criados a ter um valor desse tipo? Basta criar um único construtor que recebe essa
String!
O construtor se resume a isso! Dar possibilidades ou obrigar o usuário de uma classe a
passar argumentos para o objeto durante o processo de criação do mesmo.
Por exemplo, não podemos abrir um arquivo para leitura sem dizer qual é o nome do
arquivo que desejamos ler! Portanto, nada mais natural que passar uma String representando o
nome de um arquivo na hora de criar um objeto do tipo de leitura de arquivo, e que isso seja
obrigatório.
Você pode ter mais de um construtor na sua classe e, no momento do new, o construtor
apropriado será escolhido.
Construtor: um método especial?
Um construtor não é um método. Algumas pessoas o chamam de um método especial,
mas definitivamente não é, já que não possui retorno e só é chamado durante a
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
56
construção do objeto.
Chamando outro construtor
Um construtor só pode rodar durante a construção do objeto, isto é, você nunca
conseguirá chamar o construtor em um objeto já construído. Porém, durante a
construção de um objeto, você pode fazer com que um construtor chame outro, para
não ter de ficar copiando e colando:
class Conta {
int numero;
Cliente titular;
double saldo;
double limite;
// construtor
Conta (Cliente titular) {
// faz mais uma série de inicializações e configurações
this.titular = titular;
}
Conta (int numero, Cliente titular) {
this(titular); // chama o construtor que foi declarado acima
this.numero = numero;
}
//..
}
Existe um outro motivo, o outro lado dos construtores: facilidade. Às vezes, criamos um
construtor que recebe diversos argumentos para não obrigar o usuário de uma classe a chamar
diversos métodos do tipo ’set’.
No nosso exemplo do CPF, podemos forçar que a classe Cliente receba no mínimo o CPF,
dessa maneira um Cliente já será construído e com um CPF válido.
Java Bean
Quando criamos uma classe com todos os atributos privados, seus getters e setters e um
construtor vazio (padrão), na verdade estamos criando um Java Bean (mas não confunda
com EJB, que é Enterprise Java Beans).
Para saber mais acesse: http://java.sun.com/products/javabeans/
7.11
Exemplo usando construtor no vendas1
Criando um método imprime na classe Vendas1Construtor fica:
package POO;
import javax.swing.JOptionPane;
public class Vendas1Construtor {
public String cliente,produto;
private double valor;
public double alteraValor(double valorParametro){
valor = valorParametro;
return valor;
}
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
57
public void imprime(double valor){
JOptionPane.showMessageDialog(null,"nome: "+cliente+
"\nProduto: "+produto+
"\nValor: "+valor);
}
}
nova classe VendaEfetuadaConstrutor com a chamada do metodo:
package POO;
public class VendaEfetuadaConstrutor {
public static void main(String[] args) {
Vendas1Construtor objVendas1Construtor;
objVendas1Construtor = new Vendas1Construtor();
objVendas1Construtor.cliente = "Maneu Rocha";
objVendas1Construtor.produto = "Placa de som";
objVendas1Construtor.imprime(1563);
}
}
Criando um método construtor, que deve ter o mesmo nome da classe, se eu não criar o
construtor ele vai pegar minhas três variáveis com valores default, ele usara automaticamente o
construtor.
package POO;
import javax.swing.JOptionPane;
public class Vendas1Construtor {
public String cliente,produto;
private double valor;
//criando o construtor
public Vendas1Construtor(String cliente)
{
this.cliente= cliente;
}
public double alteraValor(double valor){
this.valor = valor;
return valor;
}
public void imprime(double valor){
JOptionPane.showMessageDialog(null,"nome: "+cliente+
"\nProduto: "+produto+
"\nValor: "+alteraValor(valor));
}
}
chamando o construtor.
package POO;
public class VendaEfetuadaConstrutor {
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
58
public static void main(String[] args) {
Vendas1Construtor objVendas1Construtor;
objVendas1Construtor = new Vendas1Construtor("Instituto Paula Sousa");
//objVendas1Construtor.cliente = "Maneu Rocha";
objVendas1Construtor.produto = "Placa de som";
objVendas1Construtor.imprime(1563);
}
}
7.12
Implementando vários Construtores
Usando o conceito de sobrecarga que vimos anteriormente posso implementar vários
construtores com parametros diferentes e o mesmo nome da classe
package POO;
import javax.swing.JOptionPane;
public class Vendas1Construtor {
public String cliente,produto;
private double valor;
//criando o construtor1
public Vendas1Construtor(String cliente)
{
this.cliente= cliente;
JOptionPane.showMessageDialog(null, "construtor1");
}
//criando o construtor2
public Vendas1Construtor(String cliente,String produto)
{
this.cliente= cliente;
this.produto = produto;
JOptionPane.showMessageDialog(null, "construtor2");
}
//criando o construtor3
public Vendas1Construtor(double valor)
{
this.valor= valor;
JOptionPane.showMessageDialog(null, "construtor3");
}
//criando o construtor4
public Vendas1Construtor(String cliente,String produto,double valor)
{
this.cliente= cliente;
this.produto = produto;
this.valor = valor;
JOptionPane.showMessageDialog(null, "construtor4");
}
public double alteraValor(double valor){
this.valor = valor;
return valor;
}
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
59
public void imprime(double valor){
JOptionPane.showMessageDialog(null,"nome: "+cliente+
"\nProduto: "+produto+
"\nValor: "+alteraValor(valor));
}
}
Conforme o tipo de parâmetro passado o java vai escolher automaticamente o construtor
necessário
package POO;
public class VendaEfetuadaConstrutor {
public static void main(String[] args) {
Vendas1Construtor objVendas1Construtor;
objVendas1Construtor = new Vendas1Construtor("USP","teclado de
computador");
//objVendas1Construtor.cliente = "Maneu Rocha";
//objVendas1Construtor.produto = "Placa de som";
objVendas1Construtor.imprime(1563);
}
}
ou
package POO;
public class VendaEfetuadaConstrutor {
public static void main(String[] args) {
Vendas1Construtor objVendas1Construtor;
objVendas1Construtor = new Vendas1Construtor("USP","caixas de
som",362);
//objVendas1Construtor.cliente = "Maneu Rocha";
//objVendas1Construtor.produto = "Placa de som";
//objVendas1Construtor.imprime(1563);
}
}
ou
package POO;
public class VendaEfetuadaConstrutor {
public static void main(String[] args) {
Vendas1Construtor objVendas1Construtor;
objVendas1Construtor = new Vendas1Construtor("USP","placa mãe");
//objVendas1Construtor.cliente = "Maneu Rocha";
//objVendas1Construtor.produto = "Placa de som";
objVendas1Construtor.imprime(111111);
}
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
60
}
7.13
Atributos de Classe
Nosso banco também quer controlar a quantidade de contas existentes no sistema. Como
poderíamos fazer isto? A idéia mais simples:
Conta c = new Conta();
totalDeContas = totalDeContas + 1;
Aqui, voltamos em um problema parecido com o da validação de CPF. Estamos espalhando um
código por toda aplicação, e quem garante que vamos conseguir lembrar de incrementar a
variável totalDeContas toda vez?
Tentamos então, passar para a seguinte proposta:
class Conta {
private int totalDeContas;
//...
Conta() {
this.totalDeContas = this.totalDeContas + 1;
}
}
Quando criarmos duas contas, qual será o valor do totalDeContas de cada uma delas? Vai
ser 1. Pois cada uma tem essa variável. O atributo é de cada objeto.
Seria interessante então, que essa variável fosse única, compartilhada por todos os objetos dessa
classe.
Dessa maneira, quando mudasse através de um objeto, o outro enxergaria o mesmo valor.
Para fazer isso em java, declaramos a variável como static.
private static int totalDeContas;
Quando declaramos um atributo como static, ele passa a não ser mais um atributo de cada
objeto, e sim um atributo da classe, a informação fica guardada pela classe, não é mais individual
para cada objeto.
Para acessarmos um atributo estático, não usamos a palavra chave this, mas sim o nome da
classe:
class Conta {
private static int totalDeContas;
//...
Conta() {
Conta.totalDeContas = Conta.totalDeContas + 1;
}
}
Já que o atributo é privado, como podemos acessar essa informação a partir de outra
classe? Precisamos
class Conta {
private static int totalDeContas;
//...
Conta() {
Conta.totalDeContas = Conta.totalDeContas + 1;
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
61
}
public int getTotalDeContas() {
return Conta.totalDeContas;
}
}
Como fazemos então para saber quantas contas foram criadas?
Conta c = new Conta();
int total = c.getTotalDeContas();
Precisamos criar uma conta antes de chamar o método! Isso não é legal, pois gostaríamos
de saber quantas contas existem sem precisar ter acesso a um objeto conta. A ideia aqui é a
mesma, transformar esse método que todo objeto conta tem em um método de toda a classe.
Usamos a palavra static de novo, mudando o método anterior.
public static int getTotalDeContas() {
return Conta.totalDeContas;
}
Para acessar esse novo método:
int total = Conta.getTotalDeContas();
Repare que estamos chamando um método não com uma referência para uma Conta, e
sim usando o nome
da classe.
Métodos e atributos estáticos
Métodos e atributos estáticos só podem acessar outros métodos e atributos estáticos da
mesma classe, o que faz todo sentido já que dentro de um método estático não temos
acesso à referência this, pois um método estático é chamado através da classe, e não de
um objeto.
O static realmente traz um “cheiro” procedural, porém em muitas vezes é necessário.
7.14
Exercícios: Encapsulamento, construtores e static
1) Adicione o modificador de visibilidade (private, se necessário) para cada atributo e método da
classe Funcionario. Tente criar um Funcionario no main e modificar ou ler um de seus atributos
privados. O que acontece?
2) Crie os getters e setters necessários da sua classe Funcionario . Por exemplo:
class Funcionario {
private double salario;
// ...
public double getSalario() {
return this.salario;
}
public void setSalario(double salario) {
this.salario = salario;
}
}
Não copie e cole! Aproveite para praticar sintaxe. tá bom!!
3) Modifique suas classes que acessam e modificam atributos de um Funcionario para utilizar os
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
62
getters e
setters recém criados.
Por exemplo, onde você encontra:
f.salario = 100;
System.out.println(f.salario);
passa para:
f.setSalario(100);
System.out.println(f.getSalario());
4) Faça com que sua classe Funcionario possa receber, opcionalmente, o nome do Funcionario
durante a criação do objeto. Utilize construtores para obter esse resultado.
Dica: utilize um construtor sem argumentos também, para o caso de a pessoa não querer passar o
nome do Funcionario.
Seria algo como:
class Funcionario {
public Funcionario() {
// construtor sem argumentos
}
public Funcionario(String nome) {
// construtor que recebe o nome
}
}
Por que você precisa do construtor sem argumentos para que a passagem do nome seja opcional?
5) (opcional) Adicione um atributo na classe Funcionario de tipo int que se chama identificador.
Esse identificador deve ter um valor único para cada instância do tipo Funcionario. O primeiro
Funcionario instanciado tem identificador 1, o segundo 2, e assim por diante. Você deve utilizar
os recursos aprendidos aqui para resolver esse problema.
Crie um getter para o identificador. Devemos ter um setter?
6) (opcional) Crie os getters e setters da sua classe Empresa e coloque seus atributos
como private. Lembre-se
de que não necessariamente todos os atributos devem ter getters e setters.
Por exemplo, na classe Empresa, seria interessante ter um setter e getter para a sua
array de funcionários?
Não seria mais interessante ter um método como este?
class Empresa {
// ...
public Funcionario getFuncionario (int posicao) {
return this.empregados[posicao];
}
}
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
63
8.1 Composição e Herança
Um dos conceitos mais interessantes das linguagens orientadas a objeto é a reutilização
de código. Mas para isso realmente funcionar, você tem que conseguir fazer mais do que
simplesmente copiar código e altera-lo. Você deve ser capaz de criar uma nova classe usando
outra classe já existente.
Existem duas maneiras diferentes de fazer isso. Uma é chamada composição. A
composição é geralmente utilizada quando se deseja utilizar as características de um objeto mas
não sua interface.
Quando eu tenho um objeto do tipo carro e uma outra pessoa vai utilizar um carro com as
mesmas funcionalidades, é mais fácil ela construir um carro utilizando as "peças" (que já estão
prontas). Assim, ela pode importar a classe carro e usar:
carro meuCarro = new carro();
A partir de agora, dentro do seu objeto, você tem um objeto do tipo carro. O que você fez
aqui foi compor um objeto. Seu objeto agora é do tipo composto, já que ele possui mais do que
um objeto dentro dele.
Mas existe situações onde a composição não basta. É quando eu desejo utilizar o objeto
existente para criar uma versão melhor ou mais especializada dele. Isso é chamado herança.
8.2 Construindo exemplo Herança
Vamos criar um pacote chamado Heranca, dai uma classe chamada HerançaPaiPessoa e
todos os atributos principais para se construir um cadastro.
package POO;
public class HerançaPaiPessoa
{
private String nome;
private String endereco;
private int numero;
private String cidade;
private String telefone;
//agora vamos construir um metodo para incluir pessoas por parametro
public void incluir(String nome, String endereco,
int numero, String cidade, String telefone)
{
this.nome = nome;
this.endereco = endereco;
this.numero = numero;
this.cidade = cidade;
this.telefone = telefone;
Para construir uma classe ou classes filhas para implementar o conceito de herança, ou
seja classes que vão herdar as caracteristicas da classe pai. Uso a palavra reservada extends e o
nome da classe pai.
package POO;
public class HerancaFilhaPessoaFisica extends HerançaPaiPessoa
{
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
64
private String cpf;
private String rg;
private int idade;
private char sexo;
//criando metodo para incluir
public void incluir(String cpf, String rg, char sexo,int idade)
{
this.cpf = cpf;
this.rg = rg;
this.idade = idade;
this.sexo = sexo;
}
}
8.3 Criando classe filha
Vamos criar a classe filha pessoa juridica
package POO;
public class HerançaPaiPessoa
{
private String nome;
private String endereco;
private int numero;
private String cidade;
private String telefone;
//agora vamos construir um metodo para incluir pessoas por parametro
public void incluir(String nome, String endereco,
int numero, String cidade, String telefone)
{
this.nome = nome;
this.endereco = endereco;
this.numero = numero;
this.cidade = cidade;
this.telefone = telefone;
}
}
As duas classes filhas agora tem todas as características da classe original, PAI.
Iremos implementar uma nova classe para cadastro de alunos, vou criar a classe Alunos,
essa classe executa portanto tem o void.
8.4 Classe sistema void
O aluno é uma pessoa fisica portanto devo instanciá-lo a partir da classe pessoa física
package POO;
public class Alunos
{
public static void main(String[] args)
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
65
{
HerancaFilhaPessoaFisica objAluno
= new HerancaFilhaPessoaFisica();
//Ao se digitar obj.Aluno. aparecem as duas opções de incluir
objAluno.incluir("Celio Assunção", "Rua Magna", 43, "cidade", "01125252525");
//uso o conceito de sobrecarga
objAluno.incluir("666555777-44", "10225666-3", 'M', 28);
//note que a variavel char 'M' foi com aspas simples
//quero imprimir o nome da pessoa
//ao digitar objAluno. eu não consigo ver os encapsulados(nome, rg
//pois estão private, se eu mudar para public o nome aparece. Fantastico
né!
System.out.println("nome do aluno " +objAluno.nome);
}
}
8.5
Metodo para private
Muito bonito, só tem um problema se ficar public a questão do encapsulamento vai para o
espaço, não é o que queremos então vamos tentar através de um método, como sabemos as
variáveis privadas só podem ser usadas dentro da classe onde foram criadas, então vamos
implementar um método que retorne o que queremos .tá bom!!
Vamos criar lá no HerancaPaiPessoa
package POO;
public class HerançaPaiPessoa
{
private String nome;
private String endereco;
private int numero;
private String cidade;
private String telefone;
//agora vamos construir um metodo para incluir pessoas por parametro
public void incluir(String nome, String endereco,
int numero, String cidade, String telefone)
{
this.nome = nome;
this.endereco = endereco;
this.numero = numero;
this.cidade = cidade;
this.telefone = telefone;
}
//criando todos os métodos
public String retornaNome()
{return(nome);};
public String retornaEndereco()
{return(endereco);}
public int retornaNumero()
{return(numero);}
public String retornaCidade()
{return(cidade);}
public String retornaTelefone()
{return(telefone);}
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
66
}
Muito fácil, agora vamos no incluir e pedir para retornar o nome vamos fazer para todos
tá bom!!
package POO;
public class Alunos
{
public static void main(String[] args)
{
HerancaFilhaPessoaFisica objAluno
= new HerancaFilhaPessoaFisica();
//Ao se digitar obj.Aluno. aparecem as duas opções de incluir
objAluno.incluir("Celio Assunção", "Rua Magna", 43, "cidade", "01125252525");
//uso o conceito de sobrecarga
objAluno.incluir("666555777-44", "10225666-3", 'M', 28);
//note que o char 'M' foi com aspas simples
//quero imprimir o nome da pessoa
//ao digitar objAluno. eu não consigo ver os encapsulados(nome, rg
//pois estão private, se eu mudar para public o nome aparece. Fantastico
né!
System.out.println("nome do aluno " +objAluno.retornaNome());
System.out.println("endereço
" +objAluno.retornaEndereco());
System.out.println("numero
" +objAluno.retornaNumero());
System.out.println("Cidade
" +objAluno.retornaCidade());
System.out.println("Telefone " +objAluno.retornaTelefone());
}
}
maravilha né??...a cidade fica como exercício, tá bom?
package POO;
public class Alunos
{
public static void main(String[] args)
{
HerancaFilhaPessoaFisica objAluno
= new HerancaFilhaPessoaFisica();
//Ao se digitar obj.Aluno. aparecem as duas opções de incluir
objAluno.incluir("Celio Assunção", "Rua Magna", 43, "cidade", "01125252525");
//uso o conceito de sobrecarga
objAluno.incluir("666555777-44", "10225666-3", 'M', 28);
//note que o char 'M' foi com aspas simples
//quero imprimir o nome da pessoa
//ao digitar objAluno. eu não consigo ver os encapsulados(nome, rg
//pois estão private, se eu mudar para public o nome aparece. Fantastico
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
né!
System.out.println("nome do aluno " +objAluno.retornaNome());
System.out.println("endereço
" +objAluno.retornaEndereco());
System.out.println("numero
" +objAluno.retornaNumero());
System.out.println("Cidade
" +objAluno.retornaCidade());
System.out.println("Telefone " +objAluno.retornaTelefone());
System.out.println("Cpf
" +objAluno.retornaCpf());
System.out.println("RG
" +objAluno.retornaRg());
System.out.println("Idade
" +objAluno.retornaIdade());
System.out.println("Sexo
" +objAluno.retornaSexo());
}
}
8.6
Exercicio de fixação
elabore o mesmo procedimento para Pessoa jurídica como exercício
67
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
68
8.7
Polimorfismo
O avião e a pomba voam porem são entidades completamente diferentes, o avião
pertence à classe dos veículos de transporte e a pomba pertence à classe dos animais
MeiosDeTransporte
Animais
Aviao
Pomba
Voador
Pelo conceito de herança já visto o Avião extends da classe MeiosDeTransporte e Pomba
extends da classe Animais, mas os dois implementam a interface Voador
O conceito de herança nos leva a discutir outro: o polimorfismo. Podemos traduzir essa
palavra pela capacidade de um objeto em saber qual o método que deve executar. Apesar da
chamada ser a mesma, objetos diferentes respondem de maneira diferente.
O método voar para o avião é diferente do método voar para a Pomba
Como exemplo, imagine uma classe chamada Figura. Essa classe tem a habilidade de
desenhar a si mesma na tela. Se eu definir uma classe chamada Triangulo que estenda a classe
Figura, ela pode usar o método da super classe para desenhar a si mesma, sem necessidade de
criar um método apenas para isso.
8.8
Implementando polimorfismo
Vamos implementar esse código em java.
Primeiro a interface voador( control +3 ,interface, Voadores)
package Polimorfismo;
public interface Voador {
public void voar();
}
Criando a classe Pomba implements Voador automaticamente o Eclipse pede que se
implementem todos os métodos que estão na interface
package Polimorfismo;
public class Pomba implements Voador {
@Override
public void voar() {
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
69
// TODO Auto-generated method stub
System.out.println("estou voando como uma Pomba");
}
}
Fazendo o mesmo com a classe Aviao implements Voador (Control +1 add...)
package Polimorfismo;
public class Aviao implements Voador{
@Override
public void voar() {
// TODO Auto-generated method stub
System.out.println("Estou voando como um avião");
}
}
Vamos criar a classe Aeroporto com um método publico chamado fazerVoar, esse método
vai receber um Voador v e esse parâmetro voador v invocará um método voar.
Isso significa que o Aeroporto pode mandar tanto um Avião como uma pomba, cada qual
deve voar de forma diferente, mesmo invocando o mesmo método voar
package Polimorfismo;
public class Aeroporto {
public void fazerVoar(Voadores v){
v.voar();
}
}
Criando a classe Sistema com o main, implementando os objetos e fazendo a chamada do
método voar fica;
package POO;
public class Sistema {
public static void main(String[] args) {
Aeroporto aeroporto = new Aeroporto();
Pomba pomba = new Pomba();
Aviao aviao = new Aviao();
aeroporto.fazerVoar(pomba);
aeroporto.fazerVoar(aviao);
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
70
}
}
Tá bom???
Isso significa que a partir de agora eu posso implementar qualquer outra classe, por exemplo
helicóptero e fazer voar sem nenhuma modificação ao meu código.
Vocês entenderam?
8.9
Outro exemplo polimorfismo
Em java eu não posso implementar herança múltipla, ou seja uma classe não pode utilizar
extends de mais uma vez, mas é possível através da interface, C++ possui esta propriedade, mas
é uma outra história.
Vamos fazer outro exemplo de uma calculadora que faz as quatro operações primeiro com a
operação soma.
package POO;
public interface InterfaceCalculos
{
public double somar();
}
esta interface devolve um double agora vamos construir a classe que implementara a interface
package POO;
public class InterfaceImplementada implements InterfaceCalculos
{
private double num1,num2;
//construtor mesmo nome da classe
public InterfaceImplementada(double num1,double num2)
{
this.num1 = num1;
this.num2 = num2;
}
//metodo main onde já implemento o objeto
public static void main(String[] args)
{
InterfaceImplementada objCalc = new InterfaceImplementada(20,10);
System.out.println("A soma e: "+objCalc.somar());
}
//metodo somar com retorno double
public double somar()
{
return num1+num2;
}
}
muito legal esta parte agora eu passo para o resto das operações:
package POO;
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
71
public interface InterfaceCalculos
{
public double somar();
public double dividir();
public double multiplicar();
public double subtrair();
}
o sistema
package POO;
public class InterfaceImplementada implements InterfaceCalculos
{
private double num1,num2;
//construtor mesmo nome da classe
public InterfaceImplementada(double num1,double num2)
{
this.num1 = num1;
this.num2 = num2;
}
//metodo main onde já implemento o objeto
public static void main(String[] args)
{
InterfaceImplementada objCalc = new InterfaceImplementada(20,10);
System.out.println("A soma e: "+objCalc.somar());
System.out.println("A multipicação e: "+objCalc.multiplicar());
System.out.println("A divisão e: "+objCalc.dividir());
System.out.println("A subtração e: "+objCalc.subtrair());
}
//metodos com retorno double
public double somar() {
return num1+num2;}
public double multiplicar() {
return num1*num2;}
public double dividir() {return num1/num2;}
public double subtrair() { return num1-num2;}
}
percebem que seria possível implementar outras operações, inclusive mais elaboradas tente tá
bom?
Instituto Paula Sousa –
9.1.
Orientação a objetos com java
Celio Assunção
72
Formularios
Como já vimos anteriormente uma das coisas mais legais do java é a imensa quantidade de
classes já prontas que podemos usar em nossas aplicações. Vimos, por exemplo, a classe
JOptionPane e algumas aplicações.
Agora vamos ver algumas coisas mais elaboradas.
Começando por formulários, vamos criar passo a passo para ver como é fácil.
Na biblioteca swing temos uma classe chamada Jframe, que é uma janela com algumas
características.
Como já foi visto podemos criar uma classe é usar o extends para que nossa classe possa herdar
caracteristicas de outra classe que já existe.
package Heranca;
import javax.swing.JFrame;
public class FormCelio extends JFrame
{
public static void main(String args[])
{
JFrame objForm1 = new JFrame();
objForm1.show();
}
}
Execute. Viu que legal, o formulário prontinho mas eu posso ainda incrementar esse formulário
com tamanho, cor de fundo, barra de títulos, conteúdos etc. Para isso tenho que montar um
método construtor onde eu vou colocar todas essas características.
package Heranca;
import javax.swing.JFrame;
public class FormCelio extends JFrame
{
//o metodo construtor com mesmo nome da classe
public FormCelio()
{
//primeiro uma barra de titulo, uso o método
//pré existente chamado setTitle()
setTitle("Aprendendo fazer formularios CURSO JAVA
EAD");
}
public static void main(String args[])
{//não esqueça de inicializar com o metodo construtor
JFrame objForm1 = new FormCelio();
objForm1.show();
Instituto Paula Sousa –
9.2.
Orientação a objetos com java
Celio Assunção
73
Jframe setSize/setLocation
posso definir o tamanho em pixels por exemplo (800x600) ou 1024x768
setSize(800x600)
posso mudar a posição do frame
setLocaction(150x150)
package Heranca;
import javax.swing.JFrame;
public class FormCelio extends JFrame
{
//o metodo construtor com mesmo nome da classe
public FormCelio()
{
//primeiro uma barra de titulo, uso o método
//pré existente chamado setTitle()
setTitle("Aprendendo fazer formularios CURSO JAVA
EAD");
//modificando o tamanho
setSize(800,600);
//modificando a posição
setLocation(150,150);
}
public static void main(String args[])
{
//não esqueça de inicializar com o metodo construtor
JFrame objForm1 = new FormCelio();
objForm1.show();
}
}
9.3.
Jfrane setDefautCloseOperation/ setResizable(false)
muito legal né? Tá começando a ficar melhor, viu só é tudo sempre a mesma coisa, funciona
direitinho é só ir mexendo e melhorando da forma que queremos.
Veja que quando você fecha o formulário a aplicação fica aberta, ela continua ativa. Existe um
método chamado setDefautCloseOperation que eu posso aplicar no meu Jframe que fará essa
função, vejamos..
veja que legal, quando você vai colocando o nome do método o eclipse vai mostrando opções.
//metodo para fechar o formulário
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
se você executar ele fechara a aplicação quando fechar o formulário. Algumas versões do Eclipse
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
74
já fazem isto automaticamente mas fica a dica para outros editores.
Uma outra coisa é a questão de poder ou não redimensionar o frame, posso usar o
setResizable(false ou true)
setResizable(false);
//neste caso não posso redimensionar, via mouse por
exemplo
9.4.
Manipulando cores getContentPane
para trocar a cor de fundo eu tenho que importar outra biblioteca gráfica a java.awt e usar o
método getContentPane( ) cor de fundo é só setar uma cor de fundo.
getContentPane().setBackground(Color.blue);
red,blue,ciano etc
poderia definir padrões RGB para meu frame, contando 255 padroes de cor eu poderia misturar
as cores por exemplo 150 red, 120 green, 50 blue
//misturando cores (red green blue)
getContentPane().setBackground(new Color(150,120,50));
viu só que legal. Para apresentar nosso formulário usamos ate agora o
JFrame objForm1 = new FormCelio();
objForm1.show();
mas tem um outro método mais atual que pode tornar ou não visível nosso frame.
objForm1.setVisible(false); viu só sumiu, tá bom?
9.5.
Inserindo mais componentes
Vamos por exemplo inserir Titulo (Label). Eu devo antes criar um objeto publico, instanciando
uma classe, do mesmo jeito que fizemos antes, fora do construtor para poder usá-lo em qualquer
lugar, depois inicializar dentro do construtor .
JLabel LbTitulos;
dai aparece um erro pois o Jlabel esta dentro da javax.swing.JLabel, mas como tambem estamos
usando o Jframe é melhor eu colocar o asterisco
import javax.swing.*;
feito isto eu posso criar meu objeto lbTitulos dentro do meu construtor
lbTitulos = new JLabel("APOSTILA AULAS DE JAVA EAD");
agora pode executar...tá bom? Não aconteceu nada porque temos que fazer como fizemos com a
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
75
cor usar o método getContentPane para setar o titulo
//setando ou adicionando o titulo
getContentPane().add(lbTitulos);
como em matemática é sempre tudo igual, fica muito fácil.
Quero inserir um botão de saída, fácil, crio
//Objeto btSaida do tipo JButon
JButton btSaida;
crio o objeto com o new
//inicializando botao saida btSaida
btSaida = new JButton("Botao Saida");
adiciono o botão saída
//setando ou adicionando botao saida
getContentPane().add(btSaida);
executo e pasmem ficou só o botão sumiu o titulo, não se desespere vamos adicionar uma caixa
de texto (TextField), crio o objeto do tipo
//objeto campoTexto
JTextField tfNome;
criando o objeto
//inicializando o campo texto sem nada escrito
tfNome = new JtextField("");
add
//setando ou adicionando
getContentPane().add(tfNome);
//pode escrever
viu como é muito fácil. Agora fica para a segunda parte do curso a manipulação destes objetos
que acabamos de criar.
Até Logo pessoal. Mandem sugestões para meu e-mail ([email protected])
obrigado,
Celio Assunção
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
76
Dicas Eclipse
Eclipse Acha que já conhece o Control + Espaço?
public class Teste {
Met(aperte ctrl space)
Sim, ela te ajuda a autocompletar nome de classes e métodos, mas podemos ir
muito além. Ao declarar uma variável do tipo ContaCorrente basta, logo após dar
o espaço, pressionar Control + Espaço e possibilidades de nome serão sugeridas:
public class Teste {
MetodoComRetorno(aperte ctrl space)
O Control + Espaço pode ativar um dos muitos templates do Eclipse, como o foreach.
Basta digitá-lo e pressionar Control + Espaço que será estruturado um enhanced-for, sugerindo
utilizar a array ou collection do escopo mais próximo. O funcionamento é análogo para outros
templates, como para gerar o método main:
import javax.swing.JOptionPane;
public class Teste {
static double nota1,nota2;
public static void main(String[] args) {
}
public static void LerNotas(){
nota1
=
Double.parseDouble(JOptionPane.showInputDialog("Digite
nota1:"));
nota2
=
Double.parseDouble(JOptionPane.showInputDialog("digite
nota2:"));
}
int[] array = new int[100];
public int[] getArray() {
return array;
}
}
Existem várias formas de se gerar os getters e setters e a mais rápida é com Control + Espaço.
Dado qualquer atributo, basta digitar get+Control + Espaço e pronto, ele dará opções para a
geração do getter. O funcionamento é análogo para o setter:
import javax.swing.JOptionPane;
public class Teste {
static double nota1,nota2;
public static void main(String[] args) {
}
public static void LerNotas(){
nota1
=
Double.parseDouble(JOptionPane.showInputDialog("Digite
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
77
nota1:"));
nota2
=
Double.parseDouble(JOptionPane.showInputDialog("digite
nota2:"));
}
private double imposto;
get(control space)
}
O Control + 1 vai além da correção:
Esta talvez seja a combinação mais eficiente, porém menos conhecida. Ela não serve apenas para
dar sugestões quando algo há algum erro de compilação (quickfix), indicado pela pequena
lâmpada, como no tratamento de exceções checked:
public class Teste{
public static void main(String[] args) {
new FileOutputStream("arquivo.txt");
}
}
neste código aparece um erro crtl +space indica opções de como resolver.
Ou para criar classes que ainda não existem:
Quando declaramos um atributo de uma classe, o Control + 1 vai oferecer e geração de getter e
setter:
public class Teste{
private double imposto;(control +1)
}
Mas o uso mais interessante é na criação de váriáveis e atributos. Quando vamos criar uma
váriável, começamos declarando-a, mas isso não é necessário. Podemos simplesmente
digitar new ContaCorrente() e pressionar Control + 1:
public class Teste{
public static void main(String[] args) {
new ContaCorrente();
}
}
Podemos também utilizar Control + 1 para remover cada import desnecessário, porém
ocontrol+shift+o é mais eficiente.
O Control + 3 pode fazer todo o restante.
Ele é o atalho que busca um comando ou opção de menu baseado no que você escreve. Ao
digitar generate, por exemplo, temos:
public class Teste{
public static void main(String[] args) {
new ContaCorrente();
}
Generate ( crtl +3)
Instituto Paula Sousa –
Orientação a objetos com java
Celio Assunção
78
}
Com isso podemos gerar construtores, getters e setters ou buscar por todo código. Até mesmo
abrir a tela de preferences ou fazer um new class. Mais: conforme você usa o Control + 3, o
Eclipse memoriza suas principais escolhas, de tal forma que da próxima vez elas estarão
ordenadas de acordo com sua utilização. Também é possível escrever apenas as primeiras letras
das palavras que constituem o comando, como Generate Getters And Setters (GGAS):
public class Teste{
public static void main(String[] args) {
new ContaCorrente();
}
ggas( crtl +3)
}
Pode gerar construtores de acordo com seu atributos, através
(Generate Constructor UsingFields), entre muitos outros. O céu é o limite.
Ou rodar sua aplicação, ao digitar run:
public class Teste{
public static void main(String[] args) {
new ContaCorrente();
}
GCUF ( crtl +3)
do
GCUF
Para os iniciante em Eclipse, isso é bem mais fácil que guardar na memória as estranhas teclas de
atalho para rodar uma aplicação: agora ela está a apenas um Control + 3 run de distância.
Bibliografia