Sunteți pe pagina 1din 103

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
Execute 21: Exemplo de criação de Janela usando componente Frame.............................................................67
Execute 22: Exemplo de criação de Janela usando componente Frame.............................................................69
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
SCRS 502 Bl. – C Ent. – 22º W2 Tel.: (61) 3225-7784
CEP - 70330-530 Brasília - DF
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

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


CEP - 70330-530 Brasília - DF
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

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


CEP - 70330-530 Brasília - DF
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

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


CEP - 70330-530 Brasília - DF
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

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


CEP - 70330-530 Brasília - DF
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?

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


CEP - 70330-530 Brasília - DF
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.

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


CEP - 70330-530 Brasília - DF
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

A seguinte tela será exibida:

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


CEP - 70330-530 Brasília - DF
10

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


CEP - 70330-530 Brasília - DF
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:

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


CEP - 70330-530 Brasília - DF
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

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


CEP - 70330-530 Brasília - DF
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.

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


CEP - 70330-530 Brasília - DF
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


dado que utiliza números
inteiros com tamanho menor
que o tipo long.Tamanho (4
byte).

short inteiro Usado para descrever um


dado que utiliza números
inteiros com tamanho menor
que o tipo int. Tamanho (2
byte)

byte inteiro Usado para descrever um


dado que utiliza números
inteiros com tamanho menor
que o tipo short. Tamanho (1
byte)

double ponto flutuante Usado para descrever um


dado que utiliza números
reais. Tamanho (8 byte)

float ponto flutuante Usado para descrever um


dado que utiliza números
reais com tamanho meno
que double. Tamanho (4
SCRS 502 Bl. – C Ent. – 22º W2 Tel.: (61) 3225-7784
CEP - 70330-530 Brasília - DF
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
SCRS 502 Bl. – C Ent. – 22º W2 Tel.: (61) 3225-7784
CEP - 70330-530 Brasília - DF
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

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


CEP - 70330-530 Brasília - DF
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

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


CEP - 70330-530 Brasília - DF
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

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


CEP - 70330-530 Brasília - DF
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:

Operador Significado Exemplo

== igual Usado para comparar se


uma expressão é igual à
outra. Por exemplo:

A=5 B=8

X = A == B

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


CEP - 70330-530 Brasília - DF
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

O valor de X é false, pois 5


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

O valor de X é false, pois 5


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

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


CEP - 70330-530 Brasília - DF
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 {


public static void main(String arg[]){

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

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


CEP - 70330-530 Brasília - DF
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.

Operador Significado Exemplo

&& 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

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


CEP - 70330-530 Brasília - DF
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

3. Digite o seguinte código:


//Logicos.java
public class Logicos {
public static void main(String arg[]){
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 =

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


CEP - 70330-530 Brasília - DF
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:


SCRS 502 Bl. – C Ent. – 22º W2 Tel.: (61) 3225-7784
CEP - 70330-530 Brasília - DF
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.

2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
StringDemo.java

3. Digite o seguinte código:


// 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.

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


CEP - 70330-530 Brasília - DF
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...”);
}

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


CEP - 70330-530 Brasília - DF
27

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


1. Abra o Jcreator.

2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
ExemploIF.java

3. Digite o seguinte código:


//ExemploIF.java

public class ExemploIF {


public static void main(String a[]){

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”
}
}
}
4. Compilar e Executar. Verifique o resultado:

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;
}

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


CEP - 70330-530 Brasília - DF
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;
case 2: System.out.println(“Item do menu 2”);
break;
case 3: System.out.println(“Item do menu 3”);
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).

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


CEP - 70330-530 Brasília - DF
29

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


1. Abra o Jcreator.

2. Acesse o menu File, opção new, opção file, Coloque o nome do arquivo de
ExemploSwitch.java

3. Digite o seguinte código:


//ExemploSwitch.java

public class ExemploSwitch {


public static void main(String a[]){
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.

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


CEP - 70330-530 Brasília - DF
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
salario = 270 + 10 portanto salario = 280
i-- portanto i é igual a 1 (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.

2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
ExemploWhile.java

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


CEP - 70330-530 Brasília - DF
31

3. Digite o seguinte código:


// ExemploWhile.java
public class ExemploWhile{
public static void main(String a[]){
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);

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


CEP - 70330-530 Brasília - DF
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 {
salario = 260 + 10 portanto salario = 270
i-- portanto i é igual a 2 (i!=0) repete
salario = 270 + 10 portanto salario = 280
i-- portanto i é igual a 1 (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
}enquanto i for diferente de 0
saiu do while

 Execute 11: Exemplo de Estrutura de Controle do{ }While


1. Abra o Jcreator.

2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
ExemploDoWhile.java

3. Digite o seguinte código:


// ExemploDoWhile.java

public class ExemploDoWhile {


SCRS 502 Bl. – C Ent. – 22º W2 Tel.: (61) 3225-7784
CEP - 70330-530 Brasília - DF
33

public static void main(String a[]){


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
}
}

4. Compilar e Executar. Verifique o resultado:


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;

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


CEP - 70330-530 Brasília - DF
34

Nesse exemplo ocorre a repetição:

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.

2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
ExemploFor.java

3. Digite o seguinte código:


//ExemploFor.java

public class ExemploFor {


public static void main(String a[]){
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
}
}
}

4. Compilar e Executar. Verifique o resultado:


10
9
8
7
6
5
4
3
2
1

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


CEP - 70330-530 Brasília - DF
35

Nesse exemplo ocorre a repetição:

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 =9 repete pois i > 0
exibe o valor de i =8 repete pois i > 0
exibe o valor de i =7 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){

Comandos de tratamento de erro2;

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


CEP - 70330-530 Brasília - DF
36

Tradução:

Tratar {

Comandos normais que será tratado;

} definir (exception1){

Comandos de tratamento de erro1;

} definir (exception2){

Comandos de tratamento de erro2;

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.

2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
TratamentoErros.java

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


CEP - 70330-530 Brasília - DF
37

3. Digite o seguinte código:


//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
}

}
}

4. Compilar e Executar. Verifique o resultado:

Impossível divisão por zero

 Execute 14: Exemplo de estrutura de erro try..finally

1. Abra o Jcreator.

2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
TratamentoErrosF.java

3. Digite o seguinte código:

//TratamentoErrosF.java

public class TratamentoErrosF {


public static void main(String args[]){
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
SCRS 502 Bl. – C Ent. – 22º W2 Tel.: (61) 3225-7784
CEP - 70330-530 Brasília - DF
38

} finally { // finaliza a execulção e exibe a mensagem de erro


System.out.println("Impossível divisão por zero");
}

}
}

4. Compilar e Executar. Verifique o resultado:

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

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


CEP - 70330-530 Brasília - DF
39

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


1. Abra o Jcreator.

2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
VetorTest.java

3. Digite o seguinte código:

//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
vetor[1]=10; // coloca na posição 1 o valor 10
vetor[2]=20; // coloca na posição 2 o valor 20
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
}

4. Compilar e Executar. Verifique o resultado:

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().

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


CEP - 70330-530 Brasília - DF
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.

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


CEP - 70330-530 Brasília - DF
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

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


CEP - 70330-530 Brasília - DF
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:
SCRS 502 Bl. – C Ent. – 22º W2 Tel.: (61) 3225-7784
CEP - 70330-530 Brasília - DF
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.

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


CEP - 70330-530 Brasília - DF
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

3. Digite o seguinte código:


//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;
}

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


CEP - 70330-530 Brasília - DF
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


public static void main(String a[]){

/* 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;
SCRS 502 Bl. – C Ent. – 22º W2 Tel.: (61) 3225-7784
CEP - 70330-530 Brasília - DF
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();
}

4. Compilar e Executar. Verifique o resultado:


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

3. Digite o seguinte código:

//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";

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


CEP - 70330-530 Brasília - DF
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;
SCRS 502 Bl. – C Ent. – 22º W2 Tel.: (61) 3225-7784
CEP - 70330-530 Brasília - DF
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


public static void main(String a[]){

// 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
p2.imprimirInfo(); // exibe informações do objeto p2

// 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
p1.imprimirInfo(); // exibe informações do objeto p1
p2.imprimirInfo(); // exibe informações do objeto p2
}
}
4. Compilar e Executar. Verifique o resultado:
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
SCRS 502 Bl. – C Ent. – 22º W2 Tel.: (61) 3225-7784
CEP - 70330-530 Brasília - DF
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
public static void main(String a[]){
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
}

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


CEP - 70330-530 Brasília - DF
50

4. Compilar e Executar. Verifique o resultado:


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.

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


CEP - 70330-530 Brasília - DF
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

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


CEP - 70330-530 Brasília - DF
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(){
SCRS 502 Bl. – C Ent. – 22º W2 Tel.: (61) 3225-7784
CEP - 70330-530 Brasília - DF
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.

2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
MaquinaLavar.java

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


CEP - 70330-530 Brasília - DF
54

3. Digite o seguinte código:


// 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


public static void main(String args[]){
int y=0,x=0;
MaquinaLavar veloMaquina = new MaquinaLavar(0);
do
{
y=veloMaquina.diminuirVelocidade();
x++;

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


CEP - 70330-530 Brasília - DF
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.

2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
Lampada.java

3. Digite o seguinte código:


//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");
}
}

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


CEP - 70330-530 Brasília - DF
56

// programa principal
public static void main(String args[]){
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;
SCRS 502 Bl. – C Ent. – 22º W2 Tel.: (61) 3225-7784
CEP - 70330-530 Brasília - DF
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

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


CEP - 70330-530 Brasília - DF
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.

2. Acesse o menu File, opção new, opção file, Coloque o nome do arquivo de
LiquidificadorGenerico.java

3. Digite o seguinte código:


//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);
}

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


CEP - 70330-530 Brasília - DF
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

5. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
LiquidificadorAnalogico.java

6. Digite o seguinte código:


//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

8. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
LiquidificadorDigital.java

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


CEP - 70330-530 Brasília - DF
60

9. Digite o seguinte código:


//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

11. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
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.

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


CEP - 70330-530 Brasília - DF
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

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


CEP - 70330-530 Brasília - DF
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”)
seguido pelo nome do empregado e o salário que recebe.

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:

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


CEP - 70330-530 Brasília - DF
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: “)
seguido pelo nome do empregado e o salário que recebe.

Deve ser feito uma aplicação para utilizar essas classes.

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


CEP - 70330-530 Brasília - DF
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.

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


CEP - 70330-530 Brasília - DF
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

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


CEP - 70330-530 Brasília - DF
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.

2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
Janela.java.

3. Digite o seguinte código:

//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);
}

// programa principal
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:


SCRS 502 Bl. – C Ent. – 22º W2 Tel.: (61) 3225-7784
CEP - 70330-530 Brasília - DF
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.

 Execute 21: Exemplo de criação de Janela usando componente


Frame.

1. Abra o Jcreator.

2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
Janela2.java.

3. Digite o seguinte código:

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


CEP - 70330-530 Brasília - DF
68

//Janela2.java
import java.awt.*; // importar o pacote java para utilizar os componentes.
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() {
super(); // constroe a janela a partir da classe Frame
setSize(320,240); // define o tamanho da janela
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

// programa principal
static public void main(String args[ ]){
Janela2 j = new Janela2(); // instanciando o objeto da classe janela
j.show(); // exibindo a janela na tela

}
}

4. Compilar e executar, a janela é mostrada a seguir:

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


CEP - 70330-530 Brasília - DF
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:

 Execute 22: Exemplo de criação de Janela usando componente


Frame.

1. Abra o Jcreator.

2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
FecharJanela.java.

3. Digite o seguinte código:


//FecharJanela.java
import java.awt.*; // importar o pacote java para utilizar os componentes.
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.

5. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
Janela3.java.

6. Digite o seguinte código:


//Janela3.java
import java.awt.*; // importar o pacote java para utilizar os componentes.
public class Janela3 extends Frame{
//Construtor
public Janela3() {
super(); // constroe a janela a partir da classe Frame
setSize(320,240); // define o tamanho da janela
setLocation(50,50); //define a localização da janela nas coordenadas da tela x e y
addWindowListener(new FecharJanela()); //adiciona o evento FecharJanela
}

// programa principal
static public void main(String args[ ]){
Janela3 j = new Janela3(); // instanciando o objeto da classe janela
j.show(); // exibindo a janela na tela

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


CEP - 70330-530 Brasília - DF
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.

2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
ExemploLabel.java.

3. Digite o seguinte código:

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


CEP - 70330-530 Brasília - DF
71

//ExemploLabel.java
import java.awt.*; // importar o pacote java para utilizar os componentes.

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

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


CEP - 70330-530 Brasília - DF
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.

2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
ExemploButton.java.

3. Digite o seguinte código:


//ExemploButton.java
import java.awt.*; // importar o pacote java para utilizar os componentes.
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;
setSize(280,70); //define o tamanho do 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).”);
}
}

static public void main(String args[]){


ExemploButton e = new ExemploButton(); // instancia a classe ExemploButton
e.addWindowListener(new FecharJanela());
e.show(); // mostra a janela do frame
}
}

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


CEP - 70330-530 Brasília - DF
73

4. Compilar e executar. Veja o resultado abaixo:

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.

2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
ExemploTextField.java.

3. Digite o seguinte código:


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

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


CEP - 70330-530 Brasília - DF
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;
setSize(250,150); //define o tamanho do Frame
setLayout(new FlowLayout()); // define o layout do frame

// instanciação dos objetos


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”);
b1.addActionListener(this);
add(b1);
}

public void actionPerformed(ActionEvent e){


if (e.getSource()==b1){
tx2.setText(tx3.getText());
tx3.setText(“”);
}
if (e.getSource()==tx4){
tx3.setText(tx4.getText());
tx4.setText(“”);
}
}
static public void main(String args[]){
ExemploTextField e = new ExemploTextField(); // instancia a classe ExemploTextField
e.addWindowListener(new FecharJanela());
e.show(); // mostra a janela do frame
}
}

4. Compilar e executar. Veja o resultado abaixo:

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


CEP - 70330-530 Brasília - DF
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.

2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
ExemploPainel.java.

3. Digite o seguinte código:


//ExemploPainel
import java.awt.*; // importar o pacote java para utilizar os componentes.
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;
setSize(400,120); //define o tamanho do Frame

// instanciação dos objetos


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”);
SCRS 502 Bl. – C Ent. – 22º W2 Tel.: (61) 3225-7784
CEP - 70330-530 Brasília - DF
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
public void actionPerformed(ActionEvent e){
if (e.getSource()==btlimpar){
entrada.setText(“”);
} else if (e.getSource()==bttransf) {
l2.setText(entrada.getText());
}

else { //fechar a aplicação


System.exit(0);
}
}

public static void main(String a[]){


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

4. Compilar e executar. Veja o resultado abaixo:

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


CEP - 70330-530 Brasília - DF
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.

2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
ExemploTextArea.java.

3. Digite o seguinte código:


//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;
setSize(300,300); //define o tamanho do Frame

// instanciação dos objetos


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


SCRS 502 Bl. – C Ent. – 22º W2 Tel.: (61) 3225-7784
CEP - 70330-530 Brasília - DF
78

add(p, BorderLayout.NORTH);
//adiciona o TextArea no centro do frame
add(taeditor, BorderLayout.CENTER);
}

// Interface ActionListener
public void actionPerformed(ActionEvent e){
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(“”);
}
}

public static void main(String a[]){


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

4. Compilar e executar. Veja o resultado abaixo:

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


CEP - 70330-530 Brasília - DF
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.

2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
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");
SCRS 502 Bl. – C Ent. – 22º W2 Tel.: (61) 3225-7784
CEP - 70330-530 Brasília - DF
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


public void actionPerformed(ActionEvent e){
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());
lbexibicao.setText(" sem seleção");
}
}

// método main
public static void main (String a[]){
ExemploList l = new ExemploList();
l.addWindowListener(new FecharJanela());
l.show();
}
}

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


CEP - 70330-530 Brasília - DF
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.

2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
ExemploChoice.java.

3. Digite o código abaixo:


//ExemploChoice.java
import java.awt.*;
import java.awt.event.*;

public class ExemploChoice extends Frame implements ItemListener{


// atributos
private Label lbexibicao; // variável do componente label
SCRS 502 Bl. – C Ent. – 22º W2 Tel.: (61) 3225-7784
CEP - 70330-530 Brasília - DF
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


public void itemStateChanged(ItemEvent e){
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
lbexibicao.setText(" sem seleção");
}
}

// metodo main
public static void main (String a[]){
ExemploChoice c = new ExemploChoice();
c.addWindowListener(new FecharJanela());
c.show();
}
}

4. Compilar e executar. Veja o resultado abaixo:

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


CEP - 70330-530 Brasília - DF
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.

2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
ExemploCheckbox.java.

3. Digite o código abaixo:


//ExemploCheckbox.java
import java.awt.*;
import java.awt.event.*;

public class ExemploCheckbox extends Frame implements ActionListener, ItemListener{

private Checkbox chnegrito,chitalico,chserif;


private TextField txexibicao, txtam;

// método main
public static void main(String a[]){
ExemploCheckbox c = new ExemploCheckbox();
c.addWindowListener(new FecharJanela());

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


CEP - 70330-530 Brasília - DF
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);
Panel p = new Panel();
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
public void actionPerformed(ActionEvent e){
changeFont();
}

// interface ItemListener
public void itemStateChanged(ItemEvent e){
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));
}
}

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


CEP - 70330-530 Brasília - DF
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.

2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
ExemploCheckBoxGroup.java.

3. Digite o código abaixo:

//ExemploCheckBoxGroup.java

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


CEP - 70330-530 Brasília - DF
86

import java.awt.*;
import java.awt.event.*;
public class ExemploCheckBoxGroup extends Frame implements ItemListener{

private Checkbox chbranco,chvermelho,chazul,chverde;


private CheckboxGroup cgcores;

// metodo main
public static void main(String a[]){
ExemploCheckBoxGroup c = new ExemploCheckBoxGroup();
c.addWindowListener(new FecharJanela());
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


Panel p = new Panel();
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
public void itemStateChanged(ItemEvent e){
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);
}

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


CEP - 70330-530 Brasília - DF
87

repaint(); // redesenhar a tela


}
}

4. Compilar e executar. Veja o resultado abaixo:

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

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


CEP - 70330-530 Brasília - DF
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);

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


CEP - 70330-530 Brasília - DF
89

 Execute 32: Exemplo de criação de Menus.

1. Abra o Jcreator.

2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
ExemploMenus.java.

3. Digite o código abaixo:


//ExemploMenus.java

import java.awt.*;
import java.awt.event.*;

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);
SCRS 502 Bl. – C Ent. – 22º W2 Tel.: (61) 3225-7784
CEP - 70330-530 Brasília - DF
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);
}

public void actionPerformed(ActionEvent e){

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


System.exit(0);
}
}

public static void main(String a[]){

ExemploMenus m = new ExemploMenus();


m.addWindowListener(new FecharJanela());
m.show();
}
}

4. Compilar e executar. Veja o resultado abaixo:

clique no menu arquivo escolha o menu sair.

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


CEP - 70330-530 Brasília - DF
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:

2) Desenvolva uma aplicação com a seguinte tela:

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


CEP - 70330-530 Brasília - DF
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.

3) Desenvolva uma aplicação com a seguinte tela:

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


CEP - 70330-530 Brasília - DF
93

4) Desenvolva uma aplicação com a seguinte tela:

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.

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


CEP - 70330-530 Brasília - DF
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.

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


CEP - 70330-530 Brasília - DF
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

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


CEP - 70330-530 Brasília - DF
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

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


CEP - 70330-530 Brasília - DF
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.

2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
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(){

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


CEP - 70330-530 Brasília - DF
98

interrompe++;
}
}

4. Compilar.

5. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
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:

A seguinte tela será exibida:

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

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


CEP - 70330-530 Brasília - DF
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.

 Execute 34: Exemplo de criação de applets.

1. Abra o Jcreator.

2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
ExemploApplet2.java.

3. Digite o codigo abaixo:


import java.awt.*;
import java.applet.*;
import java.awt.event.*;

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);

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


CEP - 70330-530 Brasília - DF
100

add(b2);
add(b3);
add(b4);
b1.addActionListener(this);
b2.addActionListener(this);
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

5. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
testaapplet2.html
<html>
<body>

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


CEP - 70330-530 Brasília - DF
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:

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


CEP - 70330-530 Brasília - DF
102

 Execute 35: Exemplo de criação de applets.

1. Abra o Jcreator.

2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
ExemploApplet3.java.

3. Digite o codigo abaixo:


import java.awt.*;
import java.awt.event.*;
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 ");
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).");
}
}
}

4. Compilar

5. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
testaapplet3.html
<html>
<body>
<applet code="ExemploApplet3.class" width=400 height=100></applet>
</body>
</html>

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


CEP - 70330-530 Brasília - DF
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

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


CEP - 70330-530 Brasília - DF