Académique Documents
Professionnel Documents
Culture Documents
Em torno de 1990, uma equipe da SUN Microsystems, liderada por James Gosling foi
incumbida de desenvolver programas para controlar aparelhos eletrônicos. A linguagem
inicialmente utilizada foi C++, mas, com o decorrer do tempo, essa equipe se deparou com
várias dificuldades inerentes ao C++ (tais como herança múltipla e ponteiros). Para contornar
essas dificuldades foi desenvolvida a linguagem Oak, que tinha a mesma estrutura do C++, só
que sem os detalhes que o tornava complicado para controlar aparelhos eletrônicos.
A linguagem Oak foi utilizada na construção do sistema Star Seven (que possibilita o
controle de vários aparelhos eletrônicos de uma casa através do toque em uma tela) e de um
sistema de televisão interativa. Apesar de nenhum dos dois projetos terem se tornado
produtos, a linguagem Oak, com o decorrer do tempo, pôde amadurecer. Tendo em vista que
o nome Oak já havia sido reivindicado, a SUN passou a chamar a linguagem Oak de Java.
Em 1993, a Internet passou a suportar WWW, deixando de ser composta somente de
texto e adotando um ambiente gráfico. Com isso, a SUN adaptou a já poderosa (independente
de plataforma, segura e simples) linguagem Java para esse novo mundo, criando o recurso de
Applet. Para mostrar que Java era uma linguagem robusta, a SUN implementou um browser, o
HotJava.
Em meados de 1995 a linguagem Java foi lançada oficialmente, e passou a ser
incorporada aos browsers da Netscape e da Microsoft.
1.2- Os 3 Alicerces
Por questões de segurança, simplificação, e por ser uma linguagem OO pura, Java não
utiliza:
✗ Structures e unions;
✗ #define;
✗ Ponteiros;
✗ Herança múltipla;
✗ Funções;
✗ Goto;
Para que Java conseguisse atingir independência de plataforma, a SUN optou por uma
arquitetura independente (máquina virtual), para a qual um código fonte Java é compilado. O
código fonte (programa.java), após compilado, se transforma em byte-code (programa.class).
Esse byte-code atualmente não pode ser executado em nenhuma arquitetura, mas pode ser
interpretado em várias arquiteturas, desde que estas tenham um interpretador Java instalado.
Veja abaixo como ocorrem as mudanças <código fonte> <byte-code (plataforma
independente)> <binário (plataforma dependente)>:
Interpretador 1001110111
Programa Java Meu
Programa
MeuPrograma.java MeuPrograma.class
Compilador
O interpretador Java é uma implementação da máquina virtual Java, voltada para uma
determinada plataforma. Um código fonte Java é compilado somente uma vez, mas será
interpretado quantas vezes forem necessárias a sua execução.
MeuPrograma.java
Programa Java Compilador
Interpretador Interpretador
Meu
Meu Programa
Programa
Palm PC
Programação Orientada a Objetos
✗ javac
✗ Java
Uma variável é um nome definido pelo programador ao qual pode ser associado um
valor pertencente a um certo tipo de dados. Em outras palavras, uma variável é uma porção
de memória, identificada por um nome, que é capaz de armazenar um valor de um certo tipo.
Desta forma toda variável possui um nome, um tipo, um conteúdo e um endereço de memória.
O nome de uma variável em Java pode ser uma seqüência de um ou mais caracteres
alfabéticos e numéricos, iniciados por uma letra ou ainda pelos caracteres ‘_’ (underscore) ou
‘$’ (cifrão). Os nomes não podem conter outros símbolos gráficos, operadores ou espaços em
branco, podendo ser arbitrariamente longos embora apenas os primeiros 32 caracteres serão
utilizados para distinguir nomes de diferentes variáveis. É importante ressaltar que as letras
minúsculas são consideradas diferentes das letras maiúsculas, ou seja, a linguagem Java é
sensível à caixa, assim temos como exemplos válidos:
a total x2 $min
_especial VALOR Maximo ExpData
Além destas, existem outras que embora reservadas não são usadas pela linguagem:
Algumas destas, tal como o goto, faziam parte da especificação preliminar do Oak,
antes de sua formalização como Java. Recomenda-se não utilizá-las qualquer que seja o
propósito.
Programação Orientada a Objetos
Desta forma para declararmos uma variável devemos seguir a seguinte sintaxe:
int i;
float total, preco;
byte mascara;
double valorMedio;
Também é possível definirmos um valor inicial para uma variável diretamente em sua
declaração:
int quantidade = 0;
float angulo = 1.57;
boolean ok = false;
char letra = ‘c’;
// HelloWorld.java
public class HelloWorld {
public static void main (String args[]) {
System.out.println("Hello World!");
}
}
Se você se tiver digitado tudo ao envés de usar “copy and paste”, é bem provável que
ele não compile, se isto ocorrer, leia atentamente o programa. Você não esqueceu nenhum
ponto e vírgula? E as chaves? HelloWorld começa com letra maiúscula, e isso faz diferença,
você foi coerente com a convenção adotada de letras maiúsculas e minúsculas para seus
identificadores?
Você estava no mesmo diretório de HelloWorld.java quando chamou o compilador? E
quando chamou o interpretador, também?
Se ainda não der certo, não se desespere, leia as explicações passo a passo do
programa e depois recorra a um usuário mais experiente. Normalmente a Java é muito fácil de
Programação Orientada a Objetos
se programar, e você precisará de pouca ajuda, o seu interesse o fará cada vez mais familiar
com esta linguagem.
// HelloWorld.java
Comentários em Java seguem a mesma sintaxe de C++, “//” inicia uma linha de
comentário, todo o restante da linha é ignorado. Existe também um outro tipo de comentário
formado por /* Insira aqui o texto a ser ignorado */ , este tipo de comentário pode ser
intercalado em uma linha de código. Comentários são tratados como espaços em branco.
{ }
“Abre chaves” e “fecha chaves”. Para quem não conhece C ou C++, eles podem ser
entendidos como algo semelhante ao BEGIN-END de Pascal ou Modula-3, ou seja: delimitam
um bloco de código. Os programadores Pascal notarão que variáveis locais dos métodos
podem ser declaradas em qualquer local entre as chaves. Mas por motivos de clareza do
código declararemos todas no início do bloco.
System.out.println("Hello World!");
Chamada do método println para o atributo out da classe ou objeto System, o
Programação Orientada a Objetos
argumento é uma constante do tipo String. println assim como writeln de Pascal, imprime a
String e posiciona o cursor na linha abaixo , analogamente print não avança linha. Por hora
você pode guardar esta linha de código como o comando para imprimir mensagens na tela,
onde o argumento que vem entre aspas é a String a ser impressa. O ; “ponto e vírgula” separa
operações.
}
Finalmente o fecha chaves termina com a declaração da classe HelloWorld.
Conclusão
Normalmente o volume de conceitos presentes num primeiro programa de uma
linguagem orientada a objetos como Java é grande se comparado com o de um primeiro
programa em C ou Pascal. Esses conceitos ainda serão aprofundados e são citados aqui apenas
por curiosidade, é normal que você não tenha entendido tudo.
Exercícios:
1- Experimente fazer modificações no programa HelloWorld. Imprima outras
mensagens na tela, adicione comentários.
2- A Linguagem Java
2.1- Comentários
Comentários são trechos de texto, usualmente explicativos, inseridos no programa de
forma que não sejam considerados como parte do código, ou seja, são informações deixadas
juntamente com o código como informação para quem programa.
O Java aceita três tipos de comentários:
➢ de uma linha
➢ de múltiplas linhas
➢ de documentação
O primeiro, de uma linha, utiliza duas barras (//) para marcar seu início:
/* comentário
de múltiplas linhas */
2.2- Constantes
Quando uma variável (atributo) é declarada como final, seu conteúdo não poderá ser
modificado (é uma constante). Veja o exemplo:
Todas as regras para a declaração de variáveis são também válidas para a declaração
de constantes.
Apesar de String não ser um tipo primitivo, ele pode ser visto como um, pois pode ser
construído diretamente, sem o uso de new, como está descrito no exemplo a seguir:
Programação Orientada a Objetos
2.4- Operadores
<< op1 << op2 desloca os bits de op1 para a esquerda de uma distância op2
>>> op1>>>op2 desloca os bits de op1 para a direita de uma distância op2 (sem
sinal)
& op1 & op2 e de bits
| op1 | op2 ou de bits
^ op1 ^ op2 ou exclusivo de bits
~ ~op2 complemento de bits
2.5- Modificadores
Os modificadores (ou qualificadores) de visibilidade indicam o nível de acesso ao
método ou atributo. Na tabela a seguir, temos todos os níveis possíveis e suas visibilidades:
Modificador Visibilidade
Private Somente dentro da classe
Sem modificador Em todas as classes do mesmo pacote
Protected Em todas as classes do mesmo pacote e em subclasses
Public Todas as classes
➢ Saída
Normalmente, em programação, quando nos referimos à saída de dados estamos
particularmente interessados em exibir mensagens no monitor do computador. Java possui
alguns comandos para saída de dados, dentre eles, destacamos apenas três:
System.out.println(“Olá Mundo!!!”);
Este comando mostra a mensagem delimitada entre as aspas no monitor e salta para
a próxima linha para que uma nova saída não apareça na mesma linha.
System.out.print(“UNESA”);
Este comando exerce, essencialmente, a mesma função do anterior, porém, ele não
salta para a próxima linha, ou seja, um novo comando exibirá um novo texto na mesma linha.
System.out.printf(“AV1=%d”,nota);
Este comando permite um maior poder de formatação da saída. Aqui pode-se utilizar
todos os recursos de formatação existente na linguagem C.
➢ Entrada
Java se popularizou essencialmente pela programação voltada à Internet e ao
ambiente gráfico. Esta característica fez com que suas primeiras versões fossem deficientes
nas operações de entrada de dados em modo texto. Nos primórdios desta linguagem, se
utilizava a entrada de dados por parâmetros (String args[]), porém as versões mais
recentes contornaram o problema e já é possível efetuar a entrada de dados de forma
razoavelmente simples. Veja um exemplo de programa que obtém dois números inteiros do
teclado e exibe a soma deles.
import java.util.Scanner;
public class Adicao {
public static void main(String args[]) {
int n1,n2,soma;
soma=n1+n2;
System.out.println(“A soma é ”+soma);
}
}
O exemplo acima mostra como pode ser efetuada a entrada de números inteiros, para
outros tipos de dados, basta alterar/adaptar o método input.next???(), para cada tipo de
dado.
Tipo Método
int input.nextInt()
String input.next()
float input.nextFloat()
double input.nextDouble()
char Input.nextChar()
{
diretiva1;
diretiva2;
.
.
.
diretivaN;
}
Programação Orientada a Objetos
if (expressão_lógica)
{ comando1;
} else {
comando2;
}
//exemploIf.java
import java.io.*;
Ao executar-se este programa podem ocorrer duas situações distintas como resultado:
se for fornecido algum argumento na linha de comando (args.length > 0), o programa exibirá
tal argumento. Caso não seja passado nenhum argumento, o programa exibirá a mensagem
alertando o usuário.
Programação Orientada a Objetos
switch(expressão_ordinal)
case ordinal1: comando1;
break;
case ordinal2: comando2;
break;
default: comando_default;
}
Note que o ponto de início de execução é um caso (case) cujo valor ordinal é aquele
resultante da expressão avaliada. Após iniciada a execução do conjunto de comandos
identificados por um certo caso, tais ações só são interrompidas com a execução de um
comando break ou com o final do comando switch.
A seguir temos uma aplicação simples que exemplifica a utilização dos comandos
switch e break.
//exemploSwitch.java
import java.io.*;
public class exemploSwitch {
public static void main (String args []) {
if (args.length > 0) {
switch(args[0].charAt(0)) {
case ‘a’:
case ‘A’: System.out.println(“Vogal A”);
Programação Orientada a Objetos
break;
case ‘e’:
case ‘E’: System.out.println(“Vogal E”);
break;
case ‘i’:
case ’I’: System.out.println(“Vogal I”);
break;
case ‘o’:
case ‘O’: System.out.println(“Vogal O”);
break;
case ‘u’:
case ’U’: System.out.println(“Vogal U”);
break;
default: System.out.println(“Arg Inválido”);
}
} else {
System.out.println(“Não foi fornecido argumento!”);
}
}
}
Exercícios:
BASE x ALTURA
AREA=
2
4- Escreva um programa que leia duas variáveis inteiras e troque o conteúdo entre
elas.
5- Escreva um programa para ler uma temperatura dada na escala Fahrenheit e exibir
o equivalente em Celsius.
5
C= x F −32
9
6- Escreva um programa para calcular e exibir o valor de xy, sendo dados a base(x) e
o expoente (y).
Exercícios Teóricos
O for possui três campos ou seções, todas opcionais, delimitamos por um par de
parênteses que efetuam o controle de repetição de um comando individual ou de um bloco de
comandos. Cada campo é separado um do outro por um ponto e vírgula. O primeiro campo é
usado para dar valor inicial a uma variável de controle (um contador). O segundo campo é um
expressão lógica que determina a execução ou não do(s) comando(s) associado(s) ao for. O
terceiro campo realiza uma operação sobre a variável de controle, geralmente incrementando
ou decrementando a variável.
// exemploFor.java
import java.io.*;
public class exemploFor {
public static void main (String args[]) {
int j;
Programação Orientada a Objetos
while (expressão_lógica)
{ comando ou lista de comandos
}
do
comando ou lista de comandos
while (expressão_lógica);
Programação Orientada a Objetos
//exemploWhile.java
import java.io.*;
public class exemploWhile {
public static void main (String args[]) {
int j = 0;
while (j > Integer.parseInt(args[0])) {
System.out.println(“ “+ j);
j--;
}
}
}
//exemploDoWhile.java
import java.io.*;
public class exemploDoWhile {
public static void main (String args []) {
int min = Integer.parseInt(args[0]);
int max = Integer.parseInt(args[1]);
do {
System.out.println(“ “ + min + “ < “ + max);
min++; max—;
} while (min < max);
System.out.println(“ “ + min + “ > “ + max);
}
}
Exercícios
1- Faça um programa em Java mostre todos os números inteiros pares de 2 a 100.
3- Faça um programa em Java que leia um número N, some todos os números inteiros
de 1 a N, e mostre o resultado obtido.
4- Faça um programa em Java que leia N e uma lista de N números e mostre a soma
de todos os números lidos.
Exercícios Teóricos
1- Escreva um programa em Java que leia um conjunto de números inteiros positivos
e determine o maior deles. A leitura do valor 0 (zero) indica o fim da entrada dos dados.
try {
comando_normal;
} catch (exception1) {
rotina_de_tratamento_de_erro1;
} catch (exception2) {
rotina_de_tratamento_de_erro2;
}
//exemploIf2.java
import java.io.*;
public class exemploIf2 {
public static void main (String args[]) {
if (args.length > 0) {
try {
for(int j=0;j<Integer.parseInt(args[0]);j++){
System.out.println(“ “+ j +” “);
}
System.out.println(“\nFim da contagem”);
} catch (java.lang.NumberFormatException e) {
System.out.println(“Argumento inválido!”);
}
}
}
}
Programação Orientada a Objetos
try {
comando_normal;
} finally {
rotina_de_tratamento_de_erro;
}
Exercícios
1- Construa um programa em Java que leia 3 (três) números inteiros (N,X,Y) e mostre
todos os números de N entre X e Y.
2- Um número é, por definição, primo se ele não tem divisores, exceto 1 e ele próprio.
Escreva um programa em Java que leia um número inteiro e determine se ele é ou não primo.
3- Classes e Objetos
Os qualificadores de acesso indicam como a classe pode ser utilizada por outras
classes e, consequentemente, outras aplicações. Existem dois especificadores de acesso
básicos:
Qualificador Significado
Indica que o conteúdo público da classe pode ser utilizado livremente por outras
Public
classes.
Indica que o conteúdo público da classe pode ser utilizado livremente por outras
Package
classes do mesmo pacote.
3.1.1- Atributos
O atributo é um elemento da classe que pode representar uma característica dos
objetos instanciados ou valores de controle da classe. A representação básica de um atributo
consiste em seu identificador e seu tipo.
A sintaxe para se criar atributos é idêntica à criação das variáveis, com a exceção de
se ter que definir o qualificador de acesso do atributo. Veja alguns exemplos:
3.1.2- Métodos
Um método se refere a um comportamento ou uma ação que pode ser executada
sobre o objeto. Os métodos alteram o estado do objeto, ou seja, alteram os conteúdos das
variáveis de instância. Os métodos também são bastante utilizados para que se possa
consultar os conteúdos das variáveis de instância, uma vez que, devido ao encapsulamento,
tais variáveis ficam inacessíveis fora da classe.
Uma outra característica interessante dos métodos é o fato de, naturalmente, se
implementar uma maior modularização do programa, uma vez que o desenvolvedor observa os
comportamentos dos objetos de forma separada e sequencial (um de cada vez), programando
cada comportamento num método individual.
A criação de um método deve seguir a seguinte sintaxe:
3.1.3- Encapsulamento
O Encapsulamento é uma característica muito interessante da POO, ela se resume ao
fato de se restringir o acesso a determinados elementos de uma determinada classe.
Normalmente os atributos de uma classe são definidos como private, ou seja, só
podem ser acessados diretamente dentro da própria classe. Isto é justificável, pois
normalmente os atributos são para controle interno do objeto ou cercados de controles
imperceptíveis aos usuários, mas importantíssimos para o correto funcionamento do objeto.
Imagine que o usuário pudesse especificar um mês como 13. (Ex.: dd/mm/aaaa –
24/13/2009)
Os métodos, pelo contrario, na maioria das vezes, são declarados como public, isso
se justifica pelo fato de que eles modelam os comportamentos dos objetos e é presumível que
o usuário deveria ter acesso as esses comportamentos. Vejamos o exemplo de um carro: Este
provavelmente terá os métodos Acelerar() e Frear() como públicos, porém, algum método
referente a uma ação interna do motor, por exemplo, GerarCentelha() poderá e deverá ser
definido como privado, uma vez que o usuário não tem a necessidade de acessar diretamente
este método.
Exercícios
1- Suponha uma classe em Java que implemente uma data. Pense em seus atributos e
métodos.
2- Implemente a classe Data, idealizada acima, em Java. Implemente apenas os
métodos setDia(int), setMes(int), setAno(int), int getDia(), int getMes() e
int::getAno().
3- Construa um programa em Java para testar a classe Data.
4- Construa os seguintes métodos: String NomeMes(), int Bissexto(), int
DiasMes() e String getData().
5- Construa o método para incrementar ou decrementar algum dos atributos da data.
O método Incr(int,int,int) deverá funcionar de acordo com os exemplos:
Parâmetros (1,0,0): incrementa o dia em 1;
Parâmetros (0,2,0): incrementa o mês em 2;
Parâmetros (0,0,-1): decrementa o ano em 1;
Obs.: O método fará apenas uma ação por vez.
6- Pelo conceito de encapsulamento, devemos proteger os atributos de modo que eles
não assumam valores incoerentes. No exercício número 2, as atribuições aos atributos da data
são implementadas de forma independente. Isto pode gerar inconsistências. Uma maneira de
corrigir este problema é excluir as implementações dos métodos setDia(int), setMes(int)e
setAno(int) e implementar o método setData(int,int,int). Este método receberá os três
atributos ao mesmo tempo e validará ou não a data.
3.1.4.1- Construtores
Exercícios
1- Construa a classe Contador. Esta classe deverá manter um valor inteiro. Este valor
poderá ser incrementado pelo acionamento do método incr(), e poderá ser decrementado
pelo acionamento do método decr(). Para simplificar o execício estes métodos somente
alterarão o estado do contador em uma unidade. Implemente também o método getCont(),
para obter o valor atual do contador e o método Mostrar(), que exibirá o valor atual do
contador.
Programação Orientada a Objetos
Note que o que caracteriza o construtor é ter o mesmo nome da classe, já o destrutor
é caracterizado por possuir o nome finalize. Você pode chamar o destrutor, mas isso não
implica que o objeto será deletado. Ao contrário dos construtores, os destrutores não tem
argumentos, mas possuem valor de retorno que é igual a void.
Os destrutores são muito úteis para "limpar a casa" quando um objeto deixa de ser
usado. Um exemplo bastante comum do uso de destrutores é o de um objeto que lida com
arquivos que devem ser fechados quando o objeto for destruído. Existem outros casos onde
um objeto deve comunicar aos outros objetos que será inutilizado, destruído, ou seja, sairá do
programa.
Em Java, que possui coleta automática de lixo, um objeto passa a não existir mais
no programa quando nenhuma variável faz referência a ele. Nesse ponto, ele é armazenado no
coletor automático de lixo, onde receberá o tratamento adequado. Um nó de uma lista ligada
pode ser apagado simplesmente fazendo o nó anterior apontar para o posterior a ele. Os
programadores não acostumados com esse conceito precisam ouvir a seguinte frase: "Você
não é obrigado a liberar explicitamente a memória de um objeto como é feito em C++ e
outras linguagens".
Se estivéssemos por exemplo em C++, que não possui coleta automática de lixo, o
destrutor seria chamado sempre que a memória de um objeto fosse desalocada, o que é feito
pelo programador através de uma chamada a delete.nomedoobjeto();.
Em Java a liberação de memória que é feita pelo coletor automático de lixo que é
executado de modo assíncrono com o restante do programa, ou seja, você não pode contar
com o fato de que o destrutor será chamado imediatamente após o momento em que seu
objeto sai de escopo, a não ser que o programa seja executado com o modo assíncrono do
coletor automático de lixo desligado (java -noasyncgc NomePrograma).
argumentos e tem, portanto, uma assinatura diferente. Um método que não recebe
argumentos tem como assinatura o tipo void enquanto um outro método que recebe dois
inteiros como argumentos tem como assinatura os tipos int, int como no exemplo abaixo:
// Calculo.java
public class Calculo {
public long dobro (int x) {
return 2*(long)x;
}
// Sobrecarga.java
public class Sobrecarga {
public long Somatorio (int max) {
int total = 0;
for (int i = 1; i < max; i++)
{ total += i; }
return total;
}
public long Somatorio (int max, int incr) {
int total = 0;
for (int i = 1; i < max; i += incr)
{ total += i; }
return total;
}
}
No exemplo acima temos o método Somatorio() que efetua a soma dos primeiros max
números naturais ou efetua a soma dos primeiros max números naturais espaçados de incr e
que a seleção de um método ou outro se dá pela diferença de argumentos utilizados pelo
método Somatorio().
A API do Java utiliza intensivamente o mecanismo de sobrecarga, por exemplo, a
classe java.lang.String onde o método indexOf possui várias implementações. O método
indexOf se destina a localizar algo dentro de uma string, isto é, determinar a posição (índice)
de um caracter ou substring, o que caracteriza diferentes possibilidades para seu uso,
conforme a tabela a seguir:
Programação Orientada a Objetos
Método Descrição
Retorna a posição, dentro da string, da primeira ocorrência do caracter
IndexOf(int)
especificado.
Retorna a posição, dentro da string, da primeira ocorrência do caracter
IndexOf(int, int)
especificado a partir da posição dada.
Retorna a posição, dentro da string, da primeira ocorrência da substring
IndexOf(String)
especificada.
Retorna a posição, dentro da string, da primeira ocorrência da substring
IndexOf(String,int)
especificada a partir da posição dada.
Desta forma, fica transparente para o usuário da classe a existência destes quatro
métodos, ao mesmo tempo ficam disponíveis tais alternativas para localização de caracteres
simples ou substrings dentro de strings.
Numa classe onde são implementados vários métodos com o mesmo nome fica a
cargo do compilador determinar qual o método apropriado em função da lista de argumentos
indicada pelo método efetivamente utilizado (dynamic binding).
Um outro ponto importante é que Java não fornece recursos para sobrecarga de
operadores tal como existe na linguagem C++. Apesar disto ser um aspecto restritivo da
linguagem, é perfeitamente condizente com a filosofia que orientou o desenvolvimento desta
linguagem que foi criada para ser pequena, simples, segura de se programar e de se usar. A
ausência de mecanismos para definir a sobrecarga de operadores pode ser contornada através
da definição e implementação apropriada de classes e métodos.
javac SobrecargaTest.java
SobrecargaTest.java:4: Wrong number of arguments in constructor.
Sobrecarga s = new Sobrecarga(false);
Java oferece um construtor default para cada classe o qual não precisa ser declarado e
implementado. Este construtor, que não recebe parâmetros, mesmo quando implementado, é
denominado construtor default. Quando sobrecarregamos o construtor de uma classe, tal como
faríamos com qualquer outro método, criamos construtores denominados construtores cópia
(copy constructor). A seguir um exemplo de uma classe contendo três diferentes construtores
(construtor default e dois construtores cópia):
// Sobracarga2.java
public class Sobracarga2 {
public int prim,sec;
//Construtores
public Sobracarga2() {
prim = sec = 0;
}
public Sobracarga2(int p) {
prim = p;
sec = 0;
}
public Sobracarga2(int p, int s) {
prim = p;
sec = s;
}
}
Programação Orientada a Objetos
A classe Sobracarga2 possui dois atributos inteiros prim e sec que são inicializados
com valor zero através do construtor default. Para que o atributo prim seja inicializado com
outro valor podemos utilizar o construtor cópia que recebe um parâmetro inteiro. Para que
tanto a atributo prim como sec sejam inicializados diferentemente dispõe-se ainda de um
segundo construtor cópia.
O uso de construtores sobrecarregados é bastante conveniente pois possibilita reduzir
o código que deve ser escrito para utilização de um objeto como nos trechos de código abaixo:
Construtor Descrição
String() Cria uma nova string se conteúdo
Cria uma nova string convertendo o conteúdo do vetor de bytes
String(byte[])
especificado
Cria uma nova string convertendo o conteúdo do vetor de char
String(char[])
especificado
Cria uma nova string contendo a mesma seqüência de caracteres
String(String)
da string especificada
Cria uma nova string contendo a mesma seqüência de caracteres
String(StringBuffer)
do objeto StringBuffer especificado
Exercícios Teóricos
1- Faça uma classe Conta (Conta Corrente) que contenha o nome e o salário do
cliente, o número da conta, o saldo e o limite. O saldo inicial deve ser zero e o limite de crédito
(cheque especial) não poderá ser maior que o valor do salário mensal do cliente. Faça um
método deposito() e um método saque(). O método saque() irá devolver true ou false,
dependendo se o cliente pode ou não realizar a retirada. Faça um método GetSaldo() que
retorne o saldo do cliente.
2- Repita o exercício anterior utilizando a sobrecarga de construtores.
Programação Orientada a Objetos
3.2.3- Herança
A herança (inheritance) é o segundo e mais importante mecanismo do polimorfismo e
pode ser entendido de diversas formas das quais, a mais simples é: uma técnica onde uma
classe passa utilizar atributos e operações definidas em uma classe especificada como seu
ancestral. Rigorosamente falando, a herança é o compartilhamento de atributos e operações
entre classes baseado num relacionamento hierárquico do tipo pai e filho, ou seja, a classe pai
contém definições que podem ser utilizadas nas classes definidas como filho. A classe pai é o
que se denomina classe base (base class) ou superclasse (superclass) e as classes filho são
chamadas de classes derivadas (derived class) ou subclasses (subclass). Este mecanismo
sugere que uma classe poderia ser definida em termos mais genéricos ou amplos e depois
refinada sucessivamente em uma ou mais subclasses específicas. Daí a origem do termo
técnico que descreve a herança: especialização (specialization).
Em Java indicamos que uma classe é derivada de uma outra classe utilizando a
palavra reservada extends conforme o trecho simplificado de código dado a seguir: A
superclasse não recebe qualquer indicação especial.
// SuperClass.java
public class SuperClass {
.
.
.
}
// SubClass.java
public class SubClass extends SuperClass {
.
.
.
}
Em princípio, todos atributos e operações definidos para certa classe base são
aplicáveis para seus descendentes que, por sua vez, não podem omitir ou suprimir tais
características, pois não seriam verdadeiros descendentes se fizessem isto. Por outro lado,
uma subclasse pode modificar a implementação de alguma operação (reimplementar) por
questões de eficiência sem modificar a interface externa da classe. Além disso as subclasses
podem adicionar novos métodos e atributos não existentes na classe base, criando uma versão
mais específica da classe base, isto é, especializando-a. Na figura abaixo temos um exemplo
de hierarquia de classes onde são indicados os atributos e operações adicionados em cada
classe. Note que os atributos e operações adicionados não são indicados explicitamente na
classe derivada, mas implicitamente pela relação de herança.
Programação Orientada a Objetos
Exercícios
1- Construa uma classe Ponto. Esta classe deve especificar as coordenadas de um
ponto e as operações que podem ser realizadas sobre ponto. Implemente o construtor da
classe.
2- Construa uma classe Pixel. Esta classe deve herdar tudo que a classe Ponto possui
e acrescentar o atributo cor. Implemente o construtor desta classe.
3- Construa a classe ContaE. Esta classe deverá ser herdeira da classe Conta. A
diferença entre as classes é que na ContaE o limite de saque será de 3 vezes o valor do
salário.
Programação Orientada a Objetos
4- Applet
Applets são pequenos programas escritos em Java que podem ser embutidos em
documentos hipertextos. Este programa será executado (interpretado) por um browser (um
navegador Web) quando for carregada a página que contém tal applet. Desta forma uma
applet é um programa Java destinado a ser utilizado pelos browser´s significando que será
transportada pela Internet tal como documentos HTML, imagens GIF e JPEG e outros
conteúdos típicos da rede.
Em função deste uso, as applet´s usualmente são construídas para serem pequenos
programas e, por questões de segurança, obedecem critérios rígidos para que sua execução
seja possível pelos browser´s.
Outro aspecto é que as applet´s são programas executados nos ambientes gráficos
das diversas plataformas que utilizam a Web, assim sua construção é bastante semelhante a
criação de programas que utilizem componentes ou recursos gráficos disponíveis na AWT.
Abaixo, um pequeno exemplo de applet e seu resultado quando executado num browser.
import java.awt.*;
import java.applet.*;
<html>
<head>
<title>Testando Applets</title>
</head>
<body>
<applet
code="PMPWelcome.class"
width=200
height=150>
</applet>
</body>
</html>
Programação Orientada a Objetos
Campo Descrição
ARCHIVE Nome do arquivo compactado da applet (Java Archive – arquivo .jar)
ALT Nome alternativo.
ALIGN Alinhamento da applet (valores possíveis são: top, midle, bottom, left e right
CODE Nome do arquivo de classe Java incluindo a extensão .class.
CODEBASE URI base para os arquivos de classe Java.
HEIGHT Altura da applet (em pixels).
HSPACE Margem horizontal (em pixels).
NAME Nome da applet para comunicação inter-applet.
VSPACE Margem vertical (em pixels).
WIDTH Largura da applet (em pixels).
É necessário utilizar o campo CODE para especificar a applet (programa Java) que deve
ser executada. O campo ARCHIVE é usado caso a applet esteja inserida num arquivo
compactado tipo JAR. O campo CODEBASE indica o local onde os arquivos “.class” ou “.jar”
estão localizados. Os demais campos referem-se a disposição da applet na página HTML. A
forma mais freqüente de uso desta tag é como exemplificado, ou seja, especificando-se a
applet através do campo CODE e seu tamanho através dos campos HEIGHT e WIDTH.
A tag <applet> é uma tag dupla, portanto finalizada por </applet>. Em seu corpo,
isto é, no interior da construção <applet></applet> podemos inserir outra tag, <param>,
destinada a parametrização da applet, o que será visto mais adiante.
A programação e compilação de applet´s é uma tarefa idêntica a criação de
programas em Java: utiliza-se um editor de textos comum e depois o compilador javac para
realizar a compilação do programa nos byte-codes correspondentes, (.class). Novamente o
nome do arquivo deve ser idêntico ao da classe pública nele contido.
No entanto o teste das applet´s produzidas não pode ser feito através do
interpretador java e sim, através de um browser compatível com Java ou através do aplicativo
appletviewer fornecido juntamente com as demais ferramentas do JDK. O appletviewer
executa applet´s que estejam inseridas em arquivos HTML, por exemplo:
appletviewer Applet1.html
Não existe a necessidade do arquivo HTML possuir o mesmo nome que a applet ou sua
classe. Outra facilidade é que o arquivo HTML pode conter apenas a tag <applet>, embora
consiga tratar arquivos HTML complexos. Assim o uso do appletviewer é mais conveniente
durante a fase de desenvolvimento e teste das applets.
➢ instanciação (create)
➢ inicialização (init)
➢ início (start)
➢ execução e renderização (paint e outros métodos)
➢ parada (stop)
➢ finalização ou destruição (destroy)
Este modo de funcionamento define o ciclo de vida das applet´s, que é esquematizado
na figura abaixo. Implementações mínimas de applet´s utilizam geralmente o método init()
ou o método paint().
stop(). O método start() é acionado pela primeira vez logo após a execução do método
init(), sendo novamente acionado tantas vezes quantas a applet tornar-se visível.
//AppletMetodos.java
import java.awt.*;
import java.applet.*;
Veja o que acontece quando se executa a applet pela primeira vez, e na seqüência,
veja o que acontece a cada minimização e maximização da applet.
import java.awt.*;
import java.applet.*;
public class ExibeTexto extends Applet {
public void paint(Graphics g) {
g.drawString("Alo mundo!",25,25);
}
}
g.drawString("Alo mundo!",25,25);
instrui o Java a chamar o método drawString() do objeto.
// Entrada.java
import java.awt.*;
import java.applet.*;
public class Entrada extends Applet {
TextField campo;
public void init() {
campo = new TextField(20);
add(campo);
}
}
TextField campo;
Observe que o objeto campo é declarado da mesma forma que se declararia qualquer
outro tipo de objeto.
Outra diferença entre Entrada e ExibeTexto é que a primeira possui um método
init() ao invés de paint(). O método init() é mais um daqueles métodos que o Java
chama automaticamente, ou seja, podemos utilizá-lo para montar a applet, pois este é um dos
primeiros métodos a serem acionados pelo controlador de eventos do Java.
Quando init() é chamado, campo já foi declarado como um objeto da classe
TextField, porém ainda não lhe foi atribuído nenhum valor. A primeira linha de código em
init() cria um objeto TextField e o atribui a campo da seguinte forma:
add(campo);
O argumento único do método add() é o controle que você quer acrescentar à applet.
//RecuperaTexto.java
import java.awt.*;
import java.applet.*;
public class RecuperaTexto extends Applet {
TextField campo;
public void init() {
campo = new TextField(20);
add(campo);
}
public void paint(Graphics g) {
String s = campo.getText();
g.drawString(s,40,50);
}
public boolean action(Event event, Object arg) {
repaint();
return true;
}
}
Quando você rodar esta applet, digite algum texto no controle TextField e pressione
ENTER. Este evento irá acionar o método action() que forçará que a applet seja “repintada” e
consequentemente o texto digitado na caixa de texto será escrito no corpo da applet.
String s = campo.getText();
Esta linha declara um atributo chamado s como sendo um objeto da classe String e
então estabelece uma igualdade com a string do controle. Pode ser visto nesta linha que o
método getText() do objeto campo está sendo chamado. Este método simplesmente retorna a
string que está armazenada no controle TextField.
Exibir a string é tão fácil como chamar seu velho amigo drawString(), como segue:
g.drawString(s,40,50);
//ExValNum.java
import java.awt.*;
import java.applet.*;
public class ExValNum extends Applet {
public void paint(Graphics g) {
int x = 10;
String s = String.valueOf(x);
g.drawString(s,40,50);
}
}
Como pode ser visto no código da applet, a classe String possui um método chamado
valueOf() que pode converter valores numéricos em string´s. O único argumento do método
é o valor que se deseja converter, que pode ser qualquer um dos tipos de dados numéricos de
Java.
Exercícios
1- Construa uma Applet que obtenha dois números inteiros através de duas caixas de
texto. Após pressionar a tecla ENTER, o programa deverá exibir a soma dos números.
2- Construa uma Applet que obtenha um número inteiro através de uma caixa de
texto e mostre os seus divisores.
3- Construa uma Applet que obtenha um número inteiro através de uma caixa de
texto e mostre o número é ou não primo.
Rótulos
Os rótulos são os mais simples dos controles de Java e nada mais são que string´s de
texto que você pode colocar em qualquer posição da área de exibição de uma applet. Um
rótulo é criado chamando-se o construtor da classe Label, como segue:
O construtor da classe Label possui dois argumentos: o texto para ser exibido e um
valor de alinhamento. O valor de alinhamento pode ser Label.LEFT, Label.CENTER ou
Label.RIGTH. Após criar o rótulo, você deve adicioná-lo à applet utilizando o método add()
como segue:
add(label)
Criando um Rótulo
Suponha que você queira um label centralizado que exiba o texto “Java is hot!”. Para
fazer isto, digite o programa a seguir:
// Rotulo.java
import java.awt.*;
import java.applet.*;
public class Rotulo extends Applet {
Label rotulo;
public void init() {
rotulo = new Label(“Java is hot!”, Label.CENTER);
add(rotulo);
}
}
Uma aspecto interessante a respeito dos rótulos é que eles guardam automaticamente
seus alinhamentos quando o tamanho da área de exibição de uma applet se modifica. As
figuras a seguir mostram o resultado desta applet. A segunda figura foi redimensionada para
ilustrar o alinhamento automático do rótulo.
Programação Orientada a Objetos
Método Descrição
int getAlignment() Recupera a configuração de alinhamento do rótulo.
String getText() Recupera a string do rótulo.
SetAlignment(int align) Configura o alinhamento do rótulo.
void setText(String label) Configura a string do rótulo.
Obs.: Os textos dos rótulos são exibidos com a fonte atualmente em uso. É possível
criar rótulos com fontes distintas desde que se crie e configure a fonte antes de criar o rótulo.
Botões
Os botões são uma excelente forma de disparar eventos em applet´s, pois eles são
fáceis de criar e gerenciar e, mais importante ainda, são simples em termos de utilização pelo
usuário. Para criar um botão, você deve fazer o seguinte:
String button.getLabel()
button.setLabel(str)
Se esta instrução if for true, foi um botão que gerou o evento. Para determinar
exatamente qual botão causou o evento, examinamos o parâmetro arg, como segue:
if (arg == str)
//Botoes.java
import java.awt.*;
import java.applet.*;
public class Botoes extends Applet
{ Button button1, button2, button3;
A applet Botoes exibe três botões em sua área de exibição, como apresentado na
figura abaixo. Toda vez que um botão é clicado com rótulo normal, seu respectivo rótulo é
invertido como mostra a segunda figura.
Exercícios
1- Crie uma applet que coloque em sua área de exibição um label, duas caixas de
texto, quatro botões e mais um label. O primeiro label deverá dar uma breve descrição do que
o programa faz. As duas caixas de texto servirão para receber do usuário dois valores inteiros.
Cada um dos botões representará cada uma das operações básicas da matemática (+, -, / e
*). O último label servirá para apresentação do resultado, ou seja, o programa servirá como
uma calculadora.
2- Crie uma applet que coloque em sua área de exibição um label, uma caixa de texto,
três botões e mais um label. O primeiro label deverá dar uma breve descrição do que o
programa faz. A caixa de texto servirá para receber do usuário um valor inteiro. Cada um dos
botões representará uma operação e o último label servirá para exibir os resultados. O botão
“Divisores” deverá exibir os divisores do número. O botão “Qtd Divisores” deverá exibir a
quantidade de divisores do número e o botão “Primo” deverá exibir a mensagem de que o
número é ou não primo.
➢ teclado
➢ mouse
5.1- Teclado
Existem apenas dois eventos que podem provir do teclado: keyDown e keyUp.
Este método é chamado quando alguma tecla for pressionada. keyCode armazena o
código ASCII correspondente à tecla pressionada. Como existem teclados sem padronização,
existem determinados códigos especiais para designar algumas teclas:
A informação de que a tecla shift, control e alt foi pressionada é obtida do parâmetro
evento recebido, usando método correspondente. Todos eles retornam um dado boolean
indicando a situação da respectiva tecla. Suponha que o nome do parâmetro de evento (do
tipo Event) é evento. Então temos
//EventosTeclado.java
import java.awt.*;
import java.applet.*;
public class EventosTeclado extends Applet
{ TextField texto;
Label tecla;
public void init()
{ texto = new TextField(20);
add(texto);
tecla = new Label("Tecla", Label.CENTER);
add(tecla);
}
public boolean keyDown(Event evento, int keyCode)
Programação Orientada a Objetos
{ tecla.setText(String.valueOf(keyCode));
return true;
}
}
Para que os eventos do teclado ocorram, eles devem ser estimulados a partir de
algum componente da applet, é justamente para isto que foi incluído no exemplo acima o
componente TextField. Para a executar corretamente o exemplo você deve startar a applet e
logo após clicar na caixa de texto, aí então pode-se começar a pressionar as teclas para ver os
resultados. Veja o que acontece quando a barra de espaço é pressionada.
5.2- Mouse
Os métodos associados a eventos provenientes do mouse recebem dois parâmetros:
evento do tipo Event e coordenadas x e y da posição do ponteiro mouse (do tipo inteiro)
relativos às coordenadas da janela atual.
// EventosMouse.java
import java.awt.*;
import java.applet.*;
Veja o resultado:
Exercícios de Revisão
1-Descreva os três argumentos usados com o método drawString().
2-Descreva o funcionamento do método init().
3-Como um valor numérico pode ser convertido em String?
4-Implemente uma applet que obtenha do usuário o seu nome e sua idade. Logo após
a entrada dos dados o programa deverá mostrar o que foi digitado pelo usuário. Veja como
deve ficar a interface:
5-Implemente uma applet que obtenha do usuário três valores inteiros. A seguinte
expressão deverá ser resolvida: valor1 + valor2 / valor3. A applet deverá mostrar uma
interface parecida com a que segue:
6-Escreva uma applet que contenha dois rótulos e dois botões dispostos em duas
linhas. Cada linha deve começar com um rótulo seguido de um botão.
7-O que você por evento?
8-Explique o funcionamento do método mouseEnter().
9-Explique a utilização do método shiftDown().