Apostila de Java Básico

1
ÍNDICE
Capítulo I – Introdução ao Java............................................................................................................................4
1 – História...........................................................................................................................................................4
2 – Característica da Linguagem..........................................................................................................................4
2.1) Simples......................................................................................................................................................4
2.2) Orientada a Objeto....................................................................................................................................4
2.3) Distribuída.................................................................................................................................................4
2.4) Robusta......................................................................................................................................................4
2.5) Segura........................................................................................................................................................5
2.6) Neutra em Relação à Arquitetura..............................................................................................................5
2.7) Portável......................................................................................................................................................5
3 – Applets x Aplicativos......................................................................................................................................5
4 – Java SDK........................................................................................................................................................5
4.1) Versões da linguagem................................................................................................................................6
5 - Java API...........................................................................................................................................................6
6 – Ambientes de Desenvolvimento Integrado.....................................................................................................7
Exercícios de Revisão Capítulo I:.....................................................................................................................7
Capítulo II – Onde está instalado?........................................................................................................................8
1 - O SDK ........................................................................................................................................................8
Execute 1: Documentação....................................................................................................................................8
2 – O IDE..........................................................................................................................................................9
Execute 2: IDE JCreator.......................................................................................................................................9
Capítulo III – Primeiro Exemplo........................................................................................................................11
1 – Primeiro Exemplo: Bem Vindo a Hytec!..................................................................................................11
Execute 3: Digitando o primeiro exemplo..........................................................................................................11
Exercícios de Revisão Capítulo III:................................................................................................................13
Capítulo IV – Fundamentos...............................................................................................................................14
1 – Tipos Primitivos, Variáveis e Operadores.....................................................................................................14
1.1) Tipos primitivos.......................................................................................................................................14
1.2) Variáveis..................................................................................................................................................15
1.3) Operadores..............................................................................................................................................16
1.2.1) Operadores Aritméticos....................................................................................................................16
Execute 4: Exemplo de Operadores Aritméticos................................................................................................18
1.2.2) Operadores Relacionais....................................................................................................................19
Execute 5: Exemplo de Operadores Relacionais................................................................................................21
1.2.3) Operadores Lógicos..........................................................................................................................22
Execute 6: Exemplo de Operadores Lógicos......................................................................................................23
1.2.4) Manipulação de Strings....................................................................................................................24
Execute 7: Exemplo de String............................................................................................................................25
2 – Estruturas de Controle e seleção...................................................................................................................25
2.1) Estrutura de seleção.................................................................................................................................25
2.1.1) Declaração if – else (se – senão).....................................................................................................26
Execute 8: Exemplo de estrutura de seleção IF..................................................................................................27
2.1.2) Declaração Switch ...........................................................................................................................27
Execute 9: Exemplo de estrutura de seleção Switch..........................................................................................29
2.2) Estrutura de Controle .............................................................................................................................29
2.2.1) Declaração while..............................................................................................................................29
Execute 10: Exemplo de estrutura de controle while.........................................................................................30
2.2.2) Declaração do - while.......................................................................................................................31
Execute 11: Exemplo de Estrutura de Controle do{ }While..............................................................................32
2.2.3) Declaração For.................................................................................................................................33
SCRS 502 Bl. – C Ent. – 22º W2 Tel.: (61) 3225-7784

CEP - 70330-530 Brasília - DF
2
Execute 12: Exemplo de estrutura de controle FOR..........................................................................................34

2.3) Estrutura de Controle de Erros................................................................................................................35
Execute 13: Exemplo de estrutura de erro try..catch..........................................................................................36
Execute 14: Exemplo de estrutura de erro try..finally........................................................................................37
2.4) Vetores.....................................................................................................................................................38
Execute 15: Exemplo de utilização de Vetores...................................................................................................39
Exercícios de Revisão Capítulo IV:................................................................................................................39
Capítulo V – Programação Orientada a Objetos.................................................................................................41
1) Objetos e classes.........................................................................................................................................41
2) Atributos e comportamento........................................................................................................................42
3) Criando uma classe.....................................................................................................................................44
Execute : Exemplo de criação de classes............................................................................................................44
Execute : Exemplo de criação de classes............................................................................................................46
Execute 16: Exemplo de criação de classes........................................................................................................49
4) Criando novos objetos (também chamados de instâncias).........................................................................50
5) O que faz o operador new..........................................................................................................................50
6)Acessando e Definindo variáveis de classe e de instância..........................................................................51
7)Chamando métodos.....................................................................................................................................51
8)Criando classes............................................................................................................................................52
9)Criando Métodos.........................................................................................................................................52
10)A palavra-chave this e Super.....................................................................................................................53
10.1) This....................................................................................................................................................53
Execute 17: Exemplo de criação de classes e métodos......................................................................................53
Execute 18: Exemplo de criação de classes e métodos......................................................................................55
11) Acessibilidade...........................................................................................................................................56
12) Dicas para o projeto de classes.................................................................................................................56
13) Herança.....................................................................................................................................................57
Execute 19: Exemplo de criação de classes e métodos – Herança e Acessibilidade..........................................58
14) Classes Abstratas......................................................................................................................................60
15) Interface....................................................................................................................................................61
Exercícios de Revisão Capítulo V..................................................................................................................62
Capitulo VI – Aplicações Gráficas com a AWT.................................................................................................64
1) Introdução...................................................................................................................................................64
2) Construindo uma aplicação Gráfica...........................................................................................................64
3)Componentes básicos..................................................................................................................................65
4)Criando Janelas (Frames)............................................................................................................................66
Execute 20: Exemplo de criação de Janela usando componente Frame.............................................................66
6) Criando Rótulos (Labels)...........................................................................................................................70
Execute 23: Exemplo de criação de Label..........................................................................................................70
1)Criando Botões (Button).............................................................................................................................71
Execute 24: Exemplo de criação de Button........................................................................................................72
2)Criando caixa de entrada de texto (TextField)............................................................................................73
Execute 25: Exemplo de criação de Button........................................................................................................73
3)Criando Painéis (Panel)...............................................................................................................................75
Execute 26: Exemplo de criação de Panel..........................................................................................................75
4)Criando caixa de entrada multilinha ou memo (TextArea).........................................................................77
Execute 27: Exemplo de criação de TextArea....................................................................................................77
11) Criando caixa de lista (List).....................................................................................................................79
Execute 28: Exemplo de criação de List.............................................................................................................79
12) Criando caixa de seleção (Choice)...........................................................................................................81
Execute 29: Exemplo de criação de Choice.......................................................................................................81
3
13) Criando caixa de opção (Checkbox):.......................................................................................................83

Execute 30: Exemplo de criação de Checkbox...................................................................................................83
14) Criando Grupo de CheckBox (CheckboxGroup).....................................................................................85
Execute 31: Exemplo de criação de CheckboxGroup........................................................................................85
15) Criando Menus ........................................................................................................................................87
Execute 32: Exemplo de criação de Menus........................................................................................................89
Exercícios de Revisão do capitulo VI.............................................................................................................91
1) A diferença entre applets e aplicativos.......................................................................................................94
2) Criando applets...........................................................................................................................................94
3) Principais atividades do applet...................................................................................................................94
3.1) Incialização..........................................................................................................................................95
3.2) Partida..................................................................................................................................................95
3.3) Interrupção..........................................................................................................................................96
3.4) Destruição............................................................................................................................................96
3.5) Pintura.................................................................................................................................................96
Execute 33: Exemplo de criação de applets.......................................................................................................97
Execute 34: Exemplo de criação de applets.......................................................................................................99
Execute 35: Exemplo de criação de applets.....................................................................................................102
Exercícios de Revisão do capitulo VII.........................................................................................................103

4
Capítulo I – Introdução ao Java
1 – História
• 1991 “Grupo de Engenheiros da SUN queria desenvolver uma linguagem de
programação de dispositivos eletrônicos”: a princípio os engenheiros iniciaram o
projeto usando a linguagem C++, só que a sua complexidade e os possíveis erros
dessa linguagem impossibilitaram o desenvolvimento do projeto. Portanto os
engenheiros partiram para criação de uma linguagem que usasse o que o C++ tem de
melhor e eliminando os aspectos que tornavam uma linguagem difícil. O nome do
projeto era “Green”. O nome original “Oak” depois rebatizado Java. Nessa época
ninguém queria comprar a tecnologia do projeto.
• 1994 Crescimento da WWW: foi criado um navegador WEB que podia executar
applets Java.
• 1995 Netscape: Netscape tornou-se a primeira empresa a licenciar o Java, lançando a
JavaSoft que organizou e estruturou o Java para executar em seu navegador,
possibilitando uma decolagem do Java no mundo.
2 – Característica da Linguagem
2.1) Simples
Mesmo sendo estruturada com base no c++, a linguagem omite os maiores problemas da
linguagem C++ que são os ponteiros, sobrecarga de operadores, herança múltiplas que
são as maiores dores de cabeça para os iniciantes.
2.2) Orientada a Objeto

A portabilidade é uma das maiores características alcançadas pelo Java, pois é uma das
grandes vantagens de usar uma linguagem orientada a objeto. Java suporta herança, mas
não herança múltipla. A ausência de herança múltipla pode ser compensada pelo uso de
herança e interface, onde uma classe herda o comportamento de sua superclasse e
implementa várias interfaces.
2.3) Distribuída
Pronta para a Internet por possuir uma biblioteca extensa para lidar com TCP/IP, como
HTTP e FTP. Os aplicativos Java podem acessar uma URL´s (páginas Internet) como
estivesse usando um arquivo no sistema local.
2.4) Robusta
Em Java os programas são escritos de forma confiáveis tentando evitar possíveis erros de
implementação. Java coloca ênfase na verificação antecipada de possíveis erros, na

5
verificação dinâmica (em tempo de execução) e na eliminação de situações sujeitas a

erros.
2.5) Segura
A coleta de lixo é a grande arma do Java, pois aqueles erros de acesso à memória que
bem evidenciados pelos programadores quando usam C++ são corrigidos pelos coletores
de lixo que coletam esses lixos automaticamente. A eliminação do uso de ponteiros (que é
o responsável principal pelos lixos deixados pelos programadores quando não usados de
forma correta), portanto é favorável ao uso de vetores e outras estruturas substitutivas
trazendo benefícios de segurança.
2.6) Neutra em Relação à Arquitetura

O compilador gera um arquivo objeto neutro em relação à arquitetura. O código compilado
é executado em muitos processadores desde que exista uma máquina virtual. Os códigos
(bytecodes) são interpretados pela máquina virtual em qualquer máquina e convertida
facilmente para código nativo na máquina em tempo real.
2.7) Portável
Java foi criada para ser portável. O bytecodes gerado pelo compilador pode ser
transportado para plataformas distintas que suportam Java (Solaris, Windows, MAC, OS,
Linux e outros). Não é necessário compilar o programa novamente para executá-lo em
outro sistema, porque o próprio compilador Java é escrito em Java de modo que ele é
portável para qualquer sistema que possui o interpretador (bytecodes).
3 – Applets x Aplicativos
As applets rodam embutidas em páginas WEB. As applets rodam em um ambiente restrito
de segurança. Aplicativos são independentes. É possível escrever programas que rodam
tanto como applets quantos como aplicativos independentes.
4 – Java SDK
O ambiente de desenvolvimento de software Java, Java SDK é formado essencialmente
por um conjunto de aplicativos que permitem entre outras tarefas compilar e executar
programas escritos na linguagem Java. Pode ser baixado gratuitamente na pagina da
SUN (www.sun.com). As ferramentas básicas do kit de desenvolvimento do Java são:
• compilador Java: javac
• interpretador de aplicativos Java (máquina virtual): java
• interpretador de applets java: appletviewer

6
Outras ferramentas
• javadoc; gerador de documentação para programas java.
• jar: um manipulador de arquivos comprimidos no formato java archive.
• Jdb: depurador de programas javae e outras.
4.1) Versões da linguagem

Java 1.0.2: essa foi à versão mais difundida, e a última entre as versões 1.0, é a versão
que está embutida nos browsers mais antigos.
Java 1.1.0: essa versão incorporou uma grande quantidade de funcionalidades, entre elas
algumas das mais importantes, são Java RMI, JavaBeans, novo modelo de eventos,
JDBC.
Java 1.2: passou a chamar-se java 2 inclui várias melhorias em relação à versão 1.1, uma
das principais é a inclusão das funcionalidades da JFC (java foundation class), a
biblioteca que contém os componentes do swing.
Java 1.4: última versão incorpora diversas melhorias e novas classes para lidar com
expressões regulares.
5 - Java API
A linguagem java é menor e mais simples do que C++, entretanto tem uma grande
biblioteca de classes. Principais características:
• Classes são agrupadas em pacotes
• API Java2 tem cerca de 60 pacotes
• API pode ser consultada em http: //java.sun.com/j2se/1.4/docs/api/
Alguns dos principais pacotes do java API
Pacotes Descrição
Java.applet Manipulação de aplicações applet
Java.awt Trabalhar com janelas e seus componentes
Java.io Manipulação de entradas e saídas
Java.lang Manipulação de padrões da linguagem

7
Java.math Manipulação de definições matemáticas
Java.net Manipulação de rede
Java.text Manipulação de texto
Java.util Manipulação de utilidades
Javax.swing Trabalhar com janelas e seus componentes
6 – Ambientes de Desenvolvimento Integrado

Um ambiente de desenvolvimento integrado (IDE – integrated development enviroment) é
um conjunto de programas que combinam um editor de codigo-fonte, um compilador, um
depurador e outras ferramentas para propiciar maior conforto no desenvolvimento de
programas. Entre os mais utilizados podemos citar:
• Jbuilder (Borland)
• Forte (Sun)
• Visual Café (Symantec)
• Visual J++ (Microsoft)
• Jcreator (Xinox)
• Eclipse (eclipse)
Exercícios de Revisão Capítulo I:

1. O que são applets?
2. Qual a diferença entre applets e aplicativos?
3. O que é o java SDK?
4. Qual é a versão atual do java?
5. Quais os principais pacotes do java API e qual a utilidade?
6. O que é um IDE?

8
Capítulo II – Onde está instalado?
1 - O SDK
Em nossos computadores o SDK está instalado na pasta: c:\ j2sdk1.4.2_04, onde:
• A pasta BIN: contém o compilador (javac.exe), a máquina virtual (java), o visualizador

de applets (appletviewer.exe) e vários utilitários do SDK.
• A pasta DEMO: contém códigos fontes de demonstração de aplicações java.
• A pasta DOCS: contém a documentação do SDK
• A pasta INCLUDE: contém arquivos de biblioteca para execução de aplicações java.
• A pasta JRE: contém bibliotecas e utilitários para aplicações de rede.
• A pasta LIB: contém bibliotecas diversas utilizadas pelo java.
 Execute 1: Documentação
1. Para verificar estas instalações siga os passos descritos abaixo:
2. Acessar o windows explorer: (iniciar, programas, windows explorer)
3. Acessar o disco local (c:), acessar a pasta j2sdk1.4.2_04
4. Verifique as pastas instaladas.
5. Acesse a pasta DOCS, dois cliques no arquivo index.htm (nesta pasta estão as
documentações do java que serão útil no decorrer do curso de java), clique no link API
& Language, clique no link Java 2 Platform API Specification.

9
A seguinte tela será exibida:
4. Navegue pelos pacotes e suas classes.
2 – O IDE
O IDE (ambiente de desenvolvimento integrado) instalado em nossos computadores é o
JCreator (Xinox Software). De fácil compreensão e bem leve.
 Execute 2: IDE JCreator

1. Para executar o JCreator siga os passos abaixo:
2. Clicar no botão iniciar, Programas, JcreatorV2LE, JcreatorLE

10

11
Capítulo III – Primeiro Exemplo
1 – Primeiro Exemplo: Bem Vindo a Hytec!

O IDE usado no curso será o Jcreator desenvolvido pela Xinox Software que pode ser
obtido no site (www.jcreator.com).
 Execute 3: Digitando o primeiro exemplo

1. Abra o JCreator: iniciar, programas, JcreatorV2le, Jcreator Le. Acesse o menu File,
opção New, opção File. Coloque o nome para o arquivo fonte de BemVindo.java,
defina uma localização para salvar esse arquivo. A janela mostrada a seguir deve ser
exibida.
Ferramenta Ferramenta
Compilar Executar
Digite o
Visualização
Área do programa
das classes,
processo de nesta área.
atributos e
métodos compilação e
usados no execução da
programa aplicação
Área da descrição
dos erros de
compilação
2. Digite o programa na parte da janela onde está especificado para digitar o programa:

12
// BemVindo.java
public class BemVindo{ // classe BemVindo

public static void main(String args[ ]){
System.out.println(“Bem Vindo a Hytec”);
}
}
public
É um qualificador do método que indica que este é acessível externamente a esta
classe (para outras classes que eventualmente seriam criadas). Não nos deteremos neste
aspecto agora, por enquanto todos os métodos serão declarados como public.
static
É um qualificador que indica que o método deve ser compartilhado por todos os
objetos que são criados a partir desta classe. Os métodos static podem ser invocados,
mesmo quando não for criado nenhum objeto para a classe, para tal deve-se seguir a
sintaxe:
<NomeClasse>.<NomeMetodoStatic>(argumentos)
Retornaremos a esta explicação posteriormente, por enquanto apenas é necessário

saber que particularmente o método main precisa ter uma qualificação porque ele é
chamado sem que se crie nenhum objeto de sua classe (classe BemVindo).
void
Semelhante ao void em C/C++, é o valor de retorno da função. Quando a função não
retorna nenhum valor ela retorna void, uma espécie de valor vazio que tem que ser
especificado.
main
É um nome particular do método que indica para o compilador o início do
programa, é dentro deste método e através de interações entre os atributos e argumentos
visíveis nele que o programa se desenvolve.
String argv[]
É o argumento de main e por consequência do programa todo. É um vetor de strings
que é formado quando são passados ou não argumentos através da invocação do nome do
programa na linha de comando do sistema operacional.
{ .... }
“Abre chaves” e “fecha chaves”: delimitam um bloco de código

13
// classe BemVindo
O uso das duas barras determina que o texto depois delas seja um comentário que
não faz parte das intruções do programa e assim para definir explicações sobre a instrução
usada no programa. No exemplo é colocado a frase “classe BemVindo” apenas como um
comentário que não faz parte dos comandos e sim apenas uma explicação.
System.out.println
Chamada do método println para o atributo out da classe ou objeto System. O
argumento é uma constante do tipo String. println assim como o writeln de Pascal, imprime
a String e posiciona o cursor na linha abaixo, analogamente print não avança a linha.
3. Salvar o programa. Acesse o menu File, a opção Save All
4. Compilar o programa. Menu Build, opção Compile File.
5. Executar o programa. Menu Build, opção Execute File.
6. Programa apenas imprimiu a mensagem Bem Vindo a Hytec
Exercícios de Revisão Capítulo III:

Desenvolva uma aplicação para imprimir o teu nome e sobrenome.

14
Capítulo IV – Fundamentos
1 – Tipos Primitivos, Variáveis e Operadores
1.1) Tipos primitivos

Ao declarar uma variável deve-se colocar o nome e tipo dessa variável. Java é uma
linguagem fortemente tipada, o que significa que todas as variáveis deverão ter um tipo
declarado. Um tipo define um conjunto dos valores que a variável poderá armazenar. Java
conta com 8 tipos primitivos:
Nome do Tipo Tipo Descrição
long inteiro Usado para descrever um

dado que utiliza números
inteiros. Tamanho (8 byte)
Int inteiro Usado para descrever um

inteiros com tamanho menor
que o tipo long.Tamanho (4
byte).
short inteiro Usado para descrever um

que o tipo int. Tamanho (2
byte)
byte inteiro Usado para descrever um

que o tipo short. Tamanho (1
byte)
double ponto flutuante Usado para descrever um

reais. Tamanho (8 byte)
float ponto flutuante Usado para descrever um

reais com tamanho meno
que double. Tamanho (4
15
byte)
char caracter Usado para descrever

apenas um caracter
alfanumérico e símbolos.
Tamanho (1 byte)
boolean lógico (true ou false) Usado para descrever um

dado que apresente apenas
verdadeiro (true) ou falso
(false). Tamanho (1 bit).
1.2) Variáveis
Variáveis são locais onde os dados são mantidos. Como na maioria das linguagens de
programação, são de tipos específicos. O tipo de uma variável determina o tipo de
informação que pode ser armazenada nela.
Variáveis em Java podem ser declaradas como atributos no corpo da classe ou podem
ser declaradas localmente em qualquer parte da implementação de um método.
A declaração de variáveis no Java segue a sintaxe:
<tipo> <identificador> [= <valor inicial>];
Onde: <tipo> é um dos tipos primitivos descritos no item anterior;
<identificador> é o nome de uma variável para que ela possa ser identificada.
<valor inicial> é o conteúdo recebido por uma variável não é obrigatório usar na
declaração
A atribuição é feita através do operador “=”:
<identificador> = <valor>;
Exemplos:
....
int qtfilhos, numpessoas; // declaração de duas variáveis inteiros
16
float salario = 260.5; // declaração de uma variável real com conteúdo

char sexo = ‘m’; // declaração de uma variável caracter com o conteúdo
boolean achou = false; // declaração de uma variável lógica com conteúdo
qtfilhos = 9; // atribui o valor 9 a variável qtfilhos
....
1.3) Operadores
A linguagem Java oferece um conjunto bastante amplo de operadores destinados a
realizar operações aritméticas, lógicas, relacionais e atribuição.
1.2.1) Operadores Aritméticos

Como na maioria das linguagens de programação, Java possui vários operadores
aritméticos:
Operador Significado Exemplo
+ Adição Usado para realizar operações de

adição. Por exemplo:
A=5 B=6
X = A + B.
O valor de X é 11.
- Subtração Usado para realizar operações de

subração. Por exemplo:
A=8 B=6
X=A-B
O valor de X é 2.
* Multiplicação Usado para realizar operações de

multiplicação. Por exemplo:
A=5 B=6
X=A*B
O valor de X é 30

17
/ Divisão Usado para realizar operações de

divisão. Por exemplo:
A = 30 B=6
X = A / B.
O valor de X é 5
% Resto da divisão Usado para identificar o resto da

divisão entre dois números inteiros.
Por exemplo:
A = 10 B=6
X=A%B
O valor de X é 4
- Sinal negativo Usado para identificar o sinal

negativo de um número. Por
exemplo:
A=5
X = -A
O valor de X é –5
++ Incremento (+1) Usado para incrementar

(acrescentar 1) um número. Por
exemplo:
A=5
X = ++a é igual X= A + 1
O valor de X é 6
-- Decremento(-1) Usado para decrementar (retirar 1)

um número. Por exemplo:
A=5
X = --A é igual X = A - 1
O valor de X é 4

18
Estes operadores aritméticos podem ser combinados para formar expressões onde deve
ser observada a precedência de avaliação de operadores. Parêntesis pode ser utilizado
para determinar uma forma específica de avaliação de uma expressão.
Por exemplo:
5+4*3 o resultado será 17.
(5+3)*3 o resultado será 24.
Nos exemplos o uso dos parêntesis indica que deve ser feitas a soma primeira e depois a
multiplicação. Caso não use o parêntesis é feita primeira à multiplicação e depois a soma.
 Execute 4: Exemplo de Operadores Aritméticos

1. Abra o Jcreator.
2. Acesse o menu File, opção new, opção file, Coloque o nome do arquivo de
Aritmeticos.java
3. Digite o seguinte código:

//Aritmeticos.java
public class Aritmeticos {

public static void main(String arg[]){
// declaração e inicialização de duas variáveis
int a = 5;
int b = 2;
System.out.print(“a = ”); // exibe em tela o texto a=

System.out.println(a); // mostra o conteúdo da variável a
System.out.print(“b = ”); // exibe em tela o texto b=

System.out.println(b); // mostra o conteúdo da variável b
System.out.print(“a = ”); // exibe em tela o texto a=

System.out.println(++a); // mostra o resultado da operação ++a
System.out.print(“b = ”); //exibe em tela o texto b=

System.out.println(--b); //exibe em tela o resultado da operação --b

19
System.out.print(“a + b =”); // exibe em tela o texto a+b=

System.out.println (a+b); // exibe em tela o resultado de a+b
System.out.print(“a – b =“); // exibe em tela o texto a-b=

System.out.println(a-b); // exibe em tela o resultado de a-b igual 5
System.out.print(“a * b =”); // exibe em tela o texto a * b =

System.out.println(a*b); // exibe em tela o resultado de a*b 6
System.out.print(“a / b = ”); // exibe em tela o texto a / b =

System.out.println(a/b); //exibe em tela o resultado de a / b igual 6
System.out.print(“a % b = “); // exibe em tela o texto a % b =

System.out.println (a%b); //exite em tela o resultado a % b igual 0
}
}
4. Compilar e Executar. Verifique o resultado:

a=5
b=2
a=6
b=1
a+b=7
a–b=5
a*b=6
a/b=6
a%b=0
1.2.2) Operadores Relacionais

Operadores que permitem comparar valores, variáveis ou resultado de expressões
retornando um resultado do tipo lógico, isto é falso (false) ou verdadeiro (true). Os
operadores relacionais disponíveis são:
== igual Usado para comparar se

uma expressão é igual à
outra. Por exemplo:
A=5 B=8
X = A == B

20
O valor de X é false, pois 5

não é igual a 8.
!= diferente Usado para comparar se

uma expressão é diferente
da outra. Por exemplo:
A=5 B=8
X = A != B
O valor de X é true, pois 5

não é diferente de 8.
> maior que Usado para comparar se

uma expressão é maior do
que a outra. Por exemplo:
A=5 B=8
X=A>B

não é maior do que 8.
>= maior ou igual que Usado para comparar se um

expressão é maior ou igual a
outra. Por exemplo:
A=5 B=8
X = A >= B

não é maior ou igual a 8.
< menor que Usado para comparar se

uma expressão é menor do
que a outra. Por exemplo:
A=5 B=8
X=A<B
O valor de X é true, pois 5 é

menor do que 8.
<= menor ou igual que Usado para comparar se

21
uma expressão é menor ou

igual do que a outra. Por
exemplo:
A=5 B=8
X = A <= B
O valor de X é true, pois 5 é

menor do que 8.
Note que o operador igual é == (usado para comparar se uma expressão é igual a outra)
para diferenciar da atribuição = (é usado para armazenar um valor em uma variável).
 Execute 5: Exemplo de Operadores Relacionais

1. Abra o Jcreator.
2. Acesse o menu File, opção new, opção file digite o nome do arquivo de
Relacionais.java, defina a localização.
3. Digite o programa abaixo:

// Relacionais.java
public class Relacionais {

int a = 15; // declara a variável inteira a e atribui o valor 15 a ela

int b = 12; // declara a variável inteira b e atribui o valor 12 a ela
System.out.print(“a = “); // exibe o texto a=

System.out.println(a); // exibe o conteúdo da variável a
System.out.print(“b = “); // exibe o texto b=

System.out.println(b); // exibe o conteúdo da variável b
System.out.print(“a = = b ”); // exibe o texto a = = b

System.out.println(a= =b); // exibe o resultado da comparação a = = b
System.out.print(“a != b ”); // exibe o texto a != b

System.out.println(a!=b); // exibe o resultado da comparação a != b

22
System.out.print(“a > b ”); // exibe o texto a > b

System.out.println(a>b); // exibe o resultado da comparação a > b
System.out.print(“a < b ”); // exibe o texto a < b

System.out.println(a<b); // exibe o resultado a comparação a < b
}
}
4. Compilar e executar. Verifique os resultados:

a = 15
b = 12
a == b false
a != b true
a > b true
a < b false
1.2.3) Operadores Lógicos

Operadores que permitem conectar logicamente resultados de diferentes expressões
aritméticas ou relacionais construindo assim uma expressão resultante composta de
várias partes.
&& e lógico (and): compara valores lógicos e a = false b = true

retorna verdadeiro caso todos os valores
forem verdadeiros. x = a && b
o valor x é false
A B A && B
false false false
false true false
true false false
true true true
|| ou lógico (or): compara valores lógicos e a = false b = true

retorna verdadeiro caso existe um valor

23
verdadeiro. x = a || b
o valor x é true
A B A || B
false false false
false true true
true false true
true true true
! não (not): nega um valor lógico a = false
b = true
x = !a
O valor de x é true, pois

aquilo que não é falso so
pode ser verdadeiro.
y=!b
O valor de y é false, pois

aquilo que não é verdadeiro
so pode ser falso.
 Execute 6: Exemplo de Operadores Lógicos

1. Abra o Jcreator.
2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
Aritmeticos.java

//Logicos.java
public class Logicos {
boolean a=false; // declara a variável logica a com o conteúdo false
boolean b=true; // declar a variável logica b com o conteúdo true
System.out.print("a = "); // exibe o texto a =

24
System.out.println(a); // exibe o conteúdo de a
System.out.print("b = "); // exibe o texto b =

System.out.println(b); // exibe o conteúdo de b
System.out.print("a && b = "); // exibe o texto a && b =

System.out.println(a&&b); // exibe o resultado a && b
System.out.print("a || b = "); // exibe o texto a || b =

System.out.println(a||b); // exibe o resultado a || b
System.out.print("!a = "); // exibe o texto !a =

System.out.println(!a); // exibe o resultado !a
}
}
4. Compilar e executar. Verifique o resultado.
a = false
b = true
a && b = false
a || b = true
!a = true
1.2.4) Manipulação de Strings

Quando você trabalha com string em Java, você utiliza uma instância da classe
java.lang.String. A classe provê vários métodos úteis para se trabalhar com cadeia de
caracteres (string).
EXEMPLO:
String vazio = “”; // string vazia
String cumprimento = “oi”; // declaração da variável cumprimento com o conteúdo oi
String A = “bana”; // declaração da variável A com o conteúdo “bana”
String B =”nada”. // declaração da variável B com o conteúdo “nada”
String C = A + B; // a string C é união da variável A com a B é igual a “bananada”.
Quando uma string é concatenada com um valor que não é string esse valor é convertido
em string
String disciplina = “Pro”+55; // coloca na string disciplina o valor “Pro55”.
Isto é feito freqüentemente em comandos de impressão, como no exemplo a seguir:

25
float nota = 20
System.out.println(“Nota de Programação: “+nota);
Ocorre a junção do texto “ Nota de Programação com a variável nota. O valor da nota é
convertido em string exibindo portanto o resutado “Nota de Programação 20”.
 Execute 7: Exemplo de String

1. Abra o Jcreator.
StringDemo.java

// StringDemo.java
public class StringDemo {

public static void main(String a[]){
String palavra1 = "Curso"; // declaração da variável string palavra1 igual “curso”

String palavra2 = "Java"; // declaração da variável string palavra2 igual “Java”
String frase = palavra1+ " "+ palavra2; // a variável frase recebe a união de
//palavra1 mais espaço (“ “) mais palavra2
System.out.println(frase); //exibe na tela o conteúdo da variável frase igual
// “Curso Java”
}
}
4. Compilar e executar. Verifique o resultado.
Curso Java
2 – Estruturas de Controle e seleção
2.1) Estrutura de seleção

As maiorias dos programas tomam decisões que afetam seu fluxo. As declarações que
tomam essas decisões são chamadas de declarações de controle.

26
2.1.1) Declaração if – else (se – senão)
Sintaxe:
if ( condição )
comando1;
else
comando2;
onde:
condição: é uma expressão de comparação de dados

comando1: é o comando caso a comparação seja verdadeira
comando2: é o comando caso a comparação seja falsa
Tradução:
Se (condição)
comando1 ;
senão
comando 2;
Exemplo:
if ( fim = = true )
System.out.println(“Término!”);
else
System.out.println(“Continuando...”);
Para mais de um comando ser executado depois da declaração, utiliza-se o conceito de

blocos, delimitados por {}.
Exemplo:
if ( fim == true ){ // comandos caso for verdadeiro a condição
cont = 0;
System.out.println(“Término!”);
}
else { // commandos caso for falso a condição
cont = cont +1;
System.out.println(“Continuando...”);
}

27
 Execute 8: Exemplo de estrutura de seleção IF

1. Abra o Jcreator.
ExemploIF.java

//ExemploIF.java
public class ExemploIF {

char sexo= 'F'; // declaração da variável caracter sexo contendo ‘F’
if (sexo == 'M') { // se o sexo for ‘M’ de masculino

System.out.println("Masculino"); // exibe a mensagem “Masculino”
} else {
System.out.println("Feminino"); // exibe a mensagem “Feminino”
}
}
}
Feminino
2.1.2) Declaração Switch
Aceita um char, byte, short ou int como sua expressão de comparação. Esse valor é
procurado nas declarações case que vem depois da declaração switch e o código
adequado é executado.
Sintaxe:
switch ( expressão ) {
case valor: comandos; break;
...
default: comandos;
}

28
onde:
expressão: pode ser um valor char, byte, short ou int

valor: é o conteúdo do valor
comandos: é uma seguência comandos caso o valor escolhido for igual ao conteudo
default: é o valor padrão caso nenhum valor for escolhido
break: é a instrução usada para parar a execução caso um valor seja encontrado
Tradução
Escolha(expressão) {
Caso valor: comandos; parar;
...
outros casos: comandos;
Exemplo:
Int cmd=2; // declaração de uma variável inteira contendo o valor 2

switch ( cmd ){
case 1: System.out.println(“Item do menu 1”);
break;
break;
break;
default: System.out.println(“Comando invalido!”);
}
O resultado será a escolha do segundo valor do cmd pois é igual a 2 então exibirá na tela
“Item do menu 2” e para (break) a execução do comando pois encontrou um valor
verdadeiro.
Caso o valor do cmd fosse 4 será impresso “Comando invalido” pois nehum valor foi
encontrado portanto escolheu o valor padrão (default é usado caso não encontre nenhum
valor verdadeiro).

29
 Execute 9: Exemplo de estrutura de seleção Switch

1. Abra o Jcreator.
ExemploSwitch.java

//ExemploSwitch.java
public class ExemploSwitch {

char sexo= 'F'; // declaração da variável caracter sexo contendo ‘F’;
switch (sexo){ // escolha sexo
case 'M':System.out.println("Masculino");break; // caso ‘M’
case 'F':System.out.println("Feminino");break; // caso ‘F’
default:System.out.println("Sexo inválido"); // outros casos
}
4. Compilar e executar. Veja o resultado:
Feminino
2.2) Estrutura de Controle
2.2.1) Declaração while
Utilizada quando não se quer que o corpo do laço seja necessariamente executado. A
expressão de comparação é avaliada antes que o laço seja executado.
Sintaxe:
while (condição) {
bloco de comandos;
}
onde:
condição: usado para repetir enquanto a condição for verdadeira
bloco de comandos: comandos usados para repetir caso a condição seja verdadeira.

30
Tradução:
enquanto (condição) {
bloco de comandos;
}
Exemplo:
i = 3;
salario = 260;
while ( i != 0 ){ // enquanto i for diferente de zero
salario = salario + 10;
i--; // i menos 1
}
Nesse exemplo o valor inicial de i é 3 portanto a condição é satisfeito (i!=0) ocorre a

execução dos comando dentro do while (repetição) veja o que acontece
i = 3 e salario = 260
entrou no while pois i é diferente de 0(i!=0) {
salario = 260 + 10 portanto salario = 270
i-- portanto i é igual a 2 (i!=0) repete
salário = 280 + 10 portanto salário = 290
i-- portanto i é igual a 0 (i!=0) não repete pois o valor de i é 0 sai do while
}
saiu do while
 Execute 10: Exemplo de estrutura de controle while

1. Abra o Jcreator.
ExemploWhile.java

31

// ExemploWhile.java
public class ExemploWhile{
int j = 10; // declara uma variável inteira chamada j contendo o valor 10
while (j > 0){ // enquanto a variável j for maior que 0 repete
System.out.println(j); // exibe o valor de j
j--; // decrementa o valor de j (retira 1 da variável j)
}
}
4. Compilar e executar. Veja o resultado
10
9
8
7
6
5
4
3
2
1
2.2.2) Declaração do - while
Utilizada quando se quer que o corpo do laço seja necessariamente executado. A

expressão de comparação é avaliada depois que o laço for executado.
Sintaxe:
do {
bloco de comandos
} while (condição);

32
Tradução:
faça {
blocos de comandos
} enquanto (condição)
Exemplo:
i = 3;
salario = 260;
do {
salario = salario + 10;
i--;
}while ( i != 0 );
Nesse exemplo ocorre a repetição:
i = 3 e salario = 260
faça {
salário = 280 + 10 portanto salário = 290
i-- portanto i é igual a 0 (i!=0) não repete pois o valor de i é 0 sai do while
}enquanto i for diferente de 0
saiu do while
 Execute 11: Exemplo de Estrutura de Controle do{ }While

1. Abra o Jcreator.
ExemploDoWhile.java

// ExemploDoWhile.java
public class ExemploDoWhile {

33

int j=10; // declara uma variável chamada j contendo o valor 10
do { // repete
System.out.println(j); //exibe o valor da variável j
j--; // decrementa o valor de j ou seja retira 1 da variável j
} while (j>0); // enquanto j for maior que 0
}
}

10
9
8
7
6
5
4
3
2
1
2.2.3) Declaração For
Fornece uma expressão para inicializar as variáveis, seguidas por uma expressão de
comparação e depois um lugar para incrementar ou decrementar as variáveis de laço. A
declaração pode ser um comando simples ou um bloco de comandos.
Sintaxe:
for (valor_inicial; condição para repetir; valor de incremento) {
bloco de comandos
}
Tradução:
para (valor_inicial; condição para repetir; valor de incremento){
bloco de comandos
}
Exemplo:
salario=260;
for (i = 0; i < 2; i ++) {
salario = salario +10;

34
salario = 260;
para (i=0; i<3; i++){ repete de 0 até 2 (0,1,2){
salario = 260 + 10 portanto o salario = 270; repete i=0 pois i < 3
salario = 270 + 10 portanto o salario = 280; repete i=1 pois i < 3
salario = 280 + 10 portanto o salário = 290; repete i=2 pois i < 3
não repete mais pois i = 3 então não é menor que 3
}
saiu da repetição
 Execute 12: Exemplo de estrutura de controle FOR

1. Abra o Jcreator.
ExemploFor.java

//ExemploFor.java
public class ExemploFor {

int j; // declara a variável inteira j;
for (j=10;j>0;j--){ // para (j=10 ; j>0; j--) repete de 10 até 1
System.out.println(j); // exibe o valor de j
}
}
}

10
9
8
7
6
5
4
3
2
1

35
para (i=10; i>0; i--) { // repete de 10 até 1 {

exibe o valor de i =10 repete pois i > 0
...
exibe o valor de i =1
SAI DA REPETIÇÃO POIS i = 0 portanto não é maior que 10
}
saiu da repetição
2.3) Estrutura de Controle de Erros

O Java oferece duas importantes estruturas para o controle de erros muito semelhantes
às estruturas existentes na linguagem C++: try catch e try finally. Ambas têm o propósito
de evitar que o programador tenha que realizar testes de verificação e avaliação antes da
realização de certas operações, desviando automaticamente o fluxo de execução para
rotinas de tratamento de erro. Através destas diretivas, delimita-se um trecho de código
que será monitorado automaticamente pelo sistema. A ocorrência de erros no Java é
sinalizada através de exceções, isto é, objetos especiais que carregam informação sobre
o tipo de erro detectado.
Sintaxe:
try {
Comandos normais que será tratado;
} catch (exception1){
Comandos de tratamento de erro1;
} catch (exception2){

36
Tradução:
Tratar {
Comandos normais que será tratado;
} definir (exception1){
} definir (exception2){
Sintaxe:
try {
Comandos normais;
} finally {
Comandos de tratamento de erro;
Tradução:
Tratar {
Comandos normais;
} finalizar {
Comandos de tratamento de erro;
 Execute 13: Exemplo de estrutura de erro try..catch

1. Abra o Jcreator.
TratamentoErros.java

37

//TratamentoErros.java
public class TratamentoErros {

public static void main(String args[]){
int a = 10; // declaração variável inteira a igual 10
int b = 0; // declaração variável inteira b igual 0
int c; // declaração variável inteira c
try { // tratar o erro
c = a / b; // divisão por zero causa erro pois a =10 e b = 0, ocorre 10/0
} catch (ArithmeticException e) { // define o erro de Aritmética
System.out.println("Impossível divisão por zero"); // exibe texto
}
}
}
Impossível divisão por zero
 Execute 14: Exemplo de estrutura de erro try..finally
1. Abra o Jcreator.
TratamentoErrosF.java
//TratamentoErrosF.java
public class TratamentoErrosF {

int a = 10; // declaração da variável a igual 10
int b = 0; // declaração da variável b igual 0
int c; // declaração da variável c
try { // Tratar erro
c = a / b; // divisão por zero causa erro
38
} finally { // finaliza a execulção e exibe a mensagem de erro

System.out.println("Impossível divisão por zero");
}
}
}
Impossível divisão por zero
2.4) Vetores
Vetores são objetos, eles possuem papel importante no estilo de programação dessa
linguagem que exclui os ponteiros. Por serem objetos, vetores são obrigatoriamente
alocados de maneira dinâmica. O exemplo a seguir aloca um vetor de inteiros com três
posições, seguindo uma sintaxe semelhante à alocação de objetos (que veremos mais
adiante):
Sintaxe:
<tipo primitivo> <nome do vetor>[ ] = new <tipo primitivo>[<tamanho do vetor>]
onde:
<tipo primitivo>: é um dos tipos primitivos já conhecidos anteriormente.
<nome do vetor>: é o nome de identificação do vetor.
new : criação do novo objeto vetor.
<tamanho do vetor>: é o tamanho das posiçõe do vetor.
Exemplo:
int x[ ] = int[3]
no exemplo é criado um vetor chamado x de inteiro com 3 posições

39
 Execute 15: Exemplo de utilização de Vetores

1. Abra o Jcreator.
VetorTest.java
//VetorTest.java
public class VetorTest

{
public static void main (String args[])
{
int vetor[] = new int[3]; // declara um vetor de inteiros chamado vetor com 3 posições
vetor[0]=0; // coloca na posição 0 o valor 0
int soma; // declara uma variável inteira chamada soma;
soma = vetor[0] + vetor[1] + vetor[2] // soma os valores das posições do vetor
System.out.println(soma); // exibe a soma
}
30
Exercícios de Revisão Capítulo IV:

1) Desenvolva uma aplicação que declare as seguintes variáveis:
x e y , contendo os valores 10 e 8.
resposta, contendo o valor falso.
Profissão, contendo o valor “Médico”
Utilize os operadores para elaborar alguns resultados nas variáveis descritas acima e
imprima utilizando o comando System.out.println().

40
2) Desenvolva uma aplicação que declare duas strings e faça a concatenação dessas
strings e imprima utilizando o comando System.out.println().
3) Desenvolva uma aplicação que conte de 1 até 10, usando os comandos (for, while e do
..While)
4) Desenvolva uma aplicação que declare duas variáveis de ponto flutuante e verifique
qual é a variável maior utilizando o comando if.
5) Desenvolva uma aplicação que declare uma variável caracter chamada estacivil
contendo o caracter ‘c’. Faça uma estrutura usando o switch para que possa imprimir
“casado” caso a variável estadocivil possua o conteúdo ‘c’. “Solteiro” quando o conteúdo
for ‘s’. “Divorciado” quando o contendo for ‘d’. “Viúvo” quando o conteúdo for ‘v’. Caso o
conteúdo seja diferente dos citados acima imprima “Estado civil invalido”.
6) Desenvolva uma aplicação que declare um vetor de 10 posições e atribua o valor 20 a

todas as posições.

41
Capítulo V – Programação Orientada a Objetos
1) Objetos e classes
A programação orientada a objetos é modelada de acordo com a observação de que, no
mundo físico, os objetos são constituídos de muitos tipos de objetos menores.
Entretanto, a capacidade de combinar objetos é apenas um aspecto da programação

orientada a objetos. Outro recurso importante é o uso de classes.
Uma classe é um modelo usado para criar um objeto. Todo objeto criado a partir da
mesma classe terá recursos semelhantes, se não idênticos.
As classes incorporam todos os recursos de um conjunto específico de objetos. Ao

escrever um programa em uma linguagem orientada a objetos, você não define objetos
individuais. Em vez disso, você define as classes usadas para criar esses objetos.
Por exemplo, você poderia criar uma classe Bola que descrevesse os recursos de todas
as bolas. O tamanho da bola é descrito através de seu raio e como tal tamanho pode ser
número inteiro ou real utilizamos uma variável do tipo float. Imaginando que a bola pode
ou não ser oca utilizamos uma variável lógica de nome oca que indica como true tal
situação e false (caso contrário). Valores inteiros, representando código do material e cor
pode ser usada para acrescentar outros detalhes na descrição do objeto.
A descrição do objeto em termo de classe o que deve ser ressaltado é que esta classe
propõe o que denominamos modelo conceitual para o objeto bola. A descrição do objeto
em classe é denominado modelagem orientada a objetos, uma das etapas mais
importante do desenvolvimento do software utilizando orientação a objetos.
Utilizando a notação UML (são desenhos que representam a modelagem das classes
como mostrado abaixo) temos a seguinte representação de uma classe e seus atributos
(características dos objetos ou propriedade dos objetos):
Definição da classe
Bola Bola
cor: int
material: int
oca: boolean Atributos do objeto
raio: float da classe

42
Onde cor, material, oca e raio são os atributos que descrevem as características do objeto
da classe Bola.
Para modelar as classes usaremos a notação UML para melhor estruturar as classes,
seus atributos e métodos.
2) Atributos e comportamento
Uma classe Java consiste em dois tipos de informação: atributos e comportamento.
Ambos estão presentes em Vulcao, um projeto que você implementará hoje como uma
classe. Esse projeto, uma simulação por computador de um veículo de exploração
vulcânica.
Os atributos são os dados que diferenciam um objeto do outro. Eles podem ser usados
para determinar a aparência, o estado e outras qualidades dos objetos pertencentes a
essa classe.
Um veículo de exploração vulcânica poderia ter os seguintes atributos:
- informações: explorando, movendo, retornando ao início.
- Velocidade: em milhas por hora
- Temperatura: em grau fahrenheit
Em uma classe, os atributos são definidos através de variáveis (lugares para armazenar
informações em um programa de computador)
Comportamento se refere às atividades que uma classe de objetos pode realizar neles
mesmos e em outros objetos. Ele pode ser usado para alterar os atributos de um objeto,
receber informações de outros objetos e enviar mensagens para outros objetos que
estejam solicitando a eles a realização de tarefas.
Um robô de vulcão poderia ter o seguinte comportamento:
- verificar a temperatura atual
- iniciar um levantamento
- relatar sua localização atual
O comportamento de uma classe de objetos é implementado através de métodos.
Os métodos são grupos de instruções relacionadas em uma classe de objetos em seus

próprios objetos e em outros e são utilizados da mesma maneira que as funções e sub-
rotinas são usadas em outras linguagens de programação.
Os objetos se comunicam entre si através de métodos. Uma classe ou um objeto pode

chamar métodos de outra classe ou objeto por muitos motivos, incluindo os seguintes:
43
- para relatar uma alteração em outro objeto
- para dizer ao outro objeto para alterar algo a respeito de si mesmo
- para pedir que o outro objeto faça algo
Sintaxe de um método público:
public <tipo de retorno> <nome do método>(<argumentos>){
instruções executadas pelo método
return <variável de retorno>
onde:
<tipo de retorno>: são os tipos primitivos estudados anteriormente.
<nome do método>: é um nome que identifica um método.
<argumentos>: são dados que devem ser passados para o método.
return: é o comando usado para retorna o valor definido pelo método.
<variável de retorno>: é a variável usada para retorna o valor usado no método.
Exemplo:
public int soma(int x, int y){
int s;
s = x + y;
return s;
}
no exemplo descrito acima é criado um método público chamado soma que é do tipo de
retorno inteiro e recebe os argumentos x,y que são inteiro. A variável s é usada para fazer
a soma de x mai y. A variável s é usada para retornar o valor do soma de x com y.
System.out.println(soma(10,8));
O comando acima mostra a utilização do método soma que recebe os valores 10 para x e
8 para y. Portanto ao chamar o método será feita a soma de x com y dando o resultado de
18, pois esta usando o comando para exibir essa soma através do método.

44
3) Criando uma classe
 Execute : Exemplo de criação de classes.

1. Abra o Jcreator.
2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de Bola.java

//Bola.java
public class Bola { // declaração da classe bola – o commando class define a declaração da classe
//atributos: são os dados que define a característica da classe Bola

String cor;
String material;
boolean oca;
float raio;
//métodos: são comportamentos que podem alterar um atributo de uma classe
/* este método obterCor() retorna uma string representando a cor da Bola. Onde public é a assinatura
tornando este método público para usar em qualquer programa. String é o tipo de retorno do método.
obterCor é o nome do método. O abrir e fechar parêntesis indicam que é um método sem argumentos.
*/
public String obterCor(){
return cor; // retorna a cor;
}
/* este método obterMaterial() retorna uma string representando o material da Bola. Onde public é a
assinatura tornando este método público para usar em qualquer parte do programa. String é o tipo de
retorno do método. obterMaterial é o nome do método. O abrir e fechar parêntesis indicam que é um
método sem argumentos.
*/
public String obterMaterial(){
return material;
}
/* este método obterOca() retorna true ou false representado se a Bola é oca ou não. Onde public é a
assinatura tornando este método público para usar em qualquer parte do programa. boolean é o tipo de
retorno do método. obterOca é o nome do método. O abrir e fechar parêntesis indicam que é um
método sem argumentos.
*/
public boolean obterOca(){
return oca;
}

45
/* este método obterRaio() retorna ponto flutuante para o valor do raio. Onde public é a
assinatura tornando este método público para usar em qualquer parte do programa.
float é o tipo de retorno do método. obterRaio é o nome do método. O abrir e fechar parêntesis indicam
que é um método sem argumentos.
*/
public float obterRaio(){
return raio;
}
// método sem retorno (usa o comando void ) e com argumento (String c) para mudar a cor da bola
public void mudarCor(String c){
cor = c;
}
// método sem retorno (usa o comando void ) e com argumento (String m) para mudar a material da bola
public void mudarMaterial(String m){
material = m;
}
// método sem retorno (usa o comando void ) e com argumento (boolean o) para mudar oca da bola
public void mudarOca(boolean o){
oca = o;
}
// método sem retorno (usa o comando void ) e com argumento (float r) para mudar o raio da bola
public void mudarRaio(float r){
raio = r;
}
// métodos sem retorno e sem argumentos imprimirInfoBola: usado para imprimir as informações da bola
public void imprimirInfoBola(){
System.out.println("Cor.....: "+obterCor()); // exibe informação da cor da bola
System.out.println("Material: "+obterMaterial()); // exibe informação do material da bola
System.out.println("Oca.....: "+obterOca()); // exibe informação do oco da bola
System.out.println("Raio....: "+obterRaio()); // exibe informação do raio da bola
System.out.println(""); // exibe uma linha em branco
}
// método principal da aplicação

/* cria um novo objeto chamado bl a partir da classe Bola. O comando new é usado para criar o
objeto a partir do modelo (classe) Bola
*/
Bola b1 = new Bola();
// mudando o conteudo dos atributos da bola através da notação de ponto que indica o objeto.atributo
b1.cor = "Branca";
b1.material = "Couro";
b1.oca = true;
b1.raio = 2;
46
// imprimindo informações da bola através da notação de ponto objeto.método

b1.imprimirInfoBola();
/* mudando o conteudo dos atributos da bola usando os métodos através notação de ponto
objeto.método.
*/
b1.mudarCor("Vermelha"); // chama o método mudarCor colocando a cor vermelha
b1.mudarMaterial("Plastico"); // chama o método mudarMaterial colocando o material plastico
b1.mudarOca(false); // chama o método mudarOca colocando o valor false
b1.mudarRaio(3); // chama o método mudarRaio colocando o valor 3 no raio
// imprimindo informações da bola

b1.imprimirInfoBola();
}

Cor.......: Branca
Material: Couro
Oca.......: true
Raio......: 2.0
Cor.......: Vermelha
Material: Plastico
Oca.......: false
Raio......: 3.0
 Execute : Exemplo de criação de classes.

1. Abra o Jcreator.
2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de Pai.java
//Pai.java
public class Pai {
// atributo
String nome, corcabelo, corolhos,sobrenome;
int idade;
// método construtor sem argumentos que define os atributos com os conteúdos

public Pai(){
nome = "Jose";
sobrenome="Rocha";
corcabelo="Preto";
corolhos="Preto";

47
idade=56;
}
// construtor com argumentos.

public Pai(String n, String s, String c, String o, int i){
nome = n;
sobrenome=s;
corcabelo=c;
corolhos=o;
idade=i;
}
// métodos sem argumentos e com retorno

public int obterIdade(){ // método usado para retornar a idade inteira
return idade; // retorna a idade
}
public String obterCorCabelo(){ // método usado para retornar a cor do cabelo string
return corcabelo; // retorna a cor do cabelo
}
public String obterCorOlhos(){ // método usado para retornar a cor dos olhos string
return corolhos; // retorna a cor dos olhos
}
public String obterNome(){ // método usado para retornar o nome string

return nome; // retorna o nome
}
public String obterSobrenome(){ // método usado para retornar o sobrenome string

return sobrenome; // retorna o sobrenome
}
// métodos sem retorno void usado para mostrar as informações dos atributos
public void imprimirInfo(){
System.out.println("Nome...........: "+obterNome()+" "+obterSobrenome());
System.out.println("Cor dos Cabelos: "+obterCorCabelo());
System.out.println("Cor dos Olhos:.: "+obterCorOlhos());
System.out.println("Idade..........: "+obterIdade());
System.out.println("");
}
//métodos com argumentos e sem retorno

public void mudarIdade(int i){ // mudar a idade
idade = i;
}
public void mudarCorCabelo(String c){ // mudar a cor do cabelo

corcabelo=c;
}
public void mudarCorOlhos(String o){ // mudar a cor dos olhos

corolhos=o;
48
public void mudarNome(String n){ // mudar o nome

nome=n;
}
public void mudarSobrenome(String s){ // mudar o sobrenome

sobrenome=s;
}
// método principal da aplicação

// construindo os objetos
Pai p1 = new Pai(); // cria o objeto p1 a partir da classe Pai
// Criar o objeto p2 a partir da classe Pai atribuindo as características do Pai

Pai p2 = new Pai("Carlos","Sousa","Loiros","Azuis",38);
// imprimindo as informações
p1.imprimirInfo(); // exibe informações do objeto p1
// alterando as informações
p1.mudarNome("Sandro"); // muda o nome do objeto p1
p2.mudarIdade(54); // muda a idade do objeto p2
// imprimindo as informações
}
}
Nome................: Jose Rocha
Cor dos Cabelos: Preto
Cor dos Olhos...: Preto
Idade.................: 56
Nome................: Carlos Sousa

Cor dos Cabelos: Loiros
Cor dos Olhos...: Azuis
Idade.................: 38
Nome................: Sadro Rocha

Cor dos Cabelos: Preto
Cor dos Olhos...: Preto
Idade.................: 56
Nome................: Carlos Sousa

Cor dos Cabelos: Loiros
Cor dos Olhos...: Azuis
49
Idade.................: 54
Para ver classes objetos, atributos e comportamentos em ação, você desenvolverá uma
classe Vulcao, criará objetos a partir dela e trabalhará com eles em um programa
funcional.
 Execute 16: Exemplo de criação de classes.

1. Abra o Jcreator.
2.Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de Vulcao.java
3.Digite o seguinte código:

// Vulcao.java
public class Vulcao {

// atributos
String informacao;
int velocidade;
float temperatura;
// métodos (comportamento)
/* este método não possui retorno (void). Seu nome é checarTemperatura não possui
argumentos. Este método verifica se a temperatura é superior a 660 caso seja ele muda
o atributo informacao=”Retornando ao inicio” e velocidade=5
public void checarTemperatura( ) {

if (temperatura > 660){
informacao = "Retornando ao inicio";
velocidade = 5;
}
}
public void mostrarAtributos(){ // este método mostra as informações dos atributos

System.out.println("Informacao : "+informacao);
System.out.println("Velocidade : "+velocidade);
System.out.println("Temperatura: "+temperatura);
}
// executando o programa
Vulcao dante = new Vulcao(); // criando o objeto dante da classe vulcao
dante.informacao = "Explorando"; // mudando o atributo informacao do objeto dante
dante.velocidade = 2; // mudando o atributo velocidade do objeto dante
dante.temperatura = 510; // mudando o atributo temperatura do objeto dante
dante.mostrarAtributos(); // exibe as informações do objeto dante
}

50

Informacao : explorando
Velocidade : 2
Temperatura: 510
4) Criando novos objetos (também chamados de instâncias)

Para criar um novo objeto, você usa o operador new como o nome da classe da qual
deseja criar uma instância, seguida do parênteses:
String name = new String();
URL endereco = new URL(http://www.hytec.com.br);
Vulcao robbie = new Vulcao();
Os parênteses são importantes; não se esqueça de usá-los. Eles podem estar vazios,
caso em que o objeto básico mais simples é criado, ou podem conter argumentos que
determinam os valores iniciais de variáveis de instância ou outras qualidades iniciais
desse objeto.
Os exemplos a seguir mostram objetos sendo criados com argumentos:
Random numero = new Random(6068460714);
Point pt = new Point(0,0);
O número e o tipo dos argumentos que você usa dentro dos parênteses com o operador
new são definidos pela própria classe, usando um método especial chamado construtor.
5) O que faz o operador new

Várias situações acontecem quando você usa o operador new. A nova instância da classe
dada é criada, uma memória é alocada para ela e um método especial, definido na classe,
é chamado. Esse método especial é chamado construtor.
Construtores são métodos especiais para a criação e inicialização de novas instâncias de

classes. Eles inicializam o novo objeto e suas variáveis, criam todos os outros objetos de
que esse objeto necessita e realizam todas as outras operações que ele precisa para ser
inicializado.

51
Cada uma das várias definições de construtor em uma classe tem um número ou tipo de
argumento diferente. Quando você usa o operador new, pode especificar diferentes
argumentos na respectiva lista e o construtor correto desses argumentos é chamado.
Para obter o valor de uma variável de instância, você usa a notação ponto. Com essa
notação, o nome de uma variável de instância ou de classe possui duas partes: uma
referência a um objeto ou classe no lado esquerdo do ponto e a variável no lado direito.
A notação de ponto é um modo de fazer referência à variável de instância e aos métodos

de um objeto usando um operador de ponto(.).
Por exemplo, dante.velocidade = 2, o objeto dante obtêm valor da velocidade que é uma
variável de instância.
Você utiliza a variável de instância para acessar variáveis da classe.
Chamar um método em um objeto é semelhante a fazer referência a suas variáveis de

instância: a notação ponto é usada. O objeto cujo método você está chamando fica do
lado esquerdo do ponto e o nome do método e seus argumentos ficam no lado direito. Por
exemplo:
dante.mostrarAtributos();
dante.checarTemperatura();
6) Acessando e Definindo variáveis de classe e de instância

As variáveis de classe e instância se comportam do mesmo modo que as variáveis locais.
É possível usá-las em expressões, atribuir valores a elas em instruções e outras
atividades. Você precisa fazer referência a elas em seu código de modo ligeiramente
diferente do que e utilizado com as variáveis normais. Para obter o valor de uma variável
de instância, você usa a notação de ponto. Com essa notação o nome de variável de
instância ou de classe possui duas partes: uma referencia ao objeto ou classe no lado
esquerdo do ponto e a variável no lado direito. Por exemplo:
dante. velocidade; // obtendo valores
dante.velocidade = 400 // alterando valores
Essa forma de acessar variáveis e uma expressão (isto é, ela retorna um valor) e os dois
lados do ponto também são expressões.
7) Chamando métodos
Chamar um método em um objeto e semelhante a fazer referência a suas variáveis de
instância: notação de ponto é usada. O objeto cujo método você está chamando fica no

52
lado esquerdo do ponto e o nome do método e seus argumentos ficam no lado direito. Por
exemplo: dante.checarTemperatura(); dante.mostrarAtributos.
8) Criando classes
Ela é definida através da palavra-chave class e do nome da classe como exemplo a
seguir: class Bola{
//corpo da classe
Por definição, as classes herdam da classe Object. Essa é a superclasse na hierarquia de

classes Java.
A palavra-chave extends é usada para indicar a superclasses de uma classe. Veja a

seguinte subclasse de bola: class BolaFutebol {
//corpo da classe
9) Criando Métodos
Os métodos definem o comportamento de um objeto e tudo o que acontece quando ele é
criado e as diversas tarefas que pode realizar durante sua existência. As definições dos
métodos tem quatro partes básicas:
Nome do método;
Uma lista de parâmetros;
Tipo de objeto ou tipo primitivo retornado pelo método;
corpo do método.
Sintaxe básica do método:
Tipo nomedometodo(tipo arg1, tipo arg2, tipo arg3...){
// corpo do método
Por exemplo:
public void mostrarAtributos(){
53
System.out.println("Informacao : "+informacao);
System.out.println("Velocidade : "+velocidade);
System.out.println("Temperatura: "+temperatura);
}
10)A palavra-chave this e Super
10.1) This
Usado para fazer referência ao objeto atual e você pode usá-la em qualquer parte na qual
uma referência a um objeto possa aparecer: em uma notação de ponto, como argumento
para um método, como valor de retorno do método atual. Alguns exemplos de this são
mostrados abaixo:
t = this.x; // a variável de instância x deste objeto
this.resetData(this); // chama método resetData, definido nessa classe, e passa para o
//objeto corrente
return this; //retorna o objeto corrente
10.2) Super
Usado para fazer referência a uma classe mais acima de outra na hierarquia de classes,
sua subclasse. Uma classe pode ter apenas uma superclasse imediatamente superior,
mas esta também pode ter uma superclasse e assim por diante.
t = super.x; a variável de instância x da classe superior
super.resetData(this); // chama método resetData, definido na classe superior
return super; // retorna o objeto da classe superior
super() //construtor da classe superior
 Execute 17: Exemplo de criação de classes e métodos.

1. Abra o Jcreator.
MaquinaLavar.java

54

// MaquinaLavar.java
public class MaquinaLavar { // classe chamada MaquinaLavar
public int velocidade; // atributo da classe
// métodos construtores
public MaquinaLavar(int velocidade){
this.velocidade=velocidade; // this, define que é o atributo velocidade da classe recebe
// a variável velocidade do método MaquinaLavar
}
//métodos
public int aumentarVelocidade (){ // método usado para aumentar a velocidade da maquina
return velocidade++; // retorna o valor da velocidade + 1
}
public int diminuirVelocidade(){ // método usado para diminuir a velocidade da maquina

return --velocidade; // retorna o valor da velocidade -1
}
public int obterVelocidade(){ // método usado para coletar o valor da velocidade

return velocidade; // retorna o valor da velocidade
}
public void setVelocidade(){ // Método usado para verificar o valor da velocidade
if (velocidade<0) { // se velocidade menor que zero. Zerar o valor

System.out.print("Velocidade invalida.\n Parando motor...");
velocidade =0;
if (velocidade>100){ // se velocidade maior que 100. Voltar a 99.

System.out.print("Hiperaquecimento. Reduzindo velocidade para 99");
velocidade=99;
}
}
// método usado para desenvolver a aplicação

int y=0,x=0;
MaquinaLavar veloMaquina = new MaquinaLavar(0);
do
{
y=veloMaquina.diminuirVelocidade();
x++;

55
} while(x<5);
System.out.print(y);
veloMaquina.setVelocidade();
}
}
4. Compilar e executar veja o resultado:
5 Velocidade inválida
 Execute 18: Exemplo de criação de classes e métodos.

1. Abra o Jcreator.
Lampada.java

//Lampada.java
public class Lampada {
//atributos
boolean ligada;
int y;
//construtores
public Lampada() {
ligada = true;
}
public Lampada(boolean ligada){
this.ligada = ligada;
}
public Lampada(int z){

y=z;
}
//métodos
public void seLigada(){
if ((ligada ==true) || (y==1))
{
System.out.print("A lampada esta ligada");
}
else
{
System.out.print("A lampada não esta ligada");
}
}

56
// programa principal
Lampada neon = new Lampada();
neon.ligada=false;
neon.seLigada();
}
}
4. Compilar e executar veja o resultado:
A lampada não esta ligada
11) Acessibilidade
Acessibilidade de uma classe, método ou atributo de uma classe é a forma como que tal
pode ser visto e utilizado por outras classes. Este conceito é mais conhecido como
encapsulamento (ocultando dados) sendo muito importante dentro da orientação a objeto.
A determinação de acessibilidade de uma classe ou membro de uma classe é feita pelos
qualificadores de acesso, ou seja palavras reservadas da linguagem que determina o grau
de encapsulamento exibe por uma classe ou elementos. Abaixo uma pequena tabela
esquematizando a acessibilidade de elementos declarados em uma classe.
Métodos e Atributos da Implementação da Classe Instância da Classe

Classe
Private sim não
Protected sim não
Package sim sim
Public sim sim
12) Dicas para o projeto de classes

Mantenha os dados da classe como privados: Assim são necessários métodos de acesso
para os atributos. por exemplo:
// atributo
private double frequencia;
// método de acesso
public double getFrequencia(){
return frequencia;
57
// método de alteração
public void setFrequencia(double f){
frequencia = f;
}
Se os dados não podem ser privados faça-os protegidos
Sempre inicialize atributos e variáveis. Por exemplo:
public class Exemplo{

//atributos
private int a;
private int b
//construtor
public Exemplo(){
a = 0;
b = 0;
}
}
Evite o uso de muitos tipos básicos em uma classe.
Nem todos os atributos necessitam de métodos de acesso.
Padronize a estrutura de suas classes.
Divida classes com muita responsabilidade.
Utilize nomes significativos na denominação das classes.
13) Heranç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 ou superclasse e as classes filho são chamadas de classes derivadas ou
subclasses. Este mecanismo sugere que uma classe poderia ser definida em termos mais

58
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.
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. Por exemplo:
//Superclasse.java
public class SuperClasse {
.
.
.
}
//SubClasse.java
public class SubClasse extends SuperClasse {
.
.
.
}
 Execute 19: Exemplo de criação de classes e métodos –

Herança e Acessibilidade.
1. Abra o Jcreator.
LiquidificadorGenerico.java

//LiquidificadorGenerico.java
public class LiquidificadorGenerico {

//atributos
protected int velocidade;
protected int velocidadeMaxima;
//Construtores
public LiquidificadorGenerico( ){
velocidade = 0;
velocidadeMaxima = 2;
}
public LiquidificadorGenerico(int v){

this( );
ajustarVelocidadeMaxima(v);
}

59
//métodos
protected void ajustarVelocidadeMaxima(int v) {
if (v > 0)
velocidadeMaxima = v;
}
protected void ajustarVelocidade(int v){

if (v > 0 && v<=velocidadeMaxima)
velocidade = v;
}
public int obterVelocidadeMaxima( ) {

return velocidadeMaxima;
}
public int obterVelocidade( ){

return velocidade;
}
}
4. Compilar
LiquidificadorAnalogico.java

//LiquidificadorAnalogico.java
public class LiquidificadorAnalogico extends LiquidificadorGenerico {

//construtor
public LiquidificadorAnalogico( ){
velocidade =0 ;
}
//métodos
public void aumentarVelocidade(){
ajustarVelocidade(velocidade +1);
}
public void diminuirVelocidade( ){

ajustarVelocidade(velocidade –1);
}
}
7. Compilar
LiquidificadorDigital.java

60

//LiquidificadorDigital.java
public class LiquidificadorDigital extends LiquidificadorGenerico {

//construtor
public LiquidificadorDigital( ){
velocidade =0 ;
}
//métodos
public void trocarVelocidade(int v){
// aciona método protegido para troca de velocidade
ajustarVelocidade(v);
}
}
10. Compilar
LiquidificadorTestar.java
12. Monte uma aplicação para utilizar os atributos e métodos das classes
LiquidificadorAnalogico e LiquidificadorDigital
13. Compilar e executar.
14) Classes Abstratas

Em algumas circunstâncias desejamos orientar como uma classe deve ser implementada,
ou melhor, como deve ser a interface de uma certa classe. Em outros casos, o modelo
representado é tão amplo que certas classes tornam-se por demais gerais, não sendo
possível ou razoável que possuam instâncias. Para estes casos dispomos das classes
abstratas
Tais classes são assim denominadas por não permitirem a instanciação, isto é, por não
permitirem a criação de objetos do seu tipo. Sendo assim seu uso é dirigido para a
construção de classes modelo, ou seja, de especificações básicas de classes através do
mecanismo de herança.
Uma classe abstrata deve ser estendida, ou seja, deve ser a classe base de outra, mais
especifica que contenha os detalhes que não puderam ser incluídos na superclasse
(abstrata). Outra possível aplicação das classes abstratas é a criação de um ancestral
comum para um conjunto de classes que, se originados desta classe abstrata, poderão
ser tratados genericamente através do polimorfismo.

61
Uma classe abstrata, como qualquer outra, pode conter métodos mas também pode
adicionalmente conter métodos abstratos, isto é, métodos que deverão ser
implementados em suas subclasses não abstratas.
Sintaxe classe abstrata:
public abstract class NomedaClasse {
// código aqui
}
Sintaxe do método abstrato:

public abstract retorno nomeDoMetodo(argumentos...){
// código aqui
}
Para definir uma classe ou método abstrato basta acrescentar o qualificador abstract a
classe ou ao método. Métodos abstratos obrigam que as subclasses tenham que
implementá-los.
15) Interface
O Java permite a definição de um tipo especial de classe denominada interface. Uma
interface é uma classe que permite obter resultados semelhantes aos obtidos com a
herança múltipla, isto é, permite o compartilhamento das interfaces das classes
envolvidas sem o compartilhamento de suas implementações, levando ao extremo o
conceito da orientação à objetos.
Isto significa que, embora o Java não oferece os mecanismos de herança múltipla
(quando uma classe compartilha a interface e implementação de várias classes base
simultaneamente), é possível obter-se a melhor parte da herança múltipla (ao
compartilhamento apenas da interface da classe) através deste novo mecanismo. O nome
interface se origina exatamente do fato que o que se pretende é uma definição
compartilhável da interface propriamente dita de uma classe mas não de sua
implementação efetiva.
A vantagem de utilizar-se as interfaces é a definição de um protocolo entre classes, isto é,

uma especificação do que uma classe deve oferecer e implementar em termos de seus
métodos o que resulta numa poderosa abstração.
Uma interface pode ser declarada como exemplificado a seguir:
interface NomeDaInterface {
// declaração de atributos
// declaração de métodos sem implementação

62
Os métodos deverão obrigatoriamente ser implementados nas classes que utilizarem a

interface.
Exercícios de Revisão Capítulo V

Construir um conjunto de classes que permita realizar os cálculos da folha de pagamento de acordo com o
tipo de empregado. Fazer uso de uma superclasse abstrata Trabalhador. As subclasses de Trabalhador são:
• TrabalhadorChefe: pago com um salário fixo semanal independente do número de horas trabalhadas.
• TrabalhadorComissão: pago com um salário básico simples mais uma porcentagem sobre os itens
vendidos.
• TrabalhadorProdução: pago pelo número de itens produzidos.
• TrabalhadorHorista: pago por hora com um adicional de hora extra.
As subclasses de Trabalhador devem implementar uma interface que contenha pelo menos o método cálculo.
A classe Trabalhador deve conter um construtor que aceite o nome e o sobrenome do empregado como
parâmetros. A classe também deve conter os seguintes métodos:
• getPrimeiroNome que retorna o nome.
• getSobrenome que retorna o sobrenome.
• toString que retorna o nome e o sobrenome separados por um espaço.
A classe Trabalhador Chefe deve conter um construtor que aceita um nome, um sobrenome e um salário
semanal como argumentos. A classe também deve conter os seguintes métodos:
• setSalarioSemanal para atribuir um novo valor à variável de instância privada salarioSemanal.
• Calculo para calcular o valor do salário de um chefe
• ToString que forma um String contendo o tipo de empregado (isto é, “Chefe: “) seguido pelo nome
do empregado chefe e o salário que recebe.
A classe TrabalhadorComissao deve conter um construtor que aceita um nome, um sobrenome, um salário,
uma comissão e uma quantidade de itens vendidos como argumentos. A classe também dever conter os
seguintes métodos:
• setSalario, setComissao e setQuantidade para atribuir um novo valor às variáveis de instância
privativas salário, comissão e quantidade, respectivamente.
• calculo para calcular o valor do salário de um trabalhador por comissão
• toString que forma um String contendo o tipo do empregado (Isto é, “Trabalhador por comissão:”)
seguido pelo nome do empregado e o salário que recebe.
A classe TrabalhadorProducao deve conter um construtor que aceita um nome, um sobrenome, um salário
por item produzidos, uma quantidade de itens produzidos. A classe também deve conter os seguintes métodos:
• setSalario e setQuantidade para atribuir um novo valor ás variáveis de instância privativas salario e
quantidade, respectivamente.
• calculo para calcular o valor do salário de um trabalhador por produção
• toString que forma um String contendo o tipo do empregado (isto é,”Trabalhador por produção”)
A classe TrabalhadorHorista deve conter um construtor que aceita um nome, um sobrenome, um salário e
uma quantidade de horas trabalhadas. A classe também deve conter os seguintes métodos:

63
• setSalario e setQuantidade para atribuir um novo valor às variáveis de instância privativas salario e
horas.
• calculo para calcular o valor do salário de um trabalhador horista.
• ToString que forma uma String contendo o tipo de empregado (isto é ,“Trabalhador Horista: “)
Deve ser feito uma aplicação para utilizar essas classes.

64
Capitulo VI – Aplicações Gráficas com a AWT
1) Introdução
Aplicações gráficas são aquelas destinadas a execução dentro dos ambientes gráficos
oferecidos por vários sistemas operacionais. Uma GUI é um ambiente que oferece uma
interface mais simples e intuitiva para os usuários.
Cada sistema operacional pode oferecer GUIs com aparências distintas.
A linguagem Java oferece capacidades únicas no desenvolvimento de aplicações gráficas

que, sem modificação ou recompilação, podem ser executadas em diferentes ambientes
gráficos, uma vantagem significativa além do próprio desenvolvimento de aplicações
gráficas.
Um dos elementos chave do sucesso das GUIs é a utilização de componentes

padronizados para representação e operação da interface em si. Um componente GUI é
um objeto visual com o qual o usuário pode interagir através do teclado ou mouse,
permitindo realizar uma ou algumas dentre diversas operações: entrada de valores
numéricos ou de texto, a seleção de itens em listas, a marcação de opções, o desenho
livre, o acionamento de operações etc.
O Java oferece uma ampla biblioteca de componentes GUI e de capacidades gráficas na

forma de classe pertencentes ao seu pacote java.awt, mais conhecido como AWT. A AWT
oferece classes comuns e abstratas relacionadas a renderização e obtenção de
informações do sistema gráfico oferecido pela plataforma sobre a qual opera a máquina
virtual Java.
2) Construindo uma aplicação Gráfica

Para construir uma aplicação gráfica é necessário projetar uma interface para a aplicação,
isto é, é necessário selecionar quais os componentes serão utilizados, qual o objetivo de
sua utilização e qual a disposição desejada para tais componentes. A partir desse
planejamento básico devemos adicionar código para praticamente tudo pois o SDK não
oferece uma interface para construção visual de interfaces gráficas tal como o Visual
Basic ou Borland Delphi.
A implementação de uma aplicação gráfica envolve três passos simples:
Instanciação dos componentes selecionados: cada componente a ser adicionado na

interface deve ser individualmente instanciado. Como um componente é uma classe,
basta instanciar um objeto da classe desejada para criarmos um componente. Se for
necessário referenciar o componente posteriormente deve ser mantida uma variável para
tal finalidade.

65
Adição do componente na interface: todos os componentes que deverão ser exibidos na

interface devem ser individualmente adicionado a esta, ou seja, cada um dos
componentes deve ser adicionado a janela.
Registro dos métodos processadores de eventos: a interface das aplicações é

verdadeiramente renderizada pela GUI oferecida pelo sistema operacional. Assim sendo,
quando ocorre a interação do usuário com a aplicação através do teclado ou mouse, o
sistema operacional envia para a aplicação responsável pela janela uma série detalhada
de mensagens narrando o tipo e forma da interação do usuário métodos especiais
capazes de receber tais mensagens devem ser adicionados a aplicação e associados aos
componentes que desejamos ser capazes de reagir à interação com o usuário.
3)Componentes básicos
Como mencionado anteriormente o pacote java.awt.Component é a base para construção

de todos os componentes GUI oferecidos pelo Java através o pacote java.awt. Esta
classe oferece a infra-estrutura necessária para criação de objeto que possuam uma
representação gráfica que pode ser exibida na tela e com a qual o usuário pode interagir.
Os componentes básicos são listados abaixo:
Componente Classe Pacote Função
Button Button java.awt Criar botões
Checkbox Checkbox java.awt Criar caixa de opções
CheckboxGroup CheckboxGroup java.awt Criar um grupo de botões de opção
Choice Choice java.awt Criar Caixa de seleção
Frame Frame java.awt Criar janela completa
Label Label java.awt Criar rótulo de texto
List List java.awt Criar caixa de listagem
Menu Menu java.awt Criar menus
MenuBar MenuBar java.awt Criar barra de menu
MenuItem MenuItem java.awt Criar item de menu
Panel Panel java.awt Criar paineis

66
TextArea TextArea java.awt Criar caixa multlinha de texto
TextField TextField java.awt Criar uma caixa de entrada de texto
Window Window java.awt Criar janela simples
4)Criando Janelas (Frames)

O componente java.awt.Frame é uma janela do sistema gráfico que possui uma barra de
título e bordas, comportando-se como uma janela normal da GUI. Como é uma sub-classe
do java.awt.Container que pode conter outros componentes sendo está sua finalidade.
 Execute 20: Exemplo de criação de Janela usando componente

Frame.
1. Abra o Jcreator.
Janela.java.
//Janela.java
import java.awt.*; // importar o pacote java para utilizar os componentes.
public class Janela extends Frame{
//Construtor
public Janela() {
super(); // constroe a janela a partir da classe Frame
setSize(320,240); // define o tamanho da janela
setLocation(50,50);
}
static public void main(String args[ ]){
Janela j = new Janela(); // instanciando o objeto da classe janela
j.show(); // exibindo a janela na tela
}
}
4. Compilar e executar a janela é mostrada a seguir:

67
Apesar da aparência esperada, das capacidades de dimensionamento e iconização, a

janela não é fechada quando acionamos a opção “Fechar”. Isto ocorre por não haver
métodos processadores de eventos capazes de receber tal mensagem encerrando a
aplicação.
Para que uma janela tenha seus eventos processados é necessário implementarmos um
processador de eventos específico. Existem basicamente duas opções para a solução
desta questão:
Utilizar a classe java.awt.event.WindowAdapter.
Utilizar a interface java.awt.event.WindowListener.
Vejamos o código do exemplo anterior modificado para implementação da interface

java.awt.event.WindowListener. Note a adição de uma nova diretiva import para
indicarmos o uso do pacote java.awt.event.

Frame.
1. Abra o Jcreator.
Janela2.java.

68
//Janela2.java
import java.awt.event.*; //importar o pacote para processadores de eventos
public class Janela2 extends Frame implements WindowListener{ //herança do Frame e interface
//WindowListener
//Construtor
public Janela2() {
setLocation(50,50);
addWindowListener(this); //adiciona a lista de eventos para esta classe
}
// métodos da interface WindowListener
public void windowClosing(WindowEvent e){ // método de evento quando fechar a janela
System.exit(0);
}
public void windowClosed(WindowEvent e){} //método de evento fechar a janela
public void windowIconified(WindowEvent e){} // método de evento a janela tornar-se ícone
public void windowOpened(WindowEvent e){} //método de evento abrir janela
public void windowDeiconified(WindowEvent e){} //método de evento a janela deixar de ser ícone
public void windowActivated(WindowEvent e){} // método de evento quando a janela ativa
public void windowDeactivated(WindowEvent e){} //método de evento quando a janela desativada
Janela2 j = new Janela2(); // instanciando o objeto da classe janela
}
}
4. Compilar e executar, a janela é mostrada a seguir:

69
Veja que é possível fechar a janela clicando no “Fechar”.
A outra solução exige uma implementação de uma classe em separado (um segundo
arquivo fonte) para o java.awt.event.WindowAdapter que possui um único método,
windowClosing, responsável por processar o evento de “fechar janela”, como mostrado
abaixo:

Frame.
1. Abra o Jcreator.
FecharJanela.java.

//FecharJanela.java
import java.awt.event.*; //importar o pacote para processadores de eventos
public class FecharJanela extends WindowAdapter{ //herança da classe WindowAdapter
public void windowClosing(WindowEvent e){ // método de evento quando fechar a janela
System.exit(0);
}
}
4. Compilar.
Janela3.java.

//Janela3.java
public class Janela3 extends Frame{
//Construtor
public Janela3() {
setLocation(50,50); //define a localização da janela nas coordenadas da tela x e y
addWindowListener(new FecharJanela()); //adiciona o evento FecharJanela
}
Janela3 j = new Janela3(); // instanciando o objeto da classe janela

70
}
}
7. Compilar e executar, a janela é mostrada a seguir:
Veja, é possível fechar a janela clicando no “Fechar”.
6) Criando Rótulos (Labels)

O componente java.awt.Label, conhecido também como rótulo de texto ou simplesmente
rótulo, é destinado a exibição de texto dentro de quaisquer componente do tipo container.
Os rótulos podem exibir uma única linha de texto a qual não pode ser modificada nem
editada pelo usuário, caracterizando um componente passivo. Métodos apropriados são
fornecidos para que o texto de um rótulo possa ser programaticamente obtido e
modificado bem como seu alinhamento.
 Execute 23: Exemplo de criação de Label.
1. Abra o Jcreator.
ExemploLabel.java.

71
//ExemploLabel.java
public class ExemploLabel extends Frame{ //herança da classe Frame

private Label l1;
private Label l2;
public ExemploLabel(){
super(“Exemplo de Label”); // constroe a janela do construtor Frame;
setSize(400,200); //define o tamanho do Frame
setLocation(50,50); //define a localização do frame
// instanciação dos objetos label
l1 = new Label(“Bem vindo a Hytec”);
l2 = new Label(“Java Básico”);
// alteração do layout do Frame ou seja da exibição no frame
setLayout(new FlowLayout());
add(l1); // adicionando o label 1 no frame
add(l2); //adicionando o label 2 no frame
}
static public void main(String args[]){
ExemploLabel e = new ExemploLabel(); // instancia a classe ExemploLabel
e.addWindowListener(new FecharJanela());
e.show(); // mostra a janela do frame
}
}
4. Compilar e executar. Veja o resultado abaixo:
1) Criando Botões (Button)

Os botões componentes encapsulados na classe java.awt.Button, são como painéis
rotulados com um texto que, quando acionados, podem provocar a execução de alguma
rotina ou seqüência de comandos. O acionamento dos botões é visualmente indicado
através de um efeito de afundamento de sua superfície. O texto associado ao botão, tal

72
como nos rótulos, não pode ser alterado pelo usuário embora isto possa ser realizado
através da aplicação.
 Execute 24: Exemplo de criação de Button.
1. Abra o Jcreator.
ExemploButton.java.

//ExemploButton.java
import java.awt.event.*; // importar o pacote para processar os eventos principalmente de cliques
//no botão deste exemplo
public class ExemploButton extends Frame implements ActionListener{ //classe Frame e interaface
//ActionListener
private Label l1;
private Button b1;
private int contar;
public ExemploButton(){
super(“Exemplo de Button”); // constroe a janela do construtor Frame;
setLayout(new FlowLayout());
// instanciação dos objetos

b1 = new Button(“Clique aqui”); // instanciando o botão
l1 = new Label(“Botão não foi usado”);
b1.addActionListener(this);
add(b1);
add(l1);
contar = 0;
}
public void actionPerformed(ActionEvent e){

if (e.getSource()==b1){
contar++;
l1.setText(“Botão já foi usado “+ contar+ “ vez(es).”);
}
}

ExemploButton e = new ExemploButton(); // instancia a classe ExemploButton
}
}

73
Depois de clicar no botão uma vez veja o resultado:
Depois de clicar no botão duas vezes veja o resultado:
2) Criando caixa de entrada de texto (TextField)
A Awt oferece através da classe java.awt.TextField o componente caixa de entrada de

texto ou apenas caixa de texto. Este componente possibilita a edição e entrada de uma
única linha de texto de forma bastante conveniente para o usuário. Todo e qualquer dado
inserido através deste componente é tratado primariamente como texto, devendo ser
convertido explicitamente para outro tipo caso desejado.
 Execute 25: Exemplo de criação de Button.
1. Abra o Jcreator.
ExemploTextField.java.

//ExemploTextFieldjava
import java.awt.event.*; // importar o pacote para processar os eventos principalmente de cliques no botão
//neste exemplo

74
public class ExemploTextField extends Frame implements ActionListener{ //classe Frame e interaface
//ActionListener
private TextField tx1,tx2,tx3,tx4;
private Button b1;
public ExemploTextField(){
super(“Exemplo de TextField”); // constroe a janela do construtor Frame;
setLayout(new FlowLayout()); // define o layout do frame

tx1 = new TextField(); // instanciando o TextField
add(tx1);
tx2 = new TextField(“”,20); // instanciando o TextField
add(tx2);
tx3 = new TextField(“Ola!”); // instanciando o TextField
add(tx3);
tx4 = new TextField(“Edite-me”,30); // instanciando o TextField
add(tx4);
tx4.addActionListener(this);
b1 = new Button(“tx3->tx2”);
add(b1);
}

if (e.getSource()==b1){
tx2.setText(tx3.getText());
tx3.setText(“”);
}
if (e.getSource()==tx4){
tx3.setText(tx4.getText());
tx4.setText(“”);
}
}
ExemploTextField e = new ExemploTextField(); // instancia a classe ExemploTextField
}
}

75
3) Criando Painéis (Panel)

O componente java.awt.Panel ou Painel é um componente tipo container, ou seja é um
componente que permite dispor outros componente inclusive outros paineis, oferecendo
grande versatilidade na disposição de elementos na interface da aplicação. Cada painel
pode assumir uma diferente disposição para seus componentes, ampliando as
possibilidades de seu uso através dos Gerenciadores de Layout.
 Execute 26: Exemplo de criação de Panel.
1. Abra o Jcreator.
ExemploPainel.java.

//ExemploPainel
import java.awt.event.*; // importar o pacote para processar os eventos principalmente de cliques no botão
//neste exemplo
public class ExemploPainel extends Frame implements ActionListener{ //classe Frame e interaface
//ActionListener
private TextField entrada;
private Label l1,l2;
private Button btlimpar, bttransf, btok;
private Panel pacima,pabaixo,pdireita;
// construtor
public ExemploPainel(){
super(“Exemplo de Painel”); // constroe a janela do construtor Frame;

l1 = new Label(“Entrada”); // instanciando o Label l1
l2 = new Label(“Saída”); // instanciando o Label l2
entrada = new TextField(20); // instanciando o TextField
btlimpar = new Button(“Limpar”);
btlimpar.addActionListener(this);
bttransf = new Button(“Transferir”);
76
bttransf.addActionListener(this);
btok = new Button(“OK”);
btok.addActionListener(this);
pacima = new Panel(new FlowLayout(FlowLayout.LEFT)); // gerenciador FlowLayout
pabaixo= new Panel(new GridLayout(1,2)); // gerenciador GridLayout
pdireita = new Panel();
//adição dos componentes

pacima.add(l1); //adicionando o Label l1 ao Painel pacima
pacima.add(entrada); //adicionando o TextField entrada ao Painel pacima
add(pacima, BorderLayout.CENTER); //adicionando o Painel pacima ao frame no centro
pdireita.add(l2); //adicionando o Label l2
add(pdireita,BorderLayout.EAST); //adicionando o Painel pdireita ao frame a direita
pabaixo.add(btlimpar); //adicionando o botão btlimpar ao Painel pabaixo
pabaixo.add(bttransf); //adicionando o botão bttransf ao Painel pabaixo
pabaixo.add(btok); //adicionando o botão btok ao Painel pabaixo
add(pabaixo,BorderLayout.SOUTH); // adicionando o Painel pabaixo ao frame abaixo.
// Interface ActionListener
if (e.getSource()==btlimpar){
entrada.setText(“”);
} else if (e.getSource()==bttransf) {
l2.setText(entrada.getText());
}
else { //fechar a aplicação

System.exit(0);
}
}

ExemploPainel p = new ExemploPainel();
p.addWindowListener(new FecharJanela());
p.show();

77
4) Criando caixa de entrada multilinha ou memo (TextArea)

Este componente, conhecido como caixa de entrada multilinha ou memo, permite a
criação de uma área para entrada e edição de texto contendo múltiplas linhas de forma a
poder conter até mesmo mais texto do que possa ser exibido. Pertence a classe
java.awt.TextArea.
 Execute 27: Exemplo de criação de TextArea.
1. Abra o Jcreator.
ExemploTextArea.java.

//ExemploTextArea.java
import java.awt.*; // importa o pacote java para utilizar os componentes.
import java.awt.event.*; // importa o pacote para processar os eventos principalmente de cliques
//no botão deste exemplo
public class ExemploTextArea extends Frame implements ActionListener{ //classe Frame e

//interface ActionListener
private TextArea taeditor;
private Button btestado;
private TextField txentrada,txposicao;
// construtor
public ExemploTextArea(){
super(“Exemplo de TextArea”); // constroe a janela do construtor Frame;

txentrada = new TextField(20);
txentrada.addActionListener(this);
txposicao = new TextField(3);
txposicao.addActionListener(this);
btestado = new Button(“on/off”);
btestado.addActionListener(this);
taeditor = new TextArea();
// criar painel
Panel p = new Panel();
p.setLayout(new FlowLayout()); //usando o gerenciador de layout FlowLayout
//adicionando os componentes no painel

p.add(txentrada);
p.add(txposicao);
p.add(btestado);
//adiciona painel no topo do frame

78
add(p, BorderLayout.NORTH);
//adiciona o TextArea no centro do frame
add(taeditor, BorderLayout.CENTER);
}
// Interface ActionListener
if (e.getSource()==btestado){
taeditor.setEditable(!taeditor.isEditable());
} else if (e.getSource()==txentrada) {
taeditor.append(txentrada.getText());
txentrada.setText(“”);
} else if (e.getSource()==txposicao){
//insere a entrada do texto na posicao indicada
taeditor.insert(txentrada.getText(),Integer.parseInt(txposicao.getText()));
txentrada.setText(“”);
txposicao.setText(“”);
}
}

ExemploTextArea t = new ExemploTextArea();
t.addWindowListener(new FecharJanela());
t.show();

79
11) Criando caixa de lista (List)

O Componente java.awt.List, conhecido como caixa de lista, permite a exibição de uma
lista de itens com as seguintes características:
• os itens não podem ser editados diretamente pelo usuário;
• uma barra de rolagem vertical é exibida automaticamente quando a caixa de lista

contêm mais itens do que pode exibir;
• pode ser configurado para permitir a seleção de um único item ou múltiplos itens e
• quando se clica num item não selecionado este passa a estar selecionado e vice-
versa.
Este componente basicamente produz dois tipos de eventos:
java.awt.event.ItemEvent quando ocorre a seleção de um item e

java.awt.event.ActionEvent quando o usuário dá um duplo clique sobre um item e pela
lista. Estes eventos requerem tratamento por listeners diferentes respectivamente como
as interfaces: java.awt.event.ItemListener e java.awt.event.ActionListener.
 Execute 28: Exemplo de criação de List.
1. Abra o Jcreator.
ExemploList.java.
3. Digite o código abaixo:

//ExemploList.java
import java.awt.*;
import java.awt.event.*;
public class ExemploList extends Frame implements ItemListener, ActionListener {

// atributos
private Label lbexibicao; // variáveis do label
private List cxlista; // variável do List
private TextField txentrada; // variável do TextField
private Panel pnorte,pcentro,psul; // variáveis dos paineis
// Construtor
public ExemploList(){
super("Exemplo de List");
80
setSize(200,300);
//instancia dos objetos

lbexibicao = new Label(" sem seleção");
lbexibicao.setBackground(SystemColor.control); // cor de fundo igual painel
cxlista = new List(6);
cxlista.addItemListener(this);
cxlista.addActionListener(this);
txentrada = new TextField(20);
txentrada.addActionListener(this);
// adicionando os objetos no Frame

add(lbexibicao,BorderLayout.NORTH); // adicionando o label no norte
add(cxlista,BorderLayout.CENTER); // adicionando o list central
add(txentrada,BorderLayout.SOUTH); // adicionando o textfield no sul
}
// métodos da interface ItemListener

public void itemStateChanged(ItemEvent e){
if (e.getSource()==cxlista){
// testa se existe seleção
if (cxlista.getSelectedIndex()>-1)
//existe item na lista
lbexibicao.setText("Seleção: "+cxlista.getSelectedItem());
else
lbexibicao.setText(" sem seleção");
}
}
// métodos da interface ActionListener

if (e.getSource()==txentrada){
// inclui entrada na lista
cxlista.add(txentrada.getText());
txentrada.setText("");
} else if (e.getSource()==cxlista){
//remove o item indicado
txentrada.setText(cxlista.getSelectedItem());
cxlista.remove(cxlista.getSelectedIndex());
}
}
// método main
public static void main (String a[]){
ExemploList l = new ExemploList();
l.addWindowListener(new FecharJanela());
l.show();
}
}

81
4. Compilar e executar. Veja a resultado abaixo:
12) Criando caixa de seleção (Choice)

O componente java.awt.Choice implementa uma lista de itens onde somente o item
selecionado é exibido. A lista exibida como um menu suspenso pode ser vista através do
acionamento de um botão integrado ao componente, por isto é conhecido também como
caixa de seleção ou combobox.
 Execute 29: Exemplo de criação de Choice.
1. Abra o Jcreator.
ExemploChoice.java.

//ExemploChoice.java
import java.awt.*;
public class ExemploChoice extends Frame implements ItemListener{

// atributos
private Label lbexibicao; // variável do componente label
82
private Choice cxselecao; // variável do componente choice
// Construtor
public ExemploChoice(){
super("Exemplo de Choice");
setSize(200,200);
// instancia do objetos
lbexibicao = new Label(" sem seleção ");
lbexibicao.setBackground(SystemColor.control);
cxselecao = new Choice();
cxselecao.add("Branco");
cxselecao.add("Vermelho");
cxselecao.add("Azul");
cxselecao.add("Verde");
cxselecao.addItemListener(this);
// adicionando os objetos no frame

add(lbexibicao,BorderLayout.NORTH);
add(cxselecao,BorderLayout.CENTER);
}
// métodos da interface ItemListener

if (e.getSource()==cxselecao){
// testa se existe a selecao
if (cxselecao.getSelectedIndex()>-1){
// exibe o item selecionado
lbexibicao.setText(cxselecao.getSelectedItem());
switch (cxselecao.getSelectedIndex()){
case 0: setBackground(Color.white);break;
case 1: setBackground(Color.red);break;
case 2: setBackground(Color.blue);break;
case 3: setBackground(Color.green);break;
}
repaint(); // redesenha a janel com as cores selecionadas
} else
// limpa a exibicao
}
}
// metodo main
public static void main (String a[]){
ExemploChoice c = new ExemploChoice();
c.addWindowListener(new FecharJanela());
c.show();
}
}

83
13) Criando caixa de opção (Checkbox):

A caixa de opção, como também é conhecido o componente java.awt.Checkbox, é um
componente utilizado para representar graficamente uma opção que pode ser ligada ou
desligada. É geralmente utilizada para exibir um grupo de opções as quais podem ser
selecionadas independentemente pelo usuário, ou seja, permitem múltiplas seleções.
 Execute 30: Exemplo de criação de Checkbox.
1. Abra o Jcreator.
ExemploCheckbox.java.

//ExemploCheckbox.java
import java.awt.*;
public class ExemploCheckbox extends Frame implements ActionListener, ItemListener{
private Checkbox chnegrito,chitalico,chserif;

private TextField txexibicao, txtam;
// método main
ExemploCheckbox c = new ExemploCheckbox();

84
c.show();
}
// construtor
public ExemploCheckbox(){
super("Exemplo de Checkbox");
setSize(300,300);
// instanciação dos componentes

chnegrito = new Checkbox("Negrito",false);
chnegrito.addItemListener(this);
chitalico = new Checkbox("Itálico",false);
chitalico.addItemListener(this);
chserif = new Checkbox("Serifado",false);
chserif.addItemListener(this);
txexibicao = new TextField("Experimente o checkbox");
txtam = new TextField("12");
txtam.addActionListener(this);
// adicionando os componentes no frame

add(txexibicao,BorderLayout.CENTER);
p.setLayout(new GridLayout(1,4));
p.setBackground(SystemColor.control);
p.add(chnegrito);
p.add(chitalico);
p.add(chserif);
p.add(txtam);
add(p, BorderLayout.SOUTH);
}
// interface ActionListener
changeFont();
}
// interface ItemListener
changeFont();
}
// metodo changeFont()
private void changeFont(){
//testa estado de cada checkbox
int negr = (chnegrito.getState() ? Font.BOLD:Font.PLAIN);
int ital = (chitalico.getState() ? Font.ITALIC:Font.PLAIN);
int size = Integer.parseInt(txtam.getText());
if (chserif.getState())
txexibicao.setFont(new Font("Serif",negr+ital,size));
else
txexibicao.setFont(new Font("SanSerif",negr+ital,size));
}
}

85
4. Compilar e executar. Veja o resultado:
14) Criando Grupo de CheckBox (CheckboxGroup)

Como vimos, quando são adicionados vários componentes java.awt.Checkbox a uma
aplicação, é possível selecionar um, vários ou mesmo todos os componentes,
caracterizando uma situação de múltipla escolha, o que nem sempre é apropriado.
Quando desejamos que seja feita uma única escolha dentre um conjunto, necessitamos
de um componente com outro componente.
A awt, ao invés de oferecer um segundo componente permite que vários componentes

java.awt.Checkbox seja associado através de um outro denominado
java.awt.CheckBoxGroup não é um componente visual e apenas proporciona uma
associação de vários Checkbox de forma que se comportem como componentes
conhecidos como botões de opções. Os botões associados garantem que apenas um
esteja selecionado em qualquer instante, assim quando um deles é selecionado, qualquer
outro que estivesse selecionado é de-selecionado, garantindo uma escolha única dentre o
conjunto de opções apresentadas ao usuário.
 Execute 31: Exemplo de criação de CheckboxGroup.
1. Abra o Jcreator.
ExemploCheckBoxGroup.java.
//ExemploCheckBoxGroup.java

86
import java.awt.*;
public class ExemploCheckBoxGroup extends Frame implements ItemListener{
private Checkbox chbranco,chvermelho,chazul,chverde;

private CheckboxGroup cgcores;
// metodo main
ExemploCheckBoxGroup c = new ExemploCheckBoxGroup();
c.show();
}
// construtor
public ExemploCheckBoxGroup(){
super("Exemplo de CheckBoxGroup");
setSize(250,200);
// instanciação dos componentes

cgcores = new CheckboxGroup();
chbranco = new Checkbox("Branco",cgcores,true);
chvermelho = new Checkbox("Vermelho",cgcores,false);
chazul = new Checkbox("Azul",cgcores,false);
chverde = new Checkbox("Verde",cgcores,false);
chbranco.addItemListener(this);
chvermelho.addItemListener(this);
chazul.addItemListener(this);
chverde.addItemListener(this);
// adicionando componentes ao frame

p.setBackground(SystemColor.control);
p.setLayout(new GridLayout(4,1));
p.add(chbranco);
p.add(chvermelho);
p.add(chazul);
p.add(chverde);
add(p,BorderLayout.WEST);
}
// interface ItemListener
if (e.getSource()==chbranco){
setBackground(Color.white);
} else if (e.getSource()==chvermelho) {
setBackground(Color.red);
} else if (e.getSource()==chazul){
setBackground(Color.blue);
} else if (e.getSource()==chverde){
setBackground(Color.green);
}

87
repaint(); // redesenhar a tela

}
}
15) Criando Menus

Como esperado, a AWT oferece suporte bastante completo para criação de aplicações
utilizando barras de menus, menus suspensos e menus independentes através de um
conjunto de classes resumidamente descrito a seguir:
Classe Descrição
MenuComponent Classe abstrata que define o

comportamento e estrutura básica dos
elementos componentes de menus.
MenuItem Classe que define uma entrada simples de

menu
MenuBar Classe que define uma barra de menus para

uma aplicação
Menu Classe que define um menu suspenso
MenuShortCut Classe que define um atalho para um item

de menu
CheckboxMenuItem Classe que define uma entrada de menu

tipo opções
PopupMenu Classe que define um menu independente

88
Adicionar uma barra de menus contendo menus e itens de menus é bastante simples no
Java. Basta seguir intuitivamente a estrutura visual apresentada:
• Adicionar uma barra de menu a janela;
• Adicionar os menus suspensos a barra de menu;
• Adicionar os itens de menus desejados ou a cada um dos menus suspensos e
• Adicionar os listener necessários para ser possível que os menus e itens de menus
exibam funcionalidades.
Para criarmos a barra de menu fazemos: MenuBar barraMenu = new MenuBar();
Para cada menu suspenso declaramos e instanciamos um objeto Menu, como

exemplificado para menus suspensos “Arquivo”, “Editar” e “Ajuda”.
Menu menuArquivo = new Menu(“Arquivo”);
Menu menueditar = new Menu(“Editar”);
Menu menuAjuda = new Menu(“Ajuda”);
Para cada item de menu de cada menu item, declaramos e instanciamos objetos
MenuITem. Abaixo temos o código correspondente para itens de um possível menu
“Arquivo”.
MenuItem minovo = new MenuItem(“Novo”);
MenuItem miabrir = new MenuItem(“Abrir”);
MenuItem misalvar = new MenuItem(“Salvar”);
MenuItem misair = new MenuItem(“Sair”);
Agora adicionamos os itens de menu acima ao menu suspenso “Arquivo”. Note o uso do
método addSeparator para adicionar-se separadores aos itens de um menu suspenso:
MenuArquivo.add(minovo);
MenuArquivo.add(miabrir);
MenuArquivo.add(misalvar);
MenuArquivo.add(misair);
O mesmo deve ser feito para os demais menus da aplicação. Finalmente adicionamos os
menus suspensos a barra de menu e esta ao frame através do método setMenuBar.
BarraMenu.add(menuArquivo);
BarraMenu.add(menuEditar);
BarraMenu.add(menuAjuda);
SetMenuBar(barraMenu);

89
 Execute 32: Exemplo de criação de Menus.
1. Abra o Jcreator.
ExemploMenus.java.

//ExemploMenus.java
import java.awt.*;
public class ExemploMenus extends Frame implements ActionListener {

MenuBar barraMenu;
Menu menuArquivo,menueditar,menuajuda;
MenuItem minovo,miabrir,misalvar,misair,mirecortar,micopiar,micolar,miajuda,misobre;
public ExemploMenus(){
super("Exemplo de Menus");
setSize(300,100);
setLocation(50,50);
// barra de menu
barraMenu = new MenuBar();
// menus suspensos
menuArquivo = new Menu("Arquivo");
menueditar = new Menu("Editar");
menuajuda = new Menu("Ajuda");
// itens do menu arquivo

minovo = new MenuItem("Novo");
miabrir = new MenuItem("Abrir");
misalvar = new MenuItem("Salvar");
misair = new MenuItem("Sair");
misair.addActionListener(this);
// itens do menu editar

mirecortar = new MenuItem("Recortar");
micopiar = new MenuItem("Copiar");
micolar = new MenuItem("Colar");
// itens do menu ajuda

miajuda = new MenuItem("Ajuda");
misobre = new MenuItem("Sobre");
// adicionando os itens do menu arquivo
menuArquivo.add(minovo);
90
menuArquivo.add(miabrir);
menuArquivo.add(misalvar);
menuArquivo.add(misair);
// adicionando os itens do menu editar

menueditar.add(mirecortar);
menueditar.add(micopiar);
menueditar.add(micolar);
// adicionando os itens do menu ajuda

menuajuda.add(miajuda);
menuajuda.add(misobre);
// adicionando os menus suspensos a barra de menu

barraMenu.add(menuArquivo);
barraMenu.add(menueditar);
barraMenu.add(menuajuda);
// adicionando a barra de menu ao frame

setMenuBar(barraMenu);
}
if (e.getSource()==misair){ // implementação do menu sair

System.exit(0);
}
}
ExemploMenus m = new ExemploMenus();

m.addWindowListener(new FecharJanela());
m.show();
}
}
clique no menu arquivo escolha o menu sair.

91
Exercícios de Revisão do capitulo VI

1) Desenvolva uma aplicação com a seguinte tela:
Funcionalidades:
• botão Limpar: quando clicar neste botão todas as caixas de textos e label imc serão
limpos.
• botão Calcular IMC: quando clicar neste botão deverá ser mostrado no label imc o
cálculo do imc (índice de massa corpórea ). O imc é calculado da seguinte forma:
peso dividido pela altura (metros) ao quadrado. A tabela abaixo define a situação do
IMC:
IMC Situação
abaixo de 20 abaixo do peso normal
20 até 25 peso normal
acima de 25 até 30 sobrepeso
acima de 30 até 35 obesidade
acima de 35 obesidade mórbida
• No label imc deverá ser apresentado o valor do imc e a situação. Veja o exemplo:

92
Funcionalidades:
• Botão +: quando clicar nesse botão será efetuado a soma entre os dois números e
mostrar o resultado no label resultado.
• Botão /: quando clicar nesse botão será efetuado a divisão entre os dois números e
mostrar o resultado no label resultado.
• Botão *: quando clicar nesse botão será efetuado a multiplicação entre os dois
números e mostrar o resultado no label resultado.
• Botão -: quando clicar nesse botão será efetuado a subtração entre os dois números.
• Botão Limpar: quando clicar nesse botão limpar os TextFields e o label resultado.

93
A tela mostrada acima posui:

• Uma barra de menu;
• Dois menus: Exemplos e Sair.
• O menu Exemplos possui 3 itens: Calculo IMC, Calculadora e Exemplos de Vários
Objetos
• O menu Sair possui 2 itens: Sim e Não.
Funcionalidades:
• Quando clicar no item de menu Calculo IMC será executado a aplicação do

exercício 1 (Calculo IMC).
• Quando clicar no item de menu Calculadora será executado a aplicação do

exercício 2 (Calculadora).
• Quando clicar no item de menu Exemplos de Vários Objetos será executado a

aplicação do exercício 3 (Exemplos de Vários Objetos).
• Quando clicar no item de menu sim: deverá sair da aplicação.

94
Capítulo VII – Escrevendo applets Java
1) A diferença entre applets e aplicativos

A diferença entre applets e aplicativos Java está no modo como eles são executados.
Os aplicativos são executados utilizando um interpretador Java para carregar o arquivo de

classe principal do aplicativo. Normalmente, isso é feito a partir de um prompt de linha de
comando que usa a ferramenta java do SDK.
Por outro lado, os applets são executados em qualquer navegador que oferece suporte
para a linguagem Java.
Para que um applet seja executado, ele deve ser incluído em uma página da Web usando
tags HTML da mesma maneira que imagens e outros elementos são incluídos. Quando
um usuário com um navegador compatível com Java carrega uma página da Web que
inclui um applet, esse navegador faz o download do applet a partir de um servidor Web e
o executa no sistema do próprio usuário da Web. Não é necessário um interpretador Java
separado – já existe um incorporado ao navegador. Assim como um aplicativo, um applet
Java inclui um arquivo de classe e todas as outras classes auxiliares necessárias para
executá-lo. A biblioteca de classe Java padrão é incluída automaticamente.
Como os applets Java são executados dentro de um navegador Java, uma parte do
trabalho de criação de uma interface com o usuário já foi realizada para o programador.
Há uma janela na qual o applet pode ser executado, um lugar para apresentar elementos
gráficos e receber informações e a interface do navegador.
2) Criando applets
A maior parte dos programas Java que você criou até agora era formada de aplicativos
(programas simples com o método main()) que é utilizado para criar objetos, configurar
variáveis de instância e chamar outros métodos.
As applets não possuem um método main() que seja chamado automaticamente para
inciar o programa. Em vez disso, existem vários métodos que são chamados em
diferentes pontos na execução de um applet.
Todos os applets são subclasses da classe java.applet.
Todos os applets devem ser declarados public, pois a classe applet é uma classe pública.
3) Principais atividades do applet

Em vez de um método main(), os applets possuem métodos que são chamados, quando
ocorrem eventos específicos em sua execução.

95
Um exemplo desses métodos é paint(), que é chamado toda vez que a janela do applet
precisa ser apresentada ou reapresentada.
A seguir são descritos cinco dos métodos mais importante na execução de um applet:
incialização, partida, interrupção, destruição e pintura.
3.1) Incialização
A inicialização ocorre quando o applet é carregado. Ela pode incluir a criação dos objetos
de que o applet precisa, a configuração do estado inicial, o carregamento de imagens ou
fontes ou o ajuste de parâmetros. Para fornecer comportamento para inicialização de um
applet, você anula o método init() do seguinte modo:
public void init(){
//codigo aqui
Algo útil a fazer ao inicializar um applet é configurar a cor de sua janela de plano de
fundo. As cores são representadas na linguagem Java pela classe Color, parte do pacote
java.awt.Chame setBackground(Color) em um applet para aplicar a cor específica para o
plano de fundo na janela.
public void init(){
setBackground(Color.black);
3.2) Partida
A partida de um applet é realizada depois que ele é inicializado. Ela também pode ocorrer
se o applet tiver sido interrompido anteriormente. Por exemplo, um applet é interrompido
se o usuário do navegador segue um vínculo para uma página diferente e é reiniciado
quando o usuário retorna à página que contém o applet.
A partida pode ocorrer várias vezes durante o ciclo de vida de um applet, mas a
inicialização só ocorre uma vez. Para fornecer comportamento de início para seu applet,
anule o método start() do seguinte modo:
public void start(){
// código aqui

96
A funcionalidade que você coloca no método start() pode incluir o início de um thread
(aplicação em execução) para controlar o applet, o envio de mensagens apropriadas para
objetos auxiliares ou a solicitação para o applet começar a ser executado de alguma
maneira.
3.3) Interrupção
A interrupção e a partida andam lado a lado. A interrupção ocorre quando o usuário sai da
página que contém o applet que está sendo executado ou quando um applet interrompe
sua execução chamando stop().
public void stop() {
// código aqui
3.4) Destruição
A destruição soa mais escabrosa do que realmente é. O método destroy() permite que o
applet faça uma limpeza pouco antes de ser liberado da memória ou de sair do
navegador. Você pode usar esse método para acabar com todos os threads que
estiverem em execução ou para liberar todos os outros objetos que estiverem sendo
executados. Geralmente, você não desejará anular destroy(), a não ser que existam
recursos específicos que precisem ser liberados, como os threads que o applet criou.
Para fornecer comportamento de limpeza ao seu applet, anule o método destroy(), do
seguinte modo:
public void destroy(){
// código aqui
3.5) Pintura
É através da pintura que um applet apresenta algo na tela, seja texto, uma linha, um
fundo colorido ou uma imagem. Ela pode ocorrer centenas de vezes durante o ciclo de
vida de um applet: uma vez depois que o applet é inicializado; outra vez se a janela do
navegador ficar atrás de outra janela na tela; mais uma vez se a janela do navegador for

97
movida para uma posição diferente na tela etc. Para apresentar algo, você deve anular o
método paint() de sua subclasse Applet. Esse método tem a seguinte aparência:
public void paint(Graphics g){
// código aqui
 Execute 33: Exemplo de criação de applets.
1. Abra o Jcreator.
ExemploApplet.java.
3. Digite o codigo abaixo:

// ExemploApplet.java
import java.applet.Applet; // pacote da classe Applet
import java.awt.Graphics; // pacote da classe Graphics da awt
public class ExemploApplet extends Applet {

private int inicio;
private int partida;
private int pintura;
private int interrompe;
public void init(){

inicio++;
}
public void start(){

partida++;
}
public void paint(Graphics g){

pintura++;
// desenha os textos nas coordenadas
g.drawString("Inicio: "+inicio,5,15);
g.drawString("Partida:"+partida,5,30);
g.drawString("Pintura:"+pintura,5,45);
g.drawString("Interrompe:"+interrompe,5,60);
}
public void stop(){

98
interrompe++;
}
}
4. Compilar.
testaapplet.html
<html>
<body>
<applet code=”ExemploApplet.class” width=275 height=80> </applet>
</body>
</html>
6. Abra o internet explorer. Acesse o menu arquivo, opção abrir localize o arquivo
testaapplet.html dê duplo clique. Veja o resultado na tela a seguir:
Aumente o tamanho da tela. Veja o resultado.
Observe que só a variável pintura que mudou o seu valor
Acesse o menu applet e clique na opção stop a tela a seguir será exibida

99
Acesse o menu Applet, clique na opção restart. Observe variável interrompe mudou o
valor, a variável inicio mudou valor, a variável pintura mudou o valor.
1. Abra o Jcreator.
ExemploApplet2.java.

import java.awt.*;
import java.applet.*;
public class ExemploApplet2 extends Applet implements ActionListener

{
private Button b1, b2, b3, b4;
public void init()
{
b1 = new Button("Azul");
b2 = new Button("Verde");
b3 = new Button("Branco");
b4 = new Button("Preto");
add(b1);

100
add(b2);
add(b3);
add(b4);
b3.addActionListener( this);
b4. addActionListener( this);
}
public void actionPerformed(ActionEvent evt)
{
Object source = evt.getSource();
if (source == b1)
setBackground(Color.blue);
if (source == b2)
setBackground(Color.green);
if (source == b3)
setBackground(Color.white);
if (source == b4)
setBackground(Color.black);
}
}
4. Compilar
testaapplet2.html
<html>
<body>

101
<applet code="ExemploApplet2.class" width=200 height=200></applet>

</body>
</html>
6. Abra o internet explorer. Acesse o menu arquivo, opção abrir localize o arquivo
testaapplet2.html dê duplo clique. Veja o resultado na tela a seguir:

102
1. Abra o Jcreator.
ExemploApplet3.java.

import java.awt.*;
import java.applet.*;
public class ExemploApplet3 extends Applet implements ActionListener {

private Label L1;
private Button b1;
private int contar;
public void init(){

b1=new Button("Clique aqui");
L1=new Label("Botão não foi usado ");
add(b1);
add(L1);
contar=0;
}

if(e.getSource()==b1){
contar++;
L1.setText("Botão já foi usado "+contar+" vez(es).");
}
}
}
4. Compilar
testaapplet3.html
<html>
<body>
<applet code="ExemploApplet3.class" width=400 height=100></applet>
</body>
</html>

103
6. Abra o internet explorer. Acesse o menu arquivo, opção abrir, localize o arquivo
testaapple3.html dê um duplo clique. Veja o resultado na tela a seguir:
Exercícios de Revisão do capitulo VII

1. Desenvolva um applet para o exemplo de Label do capítulo VI: ExemploLabel.java
2. Desenvolva um applet para o exemplo de TextField do capítulo VI:

ExemploTextField.java
3. Desenvolva um applet para o exemplo de Panel do capítulo VI: ExemploPainel.java
4. Desenvolva um applet para o exemplo de TextArea do capítulo VI:

ExemploTextArea.java


Apostila de Java Básico

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Apostila de Java Básico

Enviado por

Direitos autorais:

Formatos disponíveis

1

SCRS 502 Bl. – C Ent. – 22º W2 Tel.: (61) 3225-7784

Execute 12: Exemplo de estrutura de controle FOR..........................................................................................34

13) Criando caixa de opção (Checkbox):.......................................................................................................83

SCRS 502 Bl. – C Ent. – 22º W2 Tel.: (61) 3225-7784

Capítulo I – Introdução ao Java

2.2) Orientada a Objeto

SCRS 502 Bl. – C Ent. – 22º W2 Tel.: (61) 3225-7784

verificação dinâmica (em tempo de execução) e na eliminação de situações sujeitas a

2.6) Neutra em Relação à Arquitetura

SCRS 502 Bl. – C Ent. – 22º W2 Tel.: (61) 3225-7784

4.1) Versões da linguagem

Alguns dos principais pacotes do java API

Java.applet Manipulação de aplicações applet

Java.awt Trabalhar com janelas e seus componentes

Java.io Manipulação de entradas e saídas

Java.lang Manipulação de padrões da linguagem

SCRS 502 Bl. – C Ent. – 22º W2 Tel.: (61) 3225-7784

Java.math Manipulação de definições matemáticas

Java.net Manipulação de rede

Java.text Manipulação de texto

Java.util Manipulação de utilidades

Javax.swing Trabalhar com janelas e seus componentes

6 – Ambientes de Desenvolvimento Integrado

Exercícios de Revisão Capítulo I:

SCRS 502 Bl. – C Ent. – 22º W2 Tel.: (61) 3225-7784

Capítulo II – Onde está instalado?

Em nossos computadores o SDK está instalado na pasta: c:\ j2sdk1.4.2_04, onde:

• A pasta BIN: contém o compilador (javac.exe), a máquina virtual (java), o visualizador

• A pasta DEMO: contém códigos fontes de demonstração de aplicações java.

• A pasta DOCS: contém a documentação do SDK

• A pasta INCLUDE: contém arquivos de biblioteca para execução de aplicações java.

• A pasta JRE: contém bibliotecas e utilitários para aplicações de rede.

• A pasta LIB: contém bibliotecas diversas utilizadas pelo java.

2. Acessar o windows explorer: (iniciar, programas, windows explorer)

3. Acessar o disco local (c:), acessar a pasta j2sdk1.4.2_04

4. Verifique as pastas instaladas.

SCRS 502 Bl. – C Ent. – 22º W2 Tel.: (61) 3225-7784

A seguinte tela será exibida:

4. Navegue pelos pacotes e suas classes.

 Execute 2: IDE JCreator

2. Clicar no botão iniciar, Programas, JcreatorV2LE, JcreatorLE

A seguinte tela será exibida:

SCRS 502 Bl. – C Ent. – 22º W2 Tel.: (61) 3225-7784

SCRS 502 Bl. – C Ent. – 22º W2 Tel.: (61) 3225-7784

Capítulo III – Primeiro Exemplo

1 – Primeiro Exemplo: Bem Vindo a Hytec!

 Execute 3: Digitando o primeiro exemplo

SCRS 502 Bl. – C Ent. – 22º W2 Tel.: (61) 3225-7784

public class BemVindo{ // classe BemVindo

Retornaremos a esta explicação posteriormente, por enquanto apenas é necessário

SCRS 502 Bl. – C Ent. – 22º W2 Tel.: (61) 3225-7784

3. Salvar o programa. Acesse o menu File, a opção Save All

4. Compilar o programa. Menu Build, opção Compile File.

5. Executar o programa. Menu Build, opção Execute File.

6. Programa apenas imprimiu a mensagem Bem Vindo a Hytec

Exercícios de Revisão Capítulo III:

SCRS 502 Bl. – C Ent. – 22º W2 Tel.: (61) 3225-7784

1 – Tipos Primitivos, Variáveis e Operadores

1.1) Tipos primitivos

Nome do Tipo Tipo Descrição

long inteiro Usado para descrever um

Int inteiro Usado para descrever um