Apostila de JAVA, Notas de estudo de Engenharia Informática

Baixe Apostila de JAVA e outras Notas de estudo em PDF para Engenharia Informática, somente na Docsity!

Java

Autor:

Gustavo Cicilio

Apostila de JAVA

• 1. Introdução ______________________________________________ Sumário
• 1.1. O que é JAVA? _________________________________________
• 1.2. O que é uma Applet ______________________________________
• 1.3. O que é uma Aplicação____________________________________
• 1.4. O que é o Appletviewer ___________________________________
• 1.5. O que é Applet no WWW _________________________________
• 1.6. Criando uma Aplicação ___________________________________
• 1.7. Criando uma Applet _____________________________________
• 2. O Básico ________________________________________________
• 2.1 Variáveis e tipos de dados _________________________________
• 2.2. Comentários ____________________________________________
• 2.3. Caracteres Especiais _____________________________________
• 2.4. Expressões e Operadores __________________________________
• 2.5. Comparações ___________________________________________
• 3. Arrays, Loops e Condicionais _______________________________
• 3.1. Arrays ________________________________________________
• 3.2. Condicionais ___________________________________________
• 3.3. Operador Condicional ____________________________________
• 3.4. Switch_________________________________________________
• 3.5. Loop For ______________________________________________
• 3.6. Loop While ____________________________________________
• 3.7. Loop Do _______________________________________________
• 4. Criando Classes e Aplicações em Java _________________________
• 4.1. Definindo Classes _______________________________________
• 4.2. Definindo Variáveis de Instância ___________________________
• 4.3. Constantes _____________________________________________
• 4.4. Variáveis de Classe ______________________________________
• 4.5. Definição de Métodos ____________________________________
• 4.6. A palavra chave this _____________________________________
• 4.7. Passando argumentos para Métodos _________________________
• 5. Mais sobre Métodos _______________________________________
• 5.1. Polimorfismo ou Sobrecarga _______________________________
• 5.2. Métodos Construtores ____________________________________
• 5.3. Métodos Destrutores _____________________________________
• 6. Window Toolkit __________________________________________
• 6.1. Eventos _______________________________________________
• 6.2. Componentes AWT ______________________________________
• 6.3. Gráficos _______________________________________________
• 7. Threads _________________________________________________
• 7.1. O que são threads? _______________________________________
• 7.2. Os estados de uma thread _________________________________
• 7.3. Threads em Applets ______________________________________
• 7.4. Herdando de Thread x Implementando Runnable _______________

1.6. Criando uma APLICAÇÃO

Para começar, criaremos uma simples aplicação em Java: a clássica “Hello World!”, o

exemplo que todos os livros de linguagens usam.

1.6.1. O código fonte

Como todas as linguagens de programação, o código fonte será criado em um editor de

texto ASCII puro. No Unix alguns exemplos são emacs, pico, vi e outros. No Windows,

notepad ou dosedit também servem.

A seguir, o código da aplicação “Hello World!” (arquivo: HelloWorld.java):

class HelloWorld { public static void main (String args[]) { System.out.println(“Hello World!”); } }

1.6.2. Compilando a aplicação

Para compilar a aplicação, basta digitar o comando:

javac HelloWorld.java

Este comando vai gerar o arquivo HelloWorld.class, que é o byte-code da aplicação.

Para executar o byte-code basta digitar o comando:

java HelloWorld

1.7. Criando uma APPLET

Criar uma applet é diferente de criar uma simples aplicação porque uma applet é

executada e visualizada dentro de uma página HTML. Como exemplo, novamente será

implementada a clássica “Hello World!”.

1.7.1. O código fonte

A seguir, o código da aplicação “Hello World!” (arquivo: HelloWorldApplet.java):

import java.awt.Graphics; public class HelloWorldApplet extends java.applet.Applet { public void paint (Graphics g) { g.drawString (“Hello World!”,5,25);

1.7.2. Compilando a applet

Para compilar a applet, basta digitar o comando:

javac HelloWorldApplet.java

Este comando vai gerar o arquivo HelloWorldApplet.class, que é o byte-code da

applet. Para executar o byte-code é necessário haver uma página HTML, a qual tem o

código a

seguir (arquivo: exemplo1.html):

1.7.3. Visualização

A página com código descrito anteriormente pode ser visualizada através de um

browser que suporte java ou do appletviewer utilizando-se do comando a seguir:

appletviewer exemplo1.html

2. O BÁSICO

2.1. Variáveis e tipos de dados

Variáveis são alocações de memória nas quais podemos guardar dados. Elas têm um

nome, tipo e valor. Toda vez que necessite usar de uma variável você precisa declará-la

e só

então poderá atribuir valores a mesma.

2.1.1. Declarando variáveis

As declarações de variáveis consistem de um tipo e um nome de variável: como segue

o exemplo:

int idade;

String nome;

boolean existe;

Os nomes de variáveis podem começar com uma letra, um sublinhado ( _ ), ou um

cifrão ($). Elas não podem começar com um número. Depois do primeiro caracter pode-

se

colocar qualquer letra ou número.

2.1.2. Tipos de variáveis

Toda variável deve possuir um tipo. Os tipos que uma variável pode assumir uma das

três “coisas” a seguir:

• Uma das oito primitivas básicas de tipos de dados
• O nome de uma classe ou interface
• Um Array

Veremos mais sobre o uso de arrays e classes mais a frente.

Os oito tipos de dados básicos são: inteiros, números de ponto-flutuante, caracteres e

booleanos (verdadeiro ou falso).

Tipos Inteiros:

Tipo Tamanho Alcance

byte 8 bits -128 até 127

short 16 bits -32.768 até 32.

int 32 bits -2.147.483.648 até 2.147.483.

long 64 bits -9223372036854775808 até 9223372036854775807

Existem dois tipos de números de ponto-flutuante: float ( 32 bits, precisão simples) e

double (64 bits, precisão dupla).

2.1.3. Atribuições a variáveis

Após declarada uma variável a atribuição é feita simplesmente usando o operador ‘=’:

idade = 18;

existe = true;

2.2. Comentários

Java possui três tipos de comentário, o /* e */ como no C e C++. Tudo que estiver

entre os dois delimitadores são ignorados:

/* Este comentário ficará visível somente no código o compilador ignorará completamente este trecho entre os delimitadores */

Duas barras (//) também podem ser usadas para se comentar uma linha:

int idade; // este comando declara a variável idade

E finalmente os comentários podem começar também com /** e terminar com */. Este

comentário é especial e é usado pelo javadoc e para gerar uma documentação API do

código.

Para aprender mais sobre o javadoc acesse a home page (http://www.javasoft.com).

2.3. Caracteres especiais

Caracter Significado

y = x++;

y = --x;

As duas expressões dão resultados diferentes, pois existe uma diferença entre prefixo e

sufixo. Quando se usa os operadores ( x++ ou x-- ), y recebe o valor de x antes de x ser

incrementado, e usando o prefixo ( ++x ou –x ) acontece o contrario, y recebe o valor

incrementado de x.

2.5. Comparações

Java possui várias expressões para testar igualdade e magnitude. Todas as expressões

retornam um valor booleano (true ou false).

2.5.1. Operadores de comparação

Operador Significado Exemplo

== Igual x == 3

!= Diferente ( Não igual) x != 3

< Menor que x < 3

> Maior que x > 3

<= Menor ou igual x <= 3

>= Maior ou igual x >= 3

2.5.2. Operadores lógicos

Operador Significado

&& Operação lógica E (AND)

|| Operação lógica OU (OR)

! Negação lógica

& Comparação bit-a-bit E (AND)

| Comparação bit-a-bit OU (OR)

^ Comparação bit-a-bit OU-Exclusivo (XOR)

<< Deslocamento a esquerda

>> Deslocamento a direita

>>> Deslocamento a direita com preenchimento de zeros

• Complemento bit-a-bit

x <<= y Atribuição com deslocamento a esquerda ( x = x << y )

x >>= y Atribuição com deslocamento a direita ( x = x >> y )

x >>>= y Atribuição com deslocamento a direita e com preenchimento de

zeros ( x = x >>> y )

x &= y atribuição AND ( x = x & y )

x |= y atribuição OR ( x = x | y )

x ^= y atribuição XOR ( x = x ^ y )

3. ARRAYS, LOOPS E CONDICIONAIS

3.1. Arrays

Arrays em Java são diferentes do que em outras linguagens. Arrays em Java são

objetos que podem ser passados e acoplados a outros objetos.

Arrays podem conter qualquer tipo de elemento valorado(tipos primitivos ou objetos),

mas você não pode armazenar diferente tipos em um simples array.

Ou seja, você pode ter um array de inteiros, ou um array de strings, ou um array de

array, mas

você não pode ter um array que contenha ambos os objetos strings e inteiros.

A restrição acima descrita significa que os arrays implementados em Java são

genéricos homogêneos, ou seja, um único array pode armazenar qualquer tipo de objeto

com a

restrição que todos sejam do mesma classe.

3.1.1. Declarando um Array:

String difficult[]; Point hits[]; int temp[];

Outra alternativa de declaração:

String[] difficult; Point[] hits; int[] temp;

3.1.2. Criando Objetos Arrays:

Um dos caminhos é usar o operador new para criar uma nova instância de um array,

por exemplo:

int[] temps = new int[99];

Quando voce cria um objeto array usando o operador new, todos os índices são

inicializados para você ( 0 para arrays numéricos, falso para boolean, ‘\0’ para

caracteres, e

NULL para objetos). Você também pode criar e inicializar um array ao mesmo tempo.

String[] chiles = { “jalapeno”, “anaheim”, “serrano” , “jumbou”, “thai”};

Cada um dos elementos internos deve ser do mesmo tipo e deve ser também do mesmo

tipo que a variável que armazena o array. O exemplo acima cria um array de Strings

chamado

chiles que contém 5 elementos.

3.1.3. Acessando os Elementos do Array

Uma vez que você têm um array com valores iniciais, você pode testar e mudar os

valores em cada índice de cada array.

Os arrays em Java sempre iniciam-se na posição 0 como no C++. Por exemplo:

String[] arr= new String[10]; arr[10]=”out”;

Isto provoca um erro de compilação pois o índice 10 não existe, pois isto está fora das

bordas do array.

arr[9] = “inside”;

Esta operação de atribuição é válida e insere na posição 9 do array, a string “ inside”.

3.1.4. Arrays Multidimensionais

Java não suporta arrays multidimensionais. No entanto, você pode declarar e criar um

array de arrays e acessá-los como você faria no estilo-C.

int coords[][]= new int[12][12]; coords[0][0] = 1; coords[0][1] = 2;

3.2. Condicionais

O condicional contém a palavra chave if, seguido por um teste booleano. Um opcional

else como palavra chave pode ser executado na caso do teste ser falso, Exemplo:

if ( x < y) System.out.println(“ x e menor do que y”); else System.out.println(“ y e maior);

Nota técnica: A diferença entre o if em Java e C ou C++ é que o teste deve retornar

um

valor booleano(true ou false).

3.2.1. Bloco

Um bloco é definido por ({}) e contém um grupo de outros blocos. Quando um novo

A condição é uma expressão booleana. Exemplo:

int count=0; while( count < array1.length && array1[count]!=0){ array2[count]=(float) array1[count++]; }

3.7. Loop Do

A principal diferença entre o while e o do é que o teste condicional no caso do while é

feita antes de se executar o código interno ao loop. Desta forma, o que pode acontecer

no

while é que o loop pode não ser executado se a condição for false. Já no loop do o corpo

do

loop é executado pelo menos uma vez, pois o teste de permanência é executado no fim

do

loop.

do{ bodyOfLoop; } while(condition);

4. Criando Classes e Aplicações em Java

4.1. Definindo Classes

Para definir uma classe use a palavra chave class e o nome da classe. Exemplo:

class Minhaclasse{ ... }

Se esta classe é uma subclasse de outra classe, use extends para indicar a superclasse.

Exemplo:

class Minhaclasse extends SuperClasse{ ... }

4.2. Definindo Variáveis de Instância

As variáveis de instância, aparentemente, são declaradas e definidas quase exatamente

da mesma forma que as variáveis locais, a principal diferença é que a alocação delas é

na

definição da classe. Exemplo:

class Bike extends Veículo { String tipo; int correia; int pedal; }

4.3. Constantes

Para declarar uma constante, use a palavra chave final antes da declaração da variável

e inclua um valor inicial para esta variável. Exemplo:

final float pi=4.141592; final boolean debug=false; final int maxsize = 40000;

4.4. Variáveis de Classe

As variáveis de classe são boas para a comunicação entre os diferentes objetos da

mesma classe, ou para manter travamento de estados globais sobre um conjunto de

objetos.

Exemplo:

static int soma; static final int maxObjects= 10;

4.5. Definição de Métodos

A definição dos métodos têm quatro partes básicas:

• O nome do método;
• O tipo objeto ou tipo primitivo de retorno;
• Uma lista de parâmetros;
• O corpo do método;

A definição básica de um método tem esta aparência:

tipoderetorno nomedometodo(tipo1 arg1, tipo2 arg2, ...){ .... }

Exemplo:

int[] makeRange(int lower, int upper) { ... }

A RangeClass classe:

class RangeClass{ int[] makeRange(int lower, int upper){ int arr[] = new int[ (upper - lower) + 1]; for (int i=0; i<arr.length;i++) arr[i]=lower++; return arr; } public static void main(String arg[]){ int theArray[]; RangeClass theRange=new RangeClass(); theArray= theRange.makeRange(1,10); System.out.print(“The array: [ “ ); for ( int i=0; i < theArray.length; i++) System.out.print(theArray[i] + “ “); System.out.println(“]”); } }

A saída do programa é :

The array: [ 1 2 3 4 5 6 7 8 9 10 ]

4.6. A palavra chave this

No corpo de uma definição de método, você pode querer referir-se ao objeto corrente-o

objeto que o método foi chamado - para referir-se às variáveis de instância ou para

passar o

objeto corrente como um argumento para um outro método. Para este tipo de referência,

você

pode usar a palavra chave this.

class Pessoa {

String nome; int idade; Pessoa ( String nome, int idade ) { this.nome = nome; this.idade = idade; } public void imprimeDados () { System.out.print ( “Nome: “ + this.nome + “ Idade: “ + this.idade); } }

4.7.Passando argumentos para Métodos

class PassByReference{ int onetoZero(int arg[]){ int count=0; for(int i=0; i< arg.length; i++){ if(arg[i]==1){ count++; arg[i]=0; } } return count; }

Querendo-se definir as dimensões do retângulo de outra forma, por exemplo pode-se

usar o objeto Point ao invés de coordenadas individuais. Faremos a sobrecarga do

método

construaRetang (), passando agora como parâmetro dois objetos Point:

Retangulo construaRetang (Point superiorEsquerdo, Point inferiorDireito) { x1 = superiorEsquerdo.x; y1 = superiorEsquerdo.y; x2 = inferiorDireito.x; y2 = inferiorDireito.y; return this; }

Porém querendo-se definir um retângulo usando somente o canto superior esquerdo e

uma largura e altura do retângulo pode-se ainda definir mais um método construaRetang

Retangulo construaRetang (Point superiorEsquerdo, int largura, int altura) { x1 = superiorEsquerdo.x; y1 = superiorEsquerdo.y; x2 = (x1 + largura); y2 = (y1 + altura); return this; }

Para finalizar o exemplo mostra-se a seguir um método para imprimir as coordenadas

do retângulo e um main para fazer o teste:

import java.awt.Point; class Retangulo { int x1 = 0; int y1 = 0; int x2 = 0; int y2 = 0; Retangulo construaRetang ( int x1, int y1, int x2, int y2 ) { this.x1 = x1; this.y1 = y1; this.x2 = x2; this.y2 = y2; return this; } Retangulo construaRetang (Point superiorEsquerdo, Point inferiorDireito) { x1 = superiorEsquerdo.x; y1 = superiorEsquerdo.y; x2 = inferiorDireito.x; y2 = inferiorDireito.y; return this; } Retangulo construaRetang (Point superiorEsquerdo, int largura, int altura) { x1 = superiorEsquerdo.x; y1 = superiorEsquerdo.y; x2 = (x1 + largura); y2 = (y1 + altura); return this; } void imprimaRetangulo () { System.out.print ( “Retângulo: < “ + x1 + “, “ + y1 ); System.out.println ( “, “ + x2 + “, “ + y2 + “>”); } public static void main ( String args[] ) { Retangulo retang = new Retangulo(); System.out.println ( “Chamando construaRetang com coordenadas 25, 25, 50, 50 :” );

retang.construaRetang ( 25, 25, 50, 50 ); retang.imprimaRetangulo (); System.out.println ( “--------------------------------------------“); System.out.println ( “Chamando construaRetang com os pontos (10, 10) , (20, 20) :” ); retang.construaRetang ( new Point (10,10) , new Point (20, 20) ); retang.imprimaRetangulo (); System.out.println ( “--------------------------------------------“); System.out.println ( “Chamando construaRetang com os pontos (10, 10) , largura (50) e altura (50) :” ); retang.construaRetang ( new Point (10,10) , 50, 50); retang.imprimaRetangulo (); System.out.println ( “--------------------------------------------“); } }

5.2. Métodos Construtores

Um método construtor é um tipo especial de método que determina como um objeto é

inicializado quando ele é criado.

Diferente dos métodos normais um método construtor não pode ser chamado

diretamente; ao invés disto os métodos construtores são chamados automaticamente

pelo Java.

No momento em que o objeto é instanciado, ou seja quando se usa new o Java faz três

coisas:

• Aloca memória para o objeto
• Inicializa as variáveis daquela instância do objeto
• Chama o método construtor da classe

5.2.1. Construtores Básicos

Os construtores parecem muito com os métodos normais, com duas diferenças básicas:

• Construtores sempre têm o mesmo nome da classe
• Construtores não podem ter tipo de retorno

Exemplo:

class Pessoa { String nome; int idade; Pessoa (String n, int i) { nome = n; idade = i; } void printPessoa () { System.out.print (“Oi meu nome é : ”+ nome); System.out.println (“. Eu tenho : “+idade+ “ anos”); } public static void main ( String args[] ) { Pessoa p; p = new Pessoa ( “Maria”, 20 ); p.printPessoa(); } }

5.2.2. Polimorfismo de Construtores

Igual aos métodos normais os construtores também podem ter números variáveis de

tipos e parâmetros. Por exemplo os métodos construaRetang () definidos na classe

Retangulo

seriam excelentes construtores para a mesma classe, pois eles estão justamente

instanciando as

variáveis. Segue o exemplo abaixo com as devidas alterações :

import java.awt.Point; class Retangulo { int x1 = 0; int y1 = 0;

executada em sistemas gráficos completamente diferentes.

Neste capitulo apresentaremos os seguintes componentes: Buttom, Canvas, Checkbox,

Container, Label, List, Scrollbar e TextComponent. Mas para um bom entendimento

destes

componentes é necessário primeiro ter uma base sobre manuseio de eventos.

6.1. Eventos

Um evento é uma comunicação do mundo externo para o programa que alguma coisa

aconteceu. Podemos citar como exemplos o clique ou ainda o movimento do mouse.

Uma das

mais importantes coisas a se entender sobre o AWT é como é feito o

manuseio/tratamento

destes eventos. Sem eventos sua aplicação não poderia responder as ações do usuário.

Exemplo 1:

import java.awt.*; import java.applet.Applet; public class ex5_1 extends Applet { Button botão; public void init() { botão = new Button("Clique Aqui!"); add(botão); } public boolean action (Event evt, Object algum) { if (evt.target == botão) { botão.setLabel("OK!!"); return true; } else return false; } }

Quando um componente que tem a ele uma ação associada é manipulado pelo usuário,

o método action() daquele componente é chamado. Neste caso nos estamos usando um

botão

ao invés de usar uma subclasse de nossa autoria. O tratador de eventos tenta tratar o

evento

dentro da classe botão, mas como ele não acha o tratador que iria manusear o evento ele

passa

o evento para cima para o container que contem o componente e assim por diante até

que

alguém trate o evento.

Vamos dar uma olhada de perto no método action():

public boolean action(Event evt, Object algum) {

Todos tratadores de eventos tem uma forma similar a esta. Eles aceitam um parâmetro

do tipo Event que prove informação detalhada sobre o evento. Segundo eles retornam

um

valor Boolean indicando True se o evento foi tratado, ou False caso contrario.

if (evt.target == botão) {

Aqui o alvo do evento é e checado para se saber se é ou não o botão. Porque evt.target

e botão são ambos objetos, nos podemos checar se ambos são o mesmo objeto.

botão.setLabel("OK!!");

Já que o botão foi pressionado vamos mudar o seu titulo.

return true; } else return false;

Finalmente, se o evento foi tratado é retornado true, caso contrário é retornado false.

6.1.1. Tratamento de Eventos em Detalhe

Em quase todos os casos podemos usar os métodos tratadores de eventos que são

fornecidos na linguagem Java. Estes estão na tabela abaixo. Mas lembre-se que tudo é

relativo

ao componente. Por exemplo, o método mouseMove() de um componente é chamado

quando

o mouse é movido dentro daquele componente.

Eventos do Java

TIPO MÉTODO

Ação tomada action(Event evt, Object algum)

Botão do mouse pressionado mouseDown(Event evt, int x, int y)

Botão do mouse liberado mouseUp(Event evt, int x, int y)

Movimento do mouse mouseMove(Event evt, int x, int y)

Arrasto do mouse mouseDrag(Event evt, int x, int y)

Mouse entra em componente mouseEnter(Event evt, int x, int y)

Mouse sai de componente mouseExit(Event evt, int x, int y)

Tecla pressionada keyDown(Event evt, int key)

Tecla liberada keyUp(Event evt, int key)

Quando você deve usar outros métodos em detrimento do action()? A resposta é

quando você quer trocar o comportamento do componente, action() não é suficiente. Ele

apenas reporta eventos que são essenciais para o componente como um clique do mouse

num

botão.

Vamos adicionar ao programa exemplo anterior algumas mudanças de

comportamento:

Exemplo 2:

import java.awt.*; import java.applet.Applet; public class ex5_2 extends Applet { Button botão; public void init() { botão = new Button("Clique Aqui !!"); add(botão); } public boolean mouseEnter(Event evt, int x, int y) { botão.setLabel("Va Embora !!"); return true; } public boolean mouseExit(Event evt, int x, int y) {

botão.setLabel("Fique Longe !!"); return true; } public boolean action (Event evt, Object algum) { if (evt.target == botão) { botão.setLabel("OK"); return true; } else return false; } }

Agora por aonde que o usuário mova o mouse na applet, o mesmo é instigado a não

clicar no botão. Antes, o botão era usado de uma maneira completamente normal, agora

nos

mudamos seu comportamento/funcionalidade.

6.1.2. handleEvent() ou action()

6.1.4. Foco

Quando um usuário clica em um componente da interface, este item fica

"selecionado". Quando um text field é selecionado, o usuário pode digitar no campo de

texto.

Quando um componente recebe o foco, o método getFocus() do componente é

chamado:

public boolean getFocus(Event evt, Object what) { ... }

Quando um componente perde o foco, o método lostFocus() do componente é

chamado:

public boolean lostFocus(Event evt, Object what) { ... }

É comum em um programa a necessidade de manter o foco em determinado

componente. Por exemplo se um text field para mostrar dados e não para receber dados,

você

provavelmente não quer que o text field esteja apto a receber o foco. Para este caso

existe o

método requestFocus():

public void requestFocus() { ... }

Isto pode ser colocado em um componente que contem o text field para que este

componente fique com o foco.

6.2. Componentes AWT

Antes de começarmos é bom sabermos que:

1. Todos os componentes tem uma posição e tamanho

2. Todos os componentes tem uma cor e uma cor de fundo

3. Componentes podem ser habilitados ou desabilitados

4. Existe uma interface standard para os componentes tratarem eventos

Componentes AWT podem ser divididos em três partes:

• Componentes da Interface

Componentes da Interface abrangem todos os widgets e controles associados a uma

interface gráfica. Exemplos destes componentes são: buttons, text labels, scrollbars,

pick list e campos text-entry.

• Containers

Containers abrangem áreas nas quais os componentes da interface podem ser postos.

Isto habilita os componentes a serem agrupados e formarem um objeto mais coeso e

fácil de ser manipulado. Um Panel é um exemplo deste tipo de componente.

• Windows

Windows são um tipo muito especial da classe Component. Todos os outros

componentes são adicionados dentro de uma window. Normalmente quando se

programa applets, windows não são usadas.

6.2.1. Componentes da Interface

BUTTON

Botão. Pode ser customizado para ter um texto ou ainda ser branco.

Construtores:

Button() ⇒ cria um botão sem label

Button(String etiq) ⇒ Cria um Button com label igual ao conteúdo de etiq

Métodos específicos:

String getLabel()⇒ retorna o label(etiqueta) do botão

void setLabel(String etiq) ⇒ ajusta label do botão para o conteúdo de etiq

Ação:

Cria um evento quando pressionado.

Exemplo:

Button botão = new Button("OK");

CANVAS

Canvas é um componente completamente genérico. Ele existe como fundação para

outras subclasses. Este componente não é muito útil para usuários iniciantes ou

intermediários, mas é extremamente útil para criar seus próprios componentes.

Construtores:

Canvas()⇒ cria um canvas

Métodos específicos:

void paint(Graphics g) ⇒ desenha um canvas com a cor de fundo default

Ação:

nenhuma por default

Exemplo:

Canvas x = new Canvas();

CHECKBOX

Checkbox é uma caixa pequena com um label ao lado. O usuário pode clicar on ou off.

Isto é útil quando você tem uma variedade de atributos que podem ser ligados ou não.

Alem

disto, mais de uma checkbox podem ser agrupadas com um CheckboxGroup para

possibilitar

que apenas um dos itens seja selecionado ao mesmo tempo.

Construtores:

Checkbox()⇒ cria uma checkbox branca com opção false

Checkbox(String lbl) ⇒ cria uma checkbox com label lbl com opção false

Checkbox(String lbl, CheckboxGroup group, boolean state) ⇒ cria uma checkbox com

a

opção lbl em true contida no grupo CheckGroup.

Métodos específicos:

String getLabel()⇒ retorna o label da checkbox

String setLabel(String lbl) ⇒ ajusta o label da checkbox para lbl

boolean getState()⇒ retorna o estado da checkbox

void setState(boolean est) ⇒ ajusta o estado da checkbox para est

CheckboxGroup getCheckboxGroup()⇒ retorna o grupo que a checkbox pertence

void setCheckboxGroup(CheckboxGroup g) ⇒ ajusta nova CheckboxGroup(grupo)

que

pertence a checkbox

Ação:

Cria um evento quando o estado muda

Exemplo:

Checkbox aBox = new Checkbox("SHOW");

LABEL

Um label é simplesmente um texto que pode ser colocado em um componente.

Construtores: