Professional Documents
Culture Documents
Í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
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.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
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.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
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.
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/
Pacotes Descrição
1 - O SDK
Execute 1: Documentação
1. Para verificar estas instalações siga os passos descritos abaixo:
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.
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.
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:
// BemVindo.java
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)
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
// 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.
Capítulo IV – Fundamentos
byte)
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.
<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
<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
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.
A=5 B=6
X = A + B.
O valor de X é 11.
A=8 B=6
X=A-B
O valor de X é 2.
A=5 B=6
X=A*B
O valor de X é 30
A = 30 B=6
X = A / B.
O valor de X é 5
A = 10 B=6
X=A%B
O valor de X é 4
A=5
X = -A
O valor de X é –5
A=5
X = ++a é igual X= A + 1
O valor de X é 6
A=5
X = --A é igual X = A - 1
O valor de X é 4
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:
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.
2. Acesse o menu File, opção new, opção file, Coloque o nome do arquivo de
Aritmeticos.java
A=5 B=8
X = A == B
A=5 B=8
X = A != B
A=5 B=8
X=A>B
A=5 B=8
X = A >= B
A=5 B=8
X=A<B
A=5 B=8
X = A <= B
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).
2. Acesse o menu File, opção new, opção file digite o nome do arquivo de
Relacionais.java, defina a localização.
}
}
o valor x é false
A B A && B
verdadeiro. x = a || b
o valor x é true
A B A || B
b = true
x = !a
y=!b
2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
Aritmeticos.java
}
}
4. Compilar e executar. Verifique o resultado.
a = false
b = true
a && b = false
a || b = true
!a = true
EXEMPLO:
Quando uma string é concatenada com um valor que não é string esse valor é convertido
em string
float nota = 20
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”.
2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
StringDemo.java
}
}
4. Compilar e executar. Verifique o resultado.
Curso Java
Sintaxe:
if ( condição )
comando1;
else
comando2;
onde:
Tradução:
Se (condição)
comando1 ;
senão
comando 2;
Exemplo:
if ( fim = = true )
System.out.println(“Término!”);
else
System.out.println(“Continuando...”);
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...”);
}
2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
ExemploIF.java
Feminino
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;
}
onde:
Tradução
Escolha(expressão) {
...
Exemplo:
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).
2. Acesse o menu File, opção new, opção file, Coloque o nome do arquivo de
ExemploSwitch.java
Feminino
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.
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
}
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
2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
ExemploWhile.java
10
9
8
7
6
5
4
3
2
1
Sintaxe:
do {
bloco de comandos
} while (condição);
Tradução:
faça {
blocos de comandos
} enquanto (condição)
Exemplo:
i = 3;
salario = 260;
do {
salario = salario + 10;
i--;
}while ( i != 0 );
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
2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
ExemploDoWhile.java
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;
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
2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
ExemploFor.java
Sintaxe:
try {
} catch (exception1){
} catch (exception2){
Tradução:
Tratar {
} definir (exception1){
} definir (exception2){
Sintaxe:
try {
Comandos normais;
} finally {
Tradução:
Tratar {
Comandos normais;
} finalizar {
2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
TratamentoErros.java
}
}
1. Abra o Jcreator.
2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
TratamentoErrosF.java
//TratamentoErrosF.java
}
}
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:
onde:
Exemplo:
int x[ ] = int[3]
2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
VetorTest.java
//VetorTest.java
30
x e y , contendo os valores 10 e 8.
Utilize os operadores para elaborar alguns resultados nas variáveis descritas acima e
imprima utilizando o comando System.out.println().
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”.
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.
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.
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
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.
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.
- iniciar um levantamento
onde:
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.
2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de Bola.java
/* 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;
}
/* 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
}
/* 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
/* 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
Cor.......: Vermelha
Material: Plastico
Oca.......: false
Raio......: 3.0
2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de Pai.java
//Pai.java
public class Pai {
// atributo
String nome, corcabelo, corolhos,sobrenome;
int idade;
idade=56;
}
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
}
// 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("");
}
// construindo os objetos
Pai p1 = new Pai(); // cria o objeto p1 a partir da classe Pai
// 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
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.
2.Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de Vulcao.java
// 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
// 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
}
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.
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.
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.
Por exemplo, dante.velocidade = 2, o objeto dante obtêm valor da velocidade que é uma
variável de instância.
dante.mostrarAtributos();
dante.checarTemperatura();
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
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
//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;
corpo do método.
// 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.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:
//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.
2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
MaquinaLavar.java
// 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
}
} while(x<5);
System.out.print(y);
veloMaquina.setVelocidade();
}
}
5 Velocidade inválida
2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
Lampada.java
//atributos
boolean ligada;
int y;
//construtores
public Lampada() {
ligada = true;
}
public Lampada(boolean ligada){
this.ligada = ligada;
}
//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");
}
}
// programa principal
public static void main(String args[]){
Lampada neon = new Lampada();
neon.ligada=false;
neon.seLigada();
}
}
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é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
//construtor
public Exemplo(){
a = 0;
b = 0;
}
}
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
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 {
.
.
.
}
1. Abra o Jcreator.
2. Acesse o menu File, opção new, opção file, Coloque o nome do arquivo de
LiquidificadorGenerico.java
//Construtores
public LiquidificadorGenerico( ){
velocidade = 0;
velocidadeMaxima = 2;
}
//métodos
protected void ajustarVelocidadeMaxima(int v) {
if (v > 0)
velocidadeMaxima = v;
}
4. Compilar
5. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
LiquidificadorAnalogico.java
//métodos
public void aumentarVelocidade(){
ajustarVelocidade(velocidade +1);
}
7. Compilar
8. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
LiquidificadorDigital.java
//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
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.
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
}
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.
interface NomeDaInterface {
// declaração de atributos
• 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:
• 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.
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.
3)Componentes básicos
1. Abra o Jcreator.
2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
Janela.java.
//Janela.java
import java.awt.*; // importar o pacote java para utilizar os componentes.
public class Janela extends Frame{
//Construtor
public Janela() {
super(); // constroe a janela a partir da classe Frame
setSize(320,240); // define o tamanho da janela
setLocation(50,50);
}
// 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
}
}
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:
1. Abra o Jcreator.
2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
Janela2.java.
//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
}
}
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:
1. Abra o Jcreator.
2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
FecharJanela.java.
5. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
Janela3.java.
// 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
}
}
1. Abra o Jcreator.
2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
ExemploLabel.java.
//ExemploLabel.java
import java.awt.*; // importar o pacote java para utilizar os componentes.
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
}
}
como nos rótulos, não pode ser alterado pelo usuário embora isto possa ser realizado
através da aplicação.
1. Abra o Jcreator.
2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
ExemploButton.java.
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());
1. Abra o Jcreator.
2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
ExemploTextField.java.
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
1. Abra o Jcreator.
2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
ExemploPainel.java.
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
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();
// Interface ActionListener
public void actionPerformed(ActionEvent e){
if (e.getSource()==btlimpar){
entrada.setText(“”);
} else if (e.getSource()==bttransf) {
l2.setText(entrada.getText());
}
1. Abra o Jcreator.
2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
ExemploTextArea.java.
// construtor
public ExemploTextArea(){
super(“Exemplo de TextArea”); // constroe a janela do construtor Frame;
setSize(300,300); //define o tamanho do Frame
// criar painel
Panel p = new Panel();
p.setLayout(new FlowLayout()); //usando o gerenciador de layout FlowLayout
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(“”);
}
}
• 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.
1. Abra o Jcreator.
2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
ExemploList.java.
// 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);
// método main
public static void main (String a[]){
ExemploList l = new ExemploList();
l.addWindowListener(new FecharJanela());
l.show();
}
}
1. Abra o Jcreator.
2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
ExemploChoice.java.
// 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);
// metodo main
public static void main (String a[]){
ExemploChoice c = new ExemploChoice();
c.addWindowListener(new FecharJanela());
c.show();
}
}
1. Abra o Jcreator.
2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
ExemploCheckbox.java.
// método main
public static void main(String a[]){
ExemploCheckbox c = new ExemploCheckbox();
c.addWindowListener(new FecharJanela());
c.show();
}
// construtor
public ExemploCheckbox(){
super("Exemplo de Checkbox");
setSize(300,300);
// 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));
}
}
1. Abra o Jcreator.
2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
ExemploCheckBoxGroup.java.
//ExemploCheckBoxGroup.java
import java.awt.*;
import java.awt.event.*;
public class ExemploCheckBoxGroup extends Frame implements ItemListener{
// 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);
// 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);
}
Classe Descrição
Adicionar uma barra de menus contendo menus e itens de menus é bastante simples no
Java. Basta seguir intuitivamente a estrutura visual apresentada:
• Adicionar os listener necessários para ser possível que os menus e itens de menus
exibam funcionalidades.
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);
1. Abra o Jcreator.
2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
ExemploMenus.java.
import java.awt.*;
import java.awt.event.*;
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");
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);
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:
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.
Funcionalidades:
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 devem ser declarados public, pois a classe applet é uma classe pública.
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:
//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.
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:
// código aqui
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().
// 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:
// 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
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:
// código aqui
1. Abra o Jcreator.
2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
ExemploApplet.java.
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:
Acesse o menu applet e clique na opção stop a tela a seguir será exibida
Acesse o menu Applet, clique na opção restart. Observe variável interrompe mudou o
valor, a variável inicio mudou valor, a variável pintura mudou o valor.
1. Abra o Jcreator.
2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
ExemploApplet2.java.
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>
1. Abra o Jcreator.
2. Acesse o menu File, opção new, opção file. Coloque o nome do arquivo de
ExemploApplet3.java.
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>
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: