curso básico de linguagem java

81
Curso Básico de Linguagem Java Prof. Marco Aurelio N. Esteves http://geocities.yahoo.com.br/marcoaurelionovaes

Upload: bert

Post on 22-Jan-2016

58 views

Category:

Documents


0 download

DESCRIPTION

Curso Básico de Linguagem Java. Prof. Marco Aurelio N. Esteves. http://geocities.yahoo.com.br/marcoaurelionovaes. JAVA. O Panorama da computação de alto desempenho O crescimento do volume de dados e da complexidade dos processamentos atuais Segundo Pfister, existem três alternativas: - PowerPoint PPT Presentation

TRANSCRIPT

Page 1: Curso Básico de Linguagem Java

Curso Básico de Linguagem Java

Prof. Marco Aurelio N. Esteves

http://geocities.yahoo.com.br/marcoaurelionovaes

Page 2: Curso Básico de Linguagem Java

2

JAVA

• O Panorama da computação de alto desempenhoO Panorama da computação de alto desempenho• O crescimento do volume de dados e da complexidade O crescimento do volume de dados e da complexidade

dos processamentos atuaisdos processamentos atuais• Segundo Pfister, existem três alternativas:Segundo Pfister, existem três alternativas:

– Trabalhar mais arduamenteTrabalhar mais arduamente– Trabalhar mais sabiamenteTrabalhar mais sabiamente– Pedir ajudaPedir ajuda

• A última década, e o avanço e a popularidade dos A última década, e o avanço e a popularidade dos recursos tecnológicosrecursos tecnológicos

• Motivação: grande disponibilidade e os altos custos Motivação: grande disponibilidade e os altos custos dos supercomputadoresdos supercomputadores

• Ainda assim os grandes desafios ainda permanecemAinda assim os grandes desafios ainda permanecem• A idéia dos Grids ComputacionaisA idéia dos Grids Computacionais

Page 3: Curso Básico de Linguagem Java

3

JAVA

•PANORAMA DO CURSO

•Por que devo aprender Java?

•Objetivos x Tempo

•Java é difícil?

•O QUE É JAVA ?

•Linguagem para construção de software de eletroeletrônicos remotos

•Linguagem de programação pequena, confiável e portável

•Linguagem de programação conveniente para a Internet

•Linguagem de programação Orientada a Objetos

•Linguagem de programação no formato Cliente-Servidor

•FERRAMENTAS DE DESENVOLVIMENTO:

•JDK/SDK 1.5 (JAVA 2)

•NET BEANS

•JBUILDER

•ECLIPSE

•JCREATOR LE (Freeware)

Page 4: Curso Básico de Linguagem Java

4

JAVA

•INDEPENDÊNCIA DE PLATAFORMA:

•PROGRAMAS TRADICIONAIS

Código Fonte

C, Delphi, VB

•PROGRAMA JAVA

Código Fonte

JAVA

•PORTABILIDADE X VELOCIDADE:

•Usar compiladores de código nativo (Asymetrix, Symantec e IBM)

•Usar compiladores “Just in Time”

•SEGURANÇA

Compilador JAVA Bytecode independentede plataforma

Máquina virtual Windows

Máquina virtual Linux

Máquina virtual Solaris

Compilador Windows EXE Windows Binário

Compilador Linux EXE Linux Binário

Compilador Solaris EXE Solaris Binário

Prog1.java Prog1.class Byte Code Verifier

RunTime

HARDWARE

Page 5: Curso Básico de Linguagem Java

5

JAVA

• SOFTWARES

• DOWNLOADS

•J2SE (Java 2 Standard Edition) – www.java.sun.com/j2se/downloads/index.html

•J2SE v1.5 ( 72 Mb)

•Documentação: J2SE V1.5 Documentation (45 Mb)

•Jcreator – www.jcreator.com (2Mb)

•BlueJ – www.bluj.org (2.3 Mb)

•INSTALAÇÃO:

•Instalar a documentação na raiz do JDK

•Path (Path = ...;C:\J2SDK1.5\BIN) (FILE NOT FOUND !)

• JCreator/BlueJ – Informar as pastas do J2SDK e documentação

•VARIAÇÕES

•APLICATIVOS DESKTOP (caractere e gráfico)

•APLICATIVOS WEB: APPLETS, SERVLETS E JSP

•EJB

•NOÇÕES DE ORIENTAÇÃO A OBJETO

•Motivação: Confiabilidade, Produtividade e Manutenibilidade

•Estratégias: Encapsulamento, Herança e Polimorfismo

•A Classe e o Encapsulamento

métodos

Classe

propriedades

Page 6: Curso Básico de Linguagem Java

6

JAVA

classe Amétodo X()

classe Bmétodo Y()

classe Cmétodo Z()

classe C1 classe C2

obj.X()

Chamada do método X()

classe Carro1000

celta gol palio classe Carr_1000_16V

Instâncias (Objetos) Nova classe derivada

Caso tenha outra definição do método X() teremos uma anulação. Casotenha mais de uma definição do mesmométodo na mesma classe teremos umasobrecarga.

Page 7: Curso Básico de Linguagem Java

7

JAVA

•Organização das classes em java

•Hierarquia de Classes

•Pacotes

•O rt.jar e a documentação da API

•Exemplos de Programas

•Aplicativo Consoleimport java.lang.*; //Não precisaria pois este pacote já é importado por defaultclass Ex1 extends Object // Não precisaria pois estender Object é o default {

public static void main(String args[]) {

String frase = "Isto é um exemplo para saida em console";System.out.println(frase);

}}

Page 8: Curso Básico de Linguagem Java

8

JAVA

// Aplicativo Gráfico

import javax.swing.*;import java.awt.*;import java.awt.event.*;public class Ex2 {

public static void main(String args[]) {JFrame Ex2 = new JFrame();Font f = new Font("Arial",Font.BOLD,20);JLabel lab = new JLabel("Este é um programa com interface grafica");Ex2.setTitle("Interface Grafica");Ex2.setSize(400,200);Ex2.setFont(f);Ex2.getContentPane().add(lab);Ex2.setVisible(true);Ex2.addWindowListener(new WindowAdapter()

{ public void windowClosing(WindowEvent e) {System.exit(0); }});}

}

Page 9: Curso Básico de Linguagem Java

9

JAVA// Programa Appletimport java.awt.*;import javax.swing.*;import java.applet.*;public class Ex3 extends Applet { Font f = new Font("Arial",Font.BOLD,20); JLabel l = new JLabel("Este é um exemplo de Applet"); public void init() { l.setFont(f); add(l); } }-------------------------------------------------------------------------------------------------------------------------------------------

<! Arquivo HTML para rodar o Applet ><HTML><BODY BGCOLOR="#FFFACD"><CENTER><APPLET code = "Ex3.class" width = "300" height = "100" ></APPLET></CENTER></BODY></HTML>

Page 10: Curso Básico de Linguagem Java

10

•Compilação e Execução:

•O arquivo fonte (.java) deverá ter o mesmo nome da classe no programa caso esta classe seja descrita como

public. Por convenção usar a primeira letra do nome da classe em maiúsculo

•Para cada classe declarada no programa será criado um arquivo de classe (.class) após a compilação e apenas uma destas classes poderá conter o modificador public

• Apenas a classe que será executada terá o método main obrigatoriamente declarado como:

public static void main( String args[ ] )

•O procedimento para compilar e executar um aplicativo Java é:

• javac MeuProg.java (Resultará, caso a classe também possua este nome, em MeuProg.class)

• java MeuProg

•Comentário e Documentação:

•// -> Forma de comentar uma única linha

• /* e */ -> Forma de comentar várias linhas

•/** e */ -> Forma de criar um bloco de comentário para documentação com o utilitário javadoc. Tags de

Documentação: @version, @author, @param, @return, @exception e @see

•As tags @version e @author são apenas para descrição de classes e serão ignoradas a menos que se use as opções –author e –version como parâmetros para o javadoc

JAVA

Page 11: Curso Básico de Linguagem Java

11

JAVA•/** Esta classe exibe uma string como exemplo •@version 1.0 •@author Marcos Esteves */• public class TesteDoc {•/** Método para exibir uma string• @param texto é o parâmetro da classe <b>String</b> a ser recebido • @see #main */• public void exibeString(String texto) {• System.out.println(texto); }• public static void main(String args[]) {• TesteDoc x = new TesteDoc();• x.exibeString("String de teste !");} }

javadoc –author –version TesteDoc.java

•Literais Numéricos – Precedidos por 0 = octal e 0x = Hexa – Ex: 0377 = 3778 , 0x9876 = 987616

•Literais Booleanos – true e false (Não equivalem a 0 e 1)

•Literais Caractere – Representado por um caractere isolado entre apóstrofos ou usando uma seqüência de escapes

• Ex: ‘a’, ‘\\’, ‘\n’, ‘\u0041’, ‘1’, ‘\”’

•Literal String – São na realidade classes que se comportam como um tipo básico. São representados entre aspas inclusive as seqüências de escapes e caracteres unicode - Ex: “Uma linha\nDuas linhas\tTabulação”

Ex: (“Doom II”, c:\games\doom) - implica em: “\”Doom II\”, c:\\games\\doom”

Page 12: Curso Básico de Linguagem Java

12

JAVA•Tipos de Dados – Os tipos de dados em Java são portáveis entre plataformas e portanto, invariáveis

•Identificadores - Podem ter qualquer tamanho e caracter, a limitação vem do S.O com os nomes de classes e arquivos. Os tipos primitivos são: char(16), byte(8), short(16), int(32), long(64), float(32), double(64) e boolean(8)

•Os tipos primitivos quando usados como variáveis de instância ou classe são inicializados por default, já como variáveis locais, devem ser inicializadas Ex: int x=10; float y = 3.141592F, double z = 1.35e+10, char sexo=‘M’, String texto = “\t\tIsto é\n\t\t um exemplo”, vazia = “”, branco = “ “

•Operadores

•Aritméticos = +, -, *, /, % - unários +, -, ++, --

• De Atribuição: +=, -=, *=, /=

• Lógicos: &, && (AND), |, || (OR), ^(XOR), !(NOT)

• Relacionais: = (atribuição), == (comparação), != (diferenciação), >, >=, <, <=

Ex: int x=20 % 7, y=x / 2, x*=y, y=x++, z=++x, (x=?, y=?) ,

(if (i<=10) & (&&) (vet[i].equals(“João”))

(x=3) != (x==3), (if (i ==3) | (||) (i==5))

•Argumentos passados por linha de programa:

•Ex: public static void main(String[ ] args){ ... }

•java MeuProg Param1 Param2 (args[0] = param1 e args[1] = param2)

class MeuProg {

public static void main(String[] args){

System.out.println(“Nome= “+args[0]+”\nSobrenome= “+args[1]); } }

• java MeuProg Jose Carlos - Saída : Nome= Jose e Sobrenome= Carlos (em linhas diferentes)

Page 13: Curso Básico de Linguagem Java

13

JAVA

•Saída para dispositivo padrão:

•Ex: System.out.println(String1+String2+...) – A conversão para String é automática devido a concatenação (+) (implicitamente usando o método toString() da superclasse Object)

System.out.println(“Um ”+2+”Tres ”+4);

•Coversão de Tipos: As conversões permitidas para tipos primitivos são no sentido do menor para o maior:

byte -> short -> int -> long -> float -> double, e qualquer inversão neste sentido implica no uso de cast.

Ex: double x= 9.997; int y = (int) x;

•Principais formas de conversão de tipos:

long x =10 -> int y = (int) x ; float x = 10 -> long y = (long) x ; String x = “10” -> int y = Integer.paseInt(x)

String x = “20.54” -> float y = Float.parseFloat(x) ; String x = “20.54” -> double y = Double.parseDouble(x) ;

int x = 10 -> String y = String.valueOf(x) ; float x = 10.35 -> String y = String.valueOf(x) ; double x = 254.34 ->

String y = String.valueOf(x)

Ex: java Conversao 2 4 3

class Conversao { public static void main(String args[]) {

double nota1, nota2, nota3, media;nota1=Double.parseDouble(args[0]);nota2=Double.parseDouble(args[1]);nota3=Double.parseDouble(args[2]);media=(nota1+nota2+nota3)/3;System.out.println("A media e: "+media); } } // Saída = A media e: 3.0

Page 14: Curso Básico de Linguagem Java

14

JAVA•Constantes: Em Java as constantes somente podem ser declaradas para toda a classe e, por esta razão, é chamada de constante de classe. A declaração final indica a presença de uma constante.

Ex: class UsandoConstantes {public static final double g = 32; // Definição deve vir antes do métodopublic static void main(String[] args) {System.out.println(g + “ pes por segundo ao quadrado” } }

Comandos Condicionais:

.if ... else : a) As condições sempre devem estar entre parênteses

b) Caso haja apenas uma instrução as chaves serão desnecessárias

.Ex: if ( valor == 0 || valor == 1 )

fatorial =1;

else

{ fatorial *=valor;

valor--; }

.O operador condicional ou ternário: Retorna sempre um valor pois é na verdade uma expressão

.Ex: int maiorvalor = x > y ? x : y (Equivale a if (x>y) maiorvalor = x; else maiorvalor = y;

.A estrutura switch-case: A variável de teste e os valores somente podem ser dos tipos primitivos simples byte, short, int e char

.Ex: switch (oper) {

case ‘+’ :a += 5; break;

case ‘-’ : a -= 5; break;

case ‘*’: a *= 5; break;

case ‘/’: a /= 5; break;

default: System.out.println(“Operador desconhecido !”); }

Page 15: Curso Básico de Linguagem Java

15

.Estruturas de repetição:

.O laço for (inicialização; teste; incremento)

a) todos os argumentos são opcionais

b) É possível ter incrementos do tipo float

.Ex: for (double x = 5; x<=10; x+=0.5){ ... }

for (int parte = valor; parte > 1;)

fatorial *= parte--;

•O laço while (condição) e do { instruções } while (condição)

a) É necessário parênteses para a condição e se houver apenas uma instrução não necessita de chaves

b) while (condição) 1º Testa e depois executa

do { instruções } while (condição) 1º executa depois testa

Ex: while ( i < 10 ) { do

System.out.println(i + ” “); { System.out.println(i + ” “);

i++; } i++; }

while ( i < 10 ) ;

•Prática: Fazer a lista de exercícios nº 1

JAVA

Page 16: Curso Básico de Linguagem Java

16

JAVA

•Uso do teclado para entrada de dados usando Streams (JDK 1.4):

•import java.io.*; - Informa que será importado o pacote (conjunto de classes) io com todas as suas classes além do pacote default java.lang.*

•InputStreamReader obj1 = new InputStreamReader (System.in); - Cria um objeto (obj1) de fluxo de dados para receber da entrada padrão (System.in) um conjunto de bytes e converte-los em caracteres

•BufferedReader obj2 = new BufferedReader (obj1); - Cria um buffer a partir do fluxo de entrada de caracteres a fim de armazená-los. Isto evita sucessivas leituras de bytes e conversões para caracteres (atua como um cache).

•obj2.readLine(); - Método da classe BufferedReader para ler uma linha de texto e retornar um objeto String com o conteúdo da linha.

•try {...} catch (tipo exceção) {...}: Instruções para se controlar os possíveis erros durante a execução do programa

•getMessage() – Método da classe Exception que permite capturar a string geradora da exceção

•printStackTrace() – Método da classe Exception que mostra o tipo de exceção gerado e onde ocorreu no programa

•exit(1) – Método da classe System que interrompe a execução da JVM e o valor 1 é um indicador de anormalidade

Page 17: Curso Básico de Linguagem Java

17

JAVA

•Exceções em Java: É a forma em Java de se escrever programas robustos (que possam tratar os possíveis erros sem abortar ).

•A hierarquia de exceção:

•Ex: import java.io.*; class Dobro {

public static void main ( String args[] ) { InputStreamReader entrada = new InputStreamReader(System.in); BufferedReader br = new BufferedReader (entrada ); String valorstr; int valornum; System.out.println(“Entre com um valor inteiro: “);try { valorstr = br.readLine(); valornum = Integer.parseInt(valorstr); System.out.println(“O dobro de “ + valorstr + ” e: “ + (valornum * 2)); }catch (Exception e) { System.out.println(“ Erro : “+e.getMessage()); e.printStackTrace(); System.exit(1); } } }

Exception

Throwable

Não Run timeException

Exceções Explícitas

Exceções Implícitas

Error

RuntimeException

Page 18: Curso Básico de Linguagem Java

18

JAVA•Capturar ou Declarar a possibilidade de ocorrência de uma exceção (levantar a exceção)?

•Tratar: Proteger o código do método que contém erro em potencial e tratá-lo usando try- catch {...}

•Levantar: Divulgar com a cláusula throws que seu método, ou usa métodos que informam que podem gerar erros, ou levanta ele próprio exceções não tratadas dentro do seu método.

•try {...} catch (exceção) {...} – Após a cláusula try, as linhas entre os blocos {...} terão a execução desviada para a cláusula catch predefinida ou genérica (Exception e). Quando um erro ocorre é gerado uma exceção que pode ser tratada. O tipo da exceção gerado depende da classe e método que se esta usando e variam desde erros de entrada e saída até erro de formatação

•Ex: try { conjunto de instruções }

catch (nome da exceção) { tratamento deste tipo de erro }

catch (nome da exceção) { tratamento deste tipo de erro }...

•finally – Opcional, mas para todo try deverá existir pelo menos um catch, a não ser que se utilize o finally. Consiste em um conjunto de código que será sempre executado independente de haver ou não erro. Normalmente usado para liberar recursos ou tratar erros desconhecidos.

•O uso de throw(s): Instrução utilizada para declarar que determinada exceção pode ocorrer em um método e também é usada para provocar uma exceção em um método.

Ex: import java.io.*; class ExemploException { public static void main(String args[]) {

int limite; double nota, media, soma=0; InputStreamReader entrada = new InputStreamReader(System.in); BufferedReader br = new BufferedReader(entrada); try { System.out.print("\nEntre com o numero de notas: "); limite = Integer.parseInt(br.readLine());

Page 19: Curso Básico de Linguagem Java

19

JAVA

for ( int i=1; i<=limite; i++) { System.out.print("\nEntre com uma nota: "); nota = Double.parseDouble(br.readLine()); if (nota < 0 || nota > 10)

throw new Exception("Valor da nota < 0 ou >10 !"); soma += nota; } media = soma / limite; System.out.print("\nA media e: "+ media); System.out.println(); } catch(NumberFormatException e) { System.out.println("Valor digitado invalido !"); } catch(IOException e) { System.out.println("Erro na entrada de dados! "); System.exit(0); } catch (Exception e) { System.out.println(e.getMessage()); System.exit(0); } }}

Page 20: Curso Básico de Linguagem Java

20

• Uso do teclado para entrada de dados usando a classe Scanner (JDK 1.5)

Classe Scanner: Utilizada para ler dados de forma mais facilitada. Esta classe está disponível a partir da versão 1.5 do JDK e pertence ao pacote java.util.Ex:import java.util.Scanner; ...Scanner in = new Scanner(System.in);System.out.println(“Entre com o seu nome: “);String nome = in.nextLine(); // Foi usado o nextLine() pois o nome poderia conter brancos

Para ler um dado delimitado por branco:String primeiroNome = in.next(); // a leitura inicia no primeiro caractere diferente de espaço e termina // no primeiro igual a espaçoPara ler dados numéricos:int idade = in.nextInt();double salario = in.nextDouble();

Os métodos nextInt() e nextDouble() disparam Exceptions caso o dado não possa ser convertido para os seu respectivo tipo. Para evitar isso existem os métodos hasNextInt() e hasNextDouble() que retornam true caso a próxima seqüência seja válida.

Obs: Sempre que tiver alguma leitura antes do nextLine(), seja com nextInt, nextDouble ou next, usar uma leitura nextLine() .

Scanner in = new Scanner(System.in);System.out.println("Entre com a idade: ");idade = in.nextInt();in.nextLine(); // Se não for colocada esta linha a próxima leitura será puladaSystem.out.println("Entre com o nome: ");nome = in.nextLine();

JAVA

Page 21: Curso Básico de Linguagem Java

21

JAVA•Funções Matemáticas: Estas funções em Java são provenientes de métodos da classe Math do pacote default java.lang definidos como static.

•Sintaxe : Math.<nome do método>(<lista de argumentos>); - Possui duas constantes PI e E.

•Método ceil(<valor double>): Calcula o próximo inteiro de um valor double retornando um double.

Ex: Math.ceil(5.2); retornará 6.0

•Método floor(<valor double>): Calcula o inteiro anterior de um valor double retornando um double.

Ex: Math.floor(5.9); retornará 5.0

•Método max(<valor1>,<valor2>): Calcula o maior entre <valor1> e <valor2> retornando o maior tipo encontrado.

Ex Math.max(10,3.5); -> 10.0

•Método min(<valor1>,<valor2>): Calcula o menor entre <valor1> e <valor2> retornando o menor tipo encontrado.

Ex Math.min(10,3.5); -> 3.5

•Método sqrt(<valor1 double>): Calcula a raiz quadrada de <valor1> retornando um double.

Ex Math.sqrt(900); -> 30.0 (Negativo = NaN)

•Método pow(<base>,<pot>): Calcula a potência de <base> por <pot> retornando um double.

Ex Math.pow(25,0.5); -> 5.0

•Método round(<valor double>): Calcula o arredondamento do valor retornando um long.

Ex. Math.round(30.5); -> 31

•Método random(): Retorna um valor double aleatório entre [0.0 e 1.0[

Ex. Para sortear um nº entre 0 e 99 -> (int) (Math.random() * 100)

Page 22: Curso Básico de Linguagem Java

22

•Funções de String: Em Java, String é uma classe que possui métodos para manipulação e que pode ser utilizada como uma variável. •Sintaxe: (Declaração) String s = “Linguagem Java”; (Utilização) s.<método>(argumento/s) “Os literais String deverão estar entre aspas”.•Método length(): Retorna um inteiro equivalente ao tamanho da string. Ex. int tamanho = s.length(); (tamanho = 14)

•Método charAt(<índice>): Retorna um char correspondendo a posição relativa [0...(n-1)] do caracter na string. Ex. char c = s.charAt(5); (c = ‘a’)

•Métodos toUpperCase() e toLowerCase(): Estes métodos convertem os caracteres de uma string para maiúsculo e minúsculo respectivamente retornando um string. Ex. String x = s.toUpperCase() ( x = “LINGUAGEM JAVA” ) – String x = s.toLowerCase() ( x = “linguagem java” )

•Método substring(<índice1>,]<índice2>[): Retorna um String com os caracteres a partir de <índice1> até ]<índice2>[. Se <índice2> não for especificado, será até o final da string. Ex. String x = s.substring(0,9); (x = “Linguagem”)

• Método trim(): Remove todos os espaços antes e depois da string retornando uma String. String x = “ Espaços “; x = x.trim(); ( x = “Espaços” )

•Método replace(<char1>,<char2>): Substitui todas as ocorrências de <char1> por <char2> na string retornando um String. Se nenhuma ocorrência de <char1> for encontrada, a string original é retornada. Ex. String x = s.replace(‘a’,’ ‘); (x = “Lingu gem J v “)

•Método valueOf(<nomevar>): Converte vários tipos de dados em String.

Ex. String x = String.valueOf(45.74); (x = “45.74”)

JAVA

Page 23: Curso Básico de Linguagem Java

23

• Formatação da saída: Ao se imprimir um número no console, o default é utilizar o número máximo de dígitos não zero do tipo em questão.

Ex: x = 10000 / 3.0; System.out.println(x); Será exibido 3333.3333333333335

• Formatando com a classe NumberFormat do pacote java.text: (JDK 1.4)– Valores Numéricos: NumberFormat.getNumberInstance();– Valores Monetários: NumberFormat.getCurrencyInstance();– Valores Percentuais: NumberFormat.getPercentInstance();

• Cada um destes métodos obtém um formatador que é uma instância da classe NumberFormat, para a localização padrão. Em seguida utiliza-se o método format() desta classe para se obter uma String equivalente ao número formatado.

Ex: NumberFormat nf = NumberFormat.getNumberInstance(); System.out.println(“Numero formatado:”+nf.format(x)); Numero Formatado: 3.333,333

• Para ajustar o tamanho utiliza-se os métodos setMaximumIntegerDigits(), setMinimumIntegerDigits(), setMaximumFractionDigits(), setMinimumFractionDigits().

Ex: nf.setMaximumFractionDigits(2); nf.setMaximumIntegerDigits(2); System.out.println("Numero formatado:"+nf.format(x)); 33,33

• Trocando a localidade padrão: Locale.xxxxxx, onde xxxxxx é o objeto que contém informações sobre a localidade.

Ex: NumberFormat nf = NumberFormat.getNumberInstance(Locale.GERMANY);

• Formatando a saída com a classe DecimalFormat(string_formatacao)Ex: Decimalformat df = new Decimalformat(#.###,##); System.out.println("Numero formatado:"+df.format(x)); 3.333,33

JAVA

Page 24: Curso Básico de Linguagem Java

24

• Formatando com printf: A versão 1.5 do JDK trouxe de volta o printf que permite a formatação dos campos. A formatação ocorre de modo que cada um dos especificadores de formato que começam com o caractere % é substituídos pelo argumento correspondente. O caractere de conversão que finaliza o especificador de formato (%) indica o tipo a ser formatado. Ex:System.out.printf (“Olá, %s. no próximo ano o Sr. fará %d anos”, nome, idade); double x = 10000.0 / 3.0;System.out.println(x); // Exibe 3333.33333333333335System.out.printf ( “%8.2f”,x); // Exibe 3333.33Principais conversores para printf

d -> Número inteiro decimal Ex: 159f -> Ponto flutuante Ex: 15.9s -> String Ex: “Hello”c -> Caractere Ex: ‘H’b -> Lógico Ex: truetx -> Data e Hora (onde x representa o que se deseja da data e/ou hora)

Ex: tD -> Data no formato EUA (mës;dia;ano) – 03/20/2006ty -> Últimos dois dígitos do ano – 06

tm -> Mês com dois dígitos (com zeros iniciais) - 03td -> Dia com dois dígitos (com zeros iniciais) - 20

Além disso é possível especificar sinalizadores que controlam a aparência do resultado formatado. Alguns exemplos:

– + : Exibe o sinal para números positivos e negativos -> +3333.33– Espaço : Adiciona um espaço antes de números positivos -> 3333.33 – - : Justifica campos à esquerda -> 3333.33 – ( : Insere números negativos entre parênteses -> (3333.33) – , : adiciona separadores de milhares -> 3,333.33

Ex: System.out.printf ( “%,.2f”, 10000.0 / 3.0); // Exibe 3,333.33 System.out.printf ( “%1$s %2$tB %2$te ,2$tY”, “Data Atual: “, new Date() ); Data atual: Febuary 9, 2004 – Usando índice: %índice$

Prática: Fazer a lista de exercícios nº 2

JAVA

Page 25: Curso Básico de Linguagem Java

25

JAVAComo definir Classes: Uma classe em java é sempre definida com a palavra class em minúsculo e o nome da classe com a primeira letra em maiúsculo. Em seguida normalmente se descreve os membros da classe, ou seja, os elementos que definem a classe. Ex: class Data {

int dia; // Os tipos primitivos alocam espaço em memória, int mês; // já os tipos classe não pois são referências !

int ano; }

Data hoje; // Aloca espaço apenas para a referência : hoje

hoje = new Data(); hoje

O operador new cria uma instância, aloca memória e chama o construtor da classe;

•O acesso a qualquer membro da classe sem a devida instanciação provoca uma Exception do tipo NullPointerException. Ex: Data hoje; hoje.dia = 5; // ERRO ! Pois é necessário primeiro a instanciação hoje = new Data();

Ex: String nome1 = “Joao”; String nome2 = new String(“Joao”);

if (nome1 == nome2) System.out.println(“São iguais”);

else System.out.println(“São diferentes”);

•Métodos em Java: São sub-rotinas que podem ser invocadas todas as vezes que se fizer necessário.

qualificador tipo-do-retorno nome-do-método(tipo_parâmetro parâmetro){...}

Qualificador: São os especificadores de acesso informando quem tem direito de acesso ao método, além da presença ou não da cláusula static. Esta cláusula informa se o método é de classe ou de instância.

Tipo-do-retorno: Pode ser void indicando que nada será retornado, ou um tipo de dado ou classe informando o tipo do retorno. Caso tenha algum retorno este deverá ser retornado através da cláusula return.

null

0x01abcd

dia = 0mes= 0ano= 0

Page 26: Curso Básico de Linguagem Java

26

JAVAPropriedades ou Variáveis: Existem 3 tipos de variáveis em java: de classe, de instância e local.

Variáveis Locais: São as variáveis definidas dentro de algum método. Estas variáveis devem ser inicializadas antes de serem utilizadas.

Variáveis de Instância: São as variáveis declaradas no corpo da classe e que pertencem a instância, ou seja, pertencem ao objeto e portanto cada objeto terá sua cópia com valores possivelmente diferentes.

Variáveis de Classe: São variáveis também declaradas no corpo da classe mas que pertencem a classe como um todo, qualificando todas as instâncias da classe. Estas variáveis são declaradas com o qualificador static. Existe apenas uma cópia de cada variável de classe para todos os objetos da classe e estas residem em uma dimensão diferente da dos objetos.

Tipos de Métodos: Existem dois tipos de métodos em Java: Métodos de Classe ou Estáticos e de Instância

Métodos de classe: São os métodos definidos com o qualificador static e que operam apenas sobre as variáveis de classe. Estes métodos não precisam de uma instância para serem invocados pois podem ser chamados a partir do próprio nome da classe seguido do método. Ex: Integer.parseInt(), Math.max(), String.valueOf()

Métodos de Instância: São os métodos declarados sem o qualificados static e que operam sobre as instâncias embora possam operar sobre as classes.

Ex: classe Automovel {static int contaObj; // Variável de classeString modelo, marca; // Variáveis de instânciapublic static void main(String args[]) // Método de classe{ int x; ... // Variável local}String setModelo(String modeloAux) {...} } // Método de Instância

Page 27: Curso Básico de Linguagem Java

27

Variáveis e Métodos de classe e instância: As variáveis e métodos de classe (com o modificador static) ocupam dimensões distintas das variáveis e métodos de instância e são criadas uma única vez na instanciação do primeiro objeto da classe. Ex: class Data {

static int tipoCalendario; int dia, mes, ano;

static void trocaTipoCalendario(int novo_tipo) { ... }void incrementaDia( int num_dias) { ... } }

... Data hoje = new Data(); Data amanha = new Data() 1º) hoje

2º) amanha

Invocando Variáveis e Métodos de classe e instância: As variáveis e os métodos de instância necessitam de uma instância para serem chamados. Já as variáveis e os métodos de classe podem e devem ser chamados pelo nome da classe. Ex: Data hoje = new Data(); hoje.dia = 5; hoje.incrementaDia(3); Data.tipoCalendario = 3; Data.trocaTipoCalendario(3); Integer.parseInt(),String.valueOf(), Math.max(), ...

Métodos de Acesso: Seguindo os padrões da Orientação a Objetos de encapsulamento, os membros da classe não devem ter acesso externo a não ser por intermédio de métodos. Para isso as variáveis devem ser declaradas com o modificador private e os métodos que dão acesso as variáveis com o modificador public Os modificadores são:1) private 2) public 3) protected 4)default (package)Ex: class Data { private int dia, mes, ano;

public void setDia( int dia_aux) { dia = dia_aux }; public int getDia() { return dia }; ... // Para todas as demais variáveis }

Prática: Faça a Lista de exercícios Usando Classes até o número 5.

JAVA

Dados da classe (Class) Instância

tipoCalendario = 0trocaTipoCalendario()

dia = 0mes = 0ano = 0incrementaDia()

dia = 0mes = 0ano = 0incrementaDia()

Instância

Page 28: Curso Básico de Linguagem Java

28

JAVA•Manipulação de Data (classe Date): Esta classe do pacote java.util representa um determinado tempo decorrido a partir de determinada data arbitrária do calendário gregoriano 01 de Jan de 1970 00:00:00. Esta classe possui vários métodos de instância para data e hora. Ex: Date data = new Date();

•Os métodos mais comuns para manipulação de Datas são: data.getDate() – Retorna o dia do mês; getDay() – Retorna o dia da semana (0 domingo – 6 sábado); getMonth() - Retorna o mês ( 0 até 11); getYear() – Retorna o ano (para anos superiores a 2000 retornará 3 dígitos Ex. para 2000 retornará 100, para 2001 retornará 101, ...); data.setDate(dia) – Define o dia para o objeto data (o mesmo ocorre para setMonth() e setYear()).

Os métodos mais comuns para manipular Hora são: data.getHours() – Retorna a hora de 0 – 23; getMinutes() - Retorna os minutos de 0 – 59; getSeconds() – Retorna os segundos de 0 – 59; setHours(horas), setMinutes(minutos) e setSeconds(segundos) definem a hora, os minutos e os segundos do objeto data; data.toLocaleString() – Retorna uma String contendo a data e hora do objeto data.

•A classe GregorianCalendar: Esta classe é mais atual e recomendada para manipular datas e horas.Ex: GregorianCalendar diaDeHoje = new GregorianCalendar(). diaDeHoje = data do Sistema Oper.GregorianCalendar diaDeHoje = new GregorianCalendar(1999, 11, 31, 23, 59, 30). Meses de 0 a 11 Métodos mais utilizados:

int get(int valor) – Onde valor pode ser qualquer uma das constantes definidas em Calendar como:YEAR, MONTH, DAY_OF_MONTH, DAY_OF_WEEK, DATE, HOUR, MINUTE, SECOND, AM_PM

void set( int ano, int mes, int dia) ou void set(int ano, int mes, int dia, int hora, int minuto, int segundo)boolean equals(Object quando) – Compara o objeto corrente com quando retornando true se representam o mesmo ponto no tempo.

boolean before(Object quando) – Retorna true se objeto corrente vier antes de quando

boolean after(Object quando) - Retorna true se objeto corrente vier depois de quando

Page 29: Curso Básico de Linguagem Java

29

Ex: GregorianCalendar diaDeHoje = new GregorianCalendar(). int dia = diaDeHoje.get(Calendar.DAY_OF_MONTH); int mes = diaDeHoje.get(Calendar.MONTH);

int ano = diaDeHoje.get(Calendar.YEAR);

Alterando: diaDeHoje.set(Calendar.YEAR, 2007) diaDeHoje.set(Calendar.MONTH, Calendar.DECEMBER)

OBS: A classe abstrata Calendar possui constantes para os meses de 0 a 11 Ex. DECEMBER = 11, APRIL = 3, ...

•Construtores: São métodos que possuem o mesmo nome da classe, não possuem tipo de retorno e que tem por finalidade executar as tarefas básicas quando da criação de um objeto. Somente pode ser invocado com o construtor new. Esses métodos quando não são declarados, Java chama um default automaticamente.

Ex: class Empregado { int mat; String nome; public Empregado(int mat_aux, String nome_aux) { mat = mat_aux; nome = nome_aux } public static void main (String args[ ] ) { Empregado emp = new Empregado( 123, “João Carlos”); System.out.println(“ Mat: “ + emp.mat + “Nome : “ + emp.nome ); } }

OBS: Caso seja declarado algum construtor, o construtor default deixará de ser fornecido automaticamente !

•this e escopo: this dentro de uma definição de método de instância é usado para fazer referência ao objeto a partir do qual o método foi chamado. É uma referência para as variáveis de instância deste objeto, ao invés das variáveis locais, ou passar o objeto corrente como argumento para outro método.

Ex: Uma função tradicional : umaData = amanha( Data d ); Uma chamada em Java: Data d = new Data(); d.amanha(); // O método amanha irá operar sobre o objeto d

JAVA

Page 30: Curso Básico de Linguagem Java

30

JAVAEx: public class Data { private int dia, mês, ano; public void amanha() { this.dia = this.dia + 1; } } // O this é desnecessário pois java já associa as variáveis e métodos ao objeto Ex: class TestaEscopo { int teste = 10; void imprimeTeste() { int teste = 20; System.out.println(“Teste = “+ teste); } // this.teste; public static void main(String args[]) { TestaEscopo st = new TestaEscopo(); st.imprimeTeste(); } }

•Chamando outro construtor da mesma classe: A utilização de this como primeiro comando em um construtor indica a chamada de outro construtor sobrecarregado da classe.Ex: class Cliente { private String nome; int numConta;

public Cliente (String n, int c ) { nome = n; numConta = c; } public Cliente ( String n) { this (n,numConta + 1); } } Conta.cadastrarConta(this); // o this usado para passar a referência como parâmetro

Exercício: Criar uma classe MeuCirculo com coordenadas de centro x, y e raio r. Defina dois construtores onde no 1º valor de x, y e r seja passado como argumento e, um segundo onde caso não se passe o valor do raio r assume-se o valor 1 como default.

•Destrutores: Em Java a remoção dos objetos criados é feita automaticamente quando o objeto perde a referência ou não está mas sendo usado. Esta técnica chama-se Garbage Collection e ocorre quando o sistema esta ocioso nas referências já marcadas.

Prática: Faça a Lista de exercícios Usando Classes do ex. 6 ao 10.

Page 31: Curso Básico de Linguagem Java

31

JAVA• Arrays: Em Java os vetores são tratados como objetos, ou seja, são referências e precisam dos passos necessários a criação de qualquer objeto em java (declaração e instanciação). Para diferenciar da declaração de tipos primitivos de dados usa-se [ ] depois do nome do vetor ou do tipo. Ex: String frase[]; ou String[] frase; int coordenadas[]; ou int[] coordenadas;

A criação de objetos de array é feita após a sua declaração ou em conjunto com a declaração:Ex: frase = new String[10]; // String frase[] = new String[10]; coordenadas = new int[50]; // int[] coordenadas = new int[50];

Os elementos em um vetor são criados com os seguintes valores default – 0 para arrays numéricos, ‘ ‘ para caracteres, false para arrays boolean e null para objetos. Os arrays também podem ser criados a partir da inicialização: Ex. String nomes[] = {“João”, “Pedro”, “Mario”}; isto seria o mesmo que : String nomes[] = new String[3];

nomes[0] = “João”; nomes[1] = “Pedro”; nomes[2] = “Mario”;Os vetores sempre iniciam em zero e para se saber o tamanho de um vetor utiliza-se a variável de instância length.Ex: System.out.println(nomes.length);

A cópia de vetores pode ser feita de duas formas: 1) Movendo-se um objeto array para outro o que faz com que ambas façam referência ao mesmo vetor. Ex: int[ ] vet1, vet2; vet1 = new int[10]; vet2 = vet1; vet1[5] = 15; System.out.println(vet2[5]) // também será 15; 2) Duplicando efetivamente os elementos do vetor com o método arraycopy(vetOrigem, posOrigem, vetDestino, posDestino, qtd) da classe System.

Page 32: Curso Básico de Linguagem Java

32

Ex: vet1={2, 3, 5, 7, 11, 13}; vet2 = {1001, 1002, 1003, 1004, 1005, 1006, 1007}; System.arraycopy( vet1, 2, vet2, 3, 4); for (int i = 0; i <vet2.length; i++) System.out.println(“Elemento “+ i +”: “+vet2[i]);

A utilização de arrays com mais dimensões é semelhante a anterior porém estes necessitam de mais índices. Os arrays multidimensionais em java são montados como arrays de arrays.

int espaco[] [] [] = new int [10] [5] [5];

MeuObjeto matObj[] [] = new MeuObjeto[5] [5];

espaco[1] [2] [2] = 10; matObj[2] [4] = new matObj();

Existe uma classe Arrays do pacote java.util que possui alguns métodos de classe bastante úteis como:

• static void sort( a ) -> Ordena o array a de um dos tipos int, long, short, char, byte, float ou double usando quicksort;

• static int binarySearch( a , v) -> Busca um elemento v no array a ordenado usando pesquisa binária. Retorna o índice onde foi encontrado ou um valor negativo r indicando a posição onde deveria ser inserido.

• static void fill ( a, b) -> Preenche todo o array a com o elemento b do mesmo tipo do array a.

• static boolean equals( a, b) -> Compara os arrays a e b retornando true se forem do mesmo tipo, tiverem o mesmo comprimento e os elementos nos índices correspondentes coincidirem.

Prática: Faça a Lista de exercícios Usando Vetores.

JAVA

1001 1002 1003 5 7 11 13vet2

Page 33: Curso Básico de Linguagem Java

33

JAVA•Introdução ao Polimorfismo Estático: Implemente uma classe que tenha três métodos capazes de receber valores de tipos diferentes ( int, float e double) e imprimi-los. Instancie um objeto desta classe no método main e chame os métodos com os argumentos correspondentes.

•Sobrecarga ou Polimorfismo Estático: É um tipo de polimorfismo onde vários métodos possuem o mesmo nome em uma classe e são diferenciados apenas pela quantidade, tipo ou ordem dos parâmetros. Esta técnica evita que métodos com funcionalidades semelhantes tenham nomes distintos facilitando o reaproveitamento de código. Desta forma métodos com mesmo nome se comportam de maneira diferente, pois possuem códigos diferentes de acordo com os argumentos passados. Ex String.valueOf( .... )

class Exemplo

{

public static void main(String args[])

{

System.out.println(“Area do quadrado: “+area(3) );

System.out.println(“Area do retangulo: “+area(3,2) );

}

public static int area(int x) { return x * x };

public static int area(int x, int y) { return x * y };

}

Exercício: Implemente o exemplo acima em duas classes, uma que irá ler o número de argumentos passados e chamar o método area() e outra que irá conter apenas os métodos sobrecarregados area() para o cálculo da área.

•A seguir um exemplo completo de uma classe Empregado e utilização de overloading:

Page 34: Curso Básico de Linguagem Java

34

JAVA

// CLASSE EMPREGADO

import java.util.*;class Empregado{ private String nome; private double salario; private GregorianCalendar dataContratacao; public Empregado (String n, double s, GregorianCalendar d) { nome = n; salario = s; dataContratacao = d; } public void aumentaSalario(double percentualDeAumento) { salario = salario + salario * percentualDeAumento / 100; } public void alteraDataContratacao(int ano, int mes, int dia) { dataContratacao.set(Calendar.YEAR, ano); dataContratacao.set(Calendar.MONTH, mes); dataContratacao.set(Calendar.DATE, dia); }

Page 35: Curso Básico de Linguagem Java

35

JAVA

// CONTINUAÇÃO

public int anoContratacao() { return dataContratacao.get(Calendar.YEAR); }

public String getNome() { return nome; }

public double getSalario() { return salario; }

public void print() { System.out.printf(“%s %7.2f %d “,nome, anoContratacao(), salario); }

public void print(int i) { System.out.println(i); }

public void print(String s) { System.out.println(s); }

public void print(double d) { System.out.printf(“7.2f”,d); }}

Page 36: Curso Básico de Linguagem Java

36

JAVA

// CLASSE QUE IMPLEMENTA O OVERLOADING

import java.util.*; // Devido a classe GregorianCalendar

public class TestaEmpregados { public static void main(String args[]) { Empregado vetEmpregados[] = new Empregado[3]; vetEmpregados[0] = new Empregado("Luiz Claudio", 3500, new GregorianCalendar(1989, 10, 1)); vetEmpregados[1] = new Empregado("Vinicius Aguiar", 4500, new GregorianCalendar(1989, 12, 6)); vetEmpregados[2] = new Empregado("Luciana Arruda", 2500, new GregorianCalendar(1993, 1, 12)); for (int i = 0; i < 3; i++) { vetEmpregados[i].print(vetEmpregados[i].getNome()); // passa um String vetEmpregados[i].print(vetEmpregados[i].getSalario()); // passa um double vetEmpregados[i].print(vetEmpregados[i].anoContratacao()); // passa um int } }}

Page 37: Curso Básico de Linguagem Java

37

JAVA

Pacotes (package): É o modo empregado pela Sun para organizar e agrupar classes. Os pacotes são organizados por níveis de hierarquia de modo a garantir unicidade nas classes.

A cláusula package: A cláusula package deve ser a primeira em um arquivo de classe e informa a que pacote a classe pertencerá, por exemplo: package faturamento. A ausência da cláusula package faz com que a classe pertença a um pacote default, que é o diretório corrente. Os pacotes especificados na cláusula package são mapeados para subdiretórios no sistema de arquivos do SO, sendo criada uma estrutura de subdiretórios similar ao pacote.

Ex: Seja a classe ClasseUtil definida com: package sistemas.comuns e alocada no diretório c:\diretorioSistemas. Ao compilar, com –d, será criado um diretório sistemas abaixo do diretório atual e um subdiretório comuns abaixo do diretório sistemas com ClasseUtil.class: c:\diretorioSistemas\sistemas\comuns\ClasseUtil.class.

Como o compilador localiza os pacotes: Para a localização do pacote é necessário informar ao classpath o diretório a partir do qual se encontra tal pacote, pois os caminhos são relativos a uma ou mais raízes especificadas no classpath. Os pacotes também podem ser oferecidos em arquivos .zip ou .jar, onde internamente existirá a hierarquia dos pacotes e arquivos.

Ex: seja um classpath definido assim: CLASSPATH=.;c:\diretorioSistemas, e uma classe Exemplo que utiliza ClasseUtil definida assim: import sistemas.comuns.ClasseUtil; class Exemplo { ... }. A procura se daria:

1) por ClasseUtil.class no pacote padrão em JAVA_HOME\jre\lib\rt.jar2) por ClasseUtil.class no classpath especificado: c:\diretorioSistemas3) por ClasseUtil.class no diretório local da classe Exemplo ( .)4) por sistemas\comuns\ClassUtil.class em JAVA_HOME\jre\lib\rt.jar5) por sistemas\comuns\ClassUtil.class em c:\diretorioSistemas // Onde deveria estar !6) por sistemas\comuns\ClassUtil.class no diretório local da classe Exemplo

O comando import: Quando em uma classe se utiliza um recurso de outra classe pública, que não pertença ao mesmo pacote, é necessário utilizar o comando import informado o pacote ao qual pertence a classe que oferece o recurso desejado. Ex: import sistemas.comuns.ClasseUtil; ou import sistemas.comuns.*;

Page 38: Curso Básico de Linguagem Java

38

JAVA

Herança: É a peça chave da OO para o reaproveitamento de código e consiste em derivar uma classe a partir de outra herdando seus atributos e métodos. Em java só é possível estender uma única classe. Uma subclasse, quando criada, tende a incorporar novos atributos e/ou métodos tornando-se mais específica (especialização) que a classe original (generalização).

Ex: classe Empregado (slide 33)package testes;import java.util.*;class Gerente extends Empregado { private String nomeDaSecretaria;

public Gerente ( String n, double s, GregorianCalendar d ) { super (n, s, d); // super(...) chama o construtor da superclasse de parâmetros equivalentes nomeDaSecretaria = ""; // e deve ser o 1º comando no construtor da subclasse }

public void aumentaSalario ( double percentualDeAumento ) // Método aumentaSalario reescrito { GregorianCalendar hoje = new GregorianCalendar( ); double bonus = 0.5 * ( hoje.get(Calendar.YEAR) - anoContratacao( ) ); // Não há acesso direto a super.aumentaSalario( percentualDeAumento + bonus ); // variáveis de Empregado pois são private } // super.metodo() chama o método de mesma assinatura na superclasse para não repetir o código

public String getNomeDaSecretaria( ) { return nomeDaSecretaria; }

public void setNomeDaSecretaria( String nome ) { nomeDaSecretaria = nome; } }

Page 39: Curso Básico de Linguagem Java

39

JAVA

package testes;import java.util.*;public class TestaEmpregadoGerente{ public static void main( String args[]) { Gerente mandaChuva = new Gerente ("Ricardo", 7500, new GregorianCalendar(1987,11,15)); mandaChuva.setNomeDaSecretaria("Claudia"); Empregado vetEmpregado[] = new Empregado[3]; vetEmpregado[0] = mandaChuva; // Em tempo de compilação vetEmpregado[0] é um Empregado vetEmpregado[1] = new Empregado("Claudia",2000,new GregorianCalendar(1999, 11, 6)); vetEmpregado[2] = new Empregado("Luciana",2500,new GregorianCalendar(1993, 1, 12)); System.out.println("Empregados e salarios antes do aumento"); for (int i = 0; i < 3; i++) { vetEmpregado[i].print(); } System.out.println(); for (int i = 0; i < 3; i++) { vetEmpregado[i].aumentaSalario(5); } // Em tempo de execução vetEmpregado[0] é um Gerente System.out.println("Empregados e salarios apos o aumento"); for (int i = 0; i < 3; i++) { vetEmpregado[i].print(); } // A classe Gerente não tem método print e usa o da classe Empregado System.out.println("\nA secretaria do departamento se chama: "+mandaChuva.getNomeDaSecretaria()); } }

Page 40: Curso Básico de Linguagem Java

40

JAVA•Encapsulamento: Com exceção dos modificadores final, static e abstract os demais public, protected, private e package são usados para controlar o acesso as variáveis, métodos e classes e são os primeiros a serem declarados.

•Acesso padrão (pakage): Variável ou método declarado desta forma esta disponível para qualquer outra classe do mesmo pacote

•Acesso private: Variáveis e métodos private são acessíveis apenas dentro da classe onde foram declaradas, ou através de métodos não private da classe. Nem os métodos nem as variáveis são passados por herança.

•Acesso public: Variáveis e métodos públicos são acessíveis para qualquer classe. Aas variáveis de classe normalmente são públicas para poderem ser acessadas de qualquer lugar.

•Acesso protected: Variáveis e métodos protected são acessíveis por qualquer classe do mesmo pacote ou por subclasse desta classe (Ex. Applet é subclasse de Panel mas estão em pacotes diferentes java.awt.Panel e java.applet.Applet)

•Polimorfismo Dinâmico: Quando um método é invocado, o compilador tenta localizá-lo na classe a qual pertence o objeto e, caso não encontre, procura sucessivamente nas classes ancestrais até encontrar ou gerar erro. Polimorfismo dinâmico ou late binding consiste na utilização de objetos de classes distintas , porém relacionadas por hierarquia e que possuem a mesma assinatura (nome e lista de parâmetros) mas com códigos diferentes.

Ex: Empregado vetEmpregado[ ] = new Empregado[2];

vetEmpregado[0] = new Gerente(“Ricardo Silva”, 7500, new GregorianCalendar(1987, 12, 15) );

vetEmpregado[1] = new Empregado(“Luiz Alberto”, 2500, new GregorianCalendar(1988, 10, 11) );

vetEmpregado[0].aumentaSalario(5); // Aumentos diferenciados para métodos de mesma assinatura

vetEmpregado[1].aumentaSalario(5); // A seleção do método a carregar é realizada na hora da execução

Page 41: Curso Básico de Linguagem Java

41

JAVA

•Impedindo a Herança: Java permite que se utilize a palavra-chave final juntamente com as classes impedindo assim que essa classe seja estendida (a classe String ). Também é possível aplicar final aos métodos de modo que estes não possam ser sobrepostos em outras classes. Todos os métodos de uma classe final também são final.Os principais motivos para se utilizar final são eficiência e segurança.

•Ex: final class Vendedor { ... }

•A cláusula instanceof: Utilizado para se saber a classe real a que pertence um objeto. •Ex: public void atualizaEmpregado( Empregado e ) { if ( e instanceof Gerente ) // atualiza Gerente else if ( e instanceof Vendedor ) // atualiza Vendedor else // atualiza Empregado comum;

• Conversão entre objetos ( Casting ) : É possível se atribuir a referência de um objeto de uma subclasse para outro de uma superclasse diretamente, sempre no sentido de baixo para cima na árvore de hierarquia. Posteriormente, caso se queira recuperar toda a potencialidade do objeto da subclasse é só se fazer um cast na referência. Em OO há sempre dois tempos, o de compilação e o de execução. •Ex: public void atualizaEmpregado( Empregado e ) { if ( e instanceof Gerente ) { e.getNomeDaSecretaria(); // Erro ! Em tempo de compilação e é do tipo Empregado ( (Gerente) e). e.getNomeDaSecretaria(); // Ok o método é da classe Gerente para o compilador

Page 42: Curso Básico de Linguagem Java

42

•Ex: Empregado e = new Empregado(); Gerente g = new Gerente(); e = g; // Ok, Gerente tem tudo de Empregado e mais alguma coisa g = e; // Erro ! Certamente Empregado não tem tudo que deveria ter um Gerente g = (Gerente) e; // Ok, para o compilador mas em tempo de execução e tem que ser Gerente !

Ex: Faça uma classe onde sejam criados Empregados e Gerentes em um array de Empregados e imprima seus nomes e os nomes de suas secretárias quando for o caso a partir do vetor. import java.util.*; class ListaEmpregadosGerentes { public static void main(String args[]) { Empregado vetEmpregado[] = new Empregado[4]; Gerente mandaChuva1 = new Gerente ("Ricardo", 7500, new GregorianCalendar(1987,11,15)); mandaChuva1.setNomeDaSecretaria("Claudia"); Gerente mandaChuva2 = new Gerente ("Pedro", 5500, new GregorianCalendar(1980,06,28)); mandaChuva2.setNomeDaSecretaria("Luciana"); vetEmpregado[0] = mandaChuva1; vetEmpregado[1] = new Empregado("Claudia",2000,new GregorianCalendar(1999, 11, 6)); vetEmpregado[2] = new Empregado("Luciana",2500,new GregorianCalendar(1993, 1, 12)); vetEmpregado[3] = mandaChuva2; for (int i = 0; i < 4; i++) { if (vetEmpregado[i] instanceof Gerente) { System.out.println("Nome Gerente: "+ vetEmpregado[i].getNome()); System.out.println("Nome Secretária: "+ ((Gerente) vetEmpregado[i]).getNomeDaSecretaria()); } else System.out.println("Nome Empregado: "+ vetEmpregado[i].getNome()); } }

Prática: Faça o exercício usando herança e Polimorfismo

JAVA

Page 43: Curso Básico de Linguagem Java

43

•Classes Abstratas: É uma classe que define uma hierarquia para outras classes, porém é tão abstrata que seus métodos apenas dizem o que deve ser realizado pelos descendentes sem contudo implementar particularmente os códigos( métodos abstratos). Estas classes, definidas com o modificador abstract, não podem ser instanciadas diretamente apenas através de subclasses. Além disso, podem ter métodos e variáveis concretos e até não possuírem nenhum método abstrato, contudo se houver algum método abstrato a classe deverá ser declarada como abstrata.

•Ex: public abstract class PassaroCanoro

{ private String origem; // variável concreta

public abstratct void cantar() ; // método abstrato, sem implementação

public String getOrigem() { return origem; } } // método concreto

public class Curio extends PassaroCanoro

{ public void cantar() { ... } }

public class TrincaFerro extends PassaroCanoro // Uma classe que estenda outra que seja abstrata deve

{ public void cantar() { ... } } // prover implementação a todos os métodos abstratos

Criando um objeto: // ou também será abstrata

PassaroCanoro pc; // Se pode declarar objeto de classe abstrata

pc = new PassaroCanoro(); // Erro ! Porém não se pode instanciar

PassaroCanoro pc = new Curio(); // Instância da subclasse

JAVA

PassaroCanoro

Curió TrincaFerro

Page 44: Curso Básico de Linguagem Java

44

JAVA• A superclasse Object: Esta classe é a superclasse a partir da qual todas as classes derivam, ou seja todas as classes são filhas de Object. Normalmente se utiliza um objeto desta classe como armazenador genérico pois pode fazer referência a qualquer objeto. Esta classe também define alguns métodos úteis como: equals() e toString() que devem ser anulados em outras classes para trabalhar de forma customizada.

•Método equals(): Na classe Object apenas compara se dois objetos apontam para a mesma área. Para saber se dois objetos distintos possuem o mesmo conteúdo deve-se anulá-lo.

Ex: class Empregado { ...

public boolean equals (Object obj) { // Testa-se um objeto qualquer é igual a um dado Empregado

if ( ! (obj instanceof Empregado) )

return false;

Empregado e = (Empregado) obj;

return nome.equals(e.nome) && salario == e.salario && dataContratacao.equals(e.DataContratacao);

•Método toString: Retorna uma String que representa o valor do objeto. De um geral as classes anulam este método a fim de dar uma representação impressa do estado do objeto.

Ex: class Empregado { ...

public String toString()

{ return nome + “\n” + salario + “\n” + dataContratacao; } // Chama toString() das classes

// String e GregorianCalendar

•Todos os arrays são classes que derivam da classe Object e todo array de objetos pode ser convertido em um array de Object:

•Object vet = new int[10[; // Ok pois qualquer array é um Object;

•Object vetObj[] = new Empregado[10]; // Se o array fosse de tipo básico daria erro !

Page 45: Curso Básico de Linguagem Java

45

JAVAEx. Um método para localizar um objeto de qualquer classe em um array de objetos também de qualquer classe.

public int localizar (Object[] a, Object b)

{ for ( int i = 0; i < a.length; i++)

if ( a[i].equals(b) ) return i; // O método equals chamado é o da classe real do objeto a[i]

else return -1;

• A classe Vector: É uma classe definida no pacote java.util que armazena elementos do tipo Object, sendo assim, para se recuperar o tipo real do objeto será necessário usar o cast. A classe Vector oferece vários métodos para trabalhar com vetor como se fosse uma lista encadeada, ou seja, aumentando e reduzindo o tamanho dinamicamente.

• Criando: Vector vet = new Vector(3); Um Vector vazio com potencial de até 3 elementos. Ao se inserir o quarto elemento o Vector dobrará de tamanho automaticamente. Para se evitar o crescimento exponencial pode-se passar o tamanho do incremento no 2º argumento do construtor. Ex: new Vector(3,5);

• Adicionando: Os métodos add() e add(int index, Object obj) adicionam um elemento ao final do Vector ou na posição index deslocando os elementos >= index. Ex: vet.add(new Empregado()) ou vet.add(3,novoFunc);

• Removendo: O método remove(int index) remove o elemento na posicão = index no Vector. Ex: vet.remove(3); // Remove o elemento na quarta posição retornando-o como um Object

• Obtendo o tamanho do Vector: Com o método size() é possível se obter o tamanho corrente do vetor. Ex int tam = vet.size();

• Acessando o Vector: Com o método get(int index) é possível acessar um elemento que esteja na posição index porém é bom lembrar que ele virá como um Object. Os elementos somente podem ser acessados após se ter inserido elementos com o método add(). Ex Item x = (Item) vet.get(3);

• Alterando uma posição: Com set (int index, Object obj) é possível se alterar a posição index do Vector para o conteúdo obj. Também é necessário que a posição index já exista no Vector.

Page 46: Curso Básico de Linguagem Java

46

• Ajustando o tamanho real: É possível ajustar o tamanho do Vector sem adicionar todos os elementos um a um usando setSize(int n). Isto faz com que o Vector passe a ter n elementos null. Ex Vector v = new Vector(10); // capacidade 10 tamanho 0 v.set( 0, x ); // Erro ! Posição 0 ainda não existe. v.add(x); // v.size() passa a ser = 1 v.setSize(10); // v.size() passa a ser igual a 10• Performance: As operações com Vector não são tão eficientes como com arrays. Desta forma é comum ao sesaber que o array não mudará mais de tamanho, copiar os elementos do Vector para o array.Ex String nomes[] = new String[ vet.size() ]; vet.copyInto[nomes];

Um exemplo completo:

import java.util.*; class Departamento { private String nome; private Vector empregados = new Vector(10); public Departamento ( String n ) { nome = n; }

public void print() { System.out.println( nome ); }

public void adicionarEmpregado ( Empregado e ) { empregados.add(e); }

public Empregado removerEmpregado (Empregado e ) { int n encontrarEmpregado (empregados, e); if (n == -1 ) return null; else return (Empregado) empregados.remove(n); }

JAVA

Page 47: Curso Básico de Linguagem Java

47

JAVA

public void listarEmpregados() { for ( int i = 0 ; i < empregados.size() ; i++ ) { System.out.println( ( ( Empregado) empregados.get(i) ).getNome() ); }

private static int encontrarEmpregado( Vector v, Empregado b ) { for ( int i = 0 ; i < v.size() ; i++ ) { if ( ( ( Empregado) v.get(i) ) . equals(b) ) return i; else return -1; } }import java.util.*;class TestaEmpregado { public static void main(String args[ ]) { Departamento umEmpregado = new Departamento(“Compras”); Empregado vinicius = new Empregado (“Vinicius Aguiar”, 4500, new GregorianCalendar(1992,6,13); umDepartamento.adicionaEmpregado(vinicius); Empregado carlos= new Empregado (“Carlos Ribeiro”, 5500, new GregorianCalendar(1993,7,14); umDepartamento.adicionaEmpregado(carlos); System.out.println(“Lista de Empregados”); umDepartamento.listarEmpregados(); Empregado empRemovido = umDepartamento.removerEmpregado(carlos); if ( ! (empRemovido == null) ) System.out.println(“Empregado removido = “+empRemovido.getNome()); else System.out.println(“Empregado Inexistente. Nome = ”+carlos.getNome() ); System.out.println(“Lista de Empregados”); umDepartamento.listarEmpregados(); empRemovido = umDepartamento.removerEmpregado(carlos); if ( ! (empRemovido == null) ) System.out.println(“Empregado removido = “+empRemovido.getNome()); else System.out.println(“Empregado Inexistente. Nome = ”+carlos.getNome() ); }}

Page 48: Curso Básico de Linguagem Java

48

JAVA• Objetos Empacotadores (classes Wrappers): Ocasionalmente é preciso converter um tipo básico em objeto e para isso todos os tipos básicos possuem uma classe com esse fim. As classes são Integer, Long, Float, Double, Character e Boolean. Todas essas classes são do tipo final, não podendo portando ser herdada, e também formam objetos imutáveis, ou seja, não se pode alterar o valor contido em objetos destas classes.

Para se criar objetos a partir de tipos básicos utiliza-se os construtores das classes. Por exemplo, new Integer( 5 ) ou new Float( 35.4 ) cria objetos das classes Integer e Float com os valores 5 e 35.4 respectivamente Ex. Criar um Vector com valores do tipo double Vector v = new Vector(); v.add( 3.14 ); // Erro ! Método add() de Vector só permite objetos v.add(new Double(3.14) ); // Cria um objeto do tipo Double que armazena o valor 3.14 double x = ( (Double) v.get( n ) ). doubleValue(); // Método doubleValue() para recuperar o valor

Outra Forma de converter String em tipo básico podendo conter separadores de milhares. try { x = new DecimalFormat().parse( s.trim( ) ).doubleValue(); } catch( ParseException e) { x = 0; }

• A classe Class: A classe Class representa a identificação de tipo do objeto criado em tempo de execução. Desta forma a JVM sabe a que classe o objeto pertence e os métodos corretos. No entanto essas informações podem ser obtidas através do método getClass da classe Object que retorna um objeto da classe Class. Ex. Empregado e; ... Class c1 = e.getClass(); System.out.println(“Nome da classe = “+ e.getClass().getName() ); // Retorna o nome da classe for (int i = 0 ; i < 3 ; i++) // Pode retornar um Gerente ou um Empregado como nome de classe System.out.println( vetEmpregados[ i ].getClass().getName() + “ “+ vetEmpregados[ i ].getNome());

•Existem outras formas de se obter um objeto Class como Class.forName() e .class de um tipo

Page 49: Curso Básico de Linguagem Java

49

JAVA• Interfaces: É a forma usada por Java para fazer herança múltipla, ou seja, um filho herdar de mais de um pai como em C++. Como exemplo, suponha que desejamos escrever uma classe genérica para ordenação de qualquer tipo de objeto java. Começamos então com uma classe abstrata Sortable que possua um método abstrato copareTo() capaz de informar se um objeto é maior, menor ou igual a outro. Em seguida criamos uma classe OrdenaObjetos qualquer que possua um método de classe ordnedar( Sortable a[ ] ) que receba um array de objetos Sortable e os ordene a partir de seus métodos compareTo(). Para isso será necessário que as classses dos objetos estendam Sortable anulando o método compareTo().Ex. class Empregados extends Sortable { ... // Estendendo Sortable public int compareTo( Sortable b ) // codificando o método compareTo() de Sortable { Empregado emp = (Empregado) b; if ( salario < emp.salario ) return -1; if ( salario > emp.salario ) return 1; return 0; }

public class TestaOrdenacao { public static void main(String args [ ]) { Empregado vetEmpregados = new Empregado[ 3 ]; vetEmpregado[0] = new Empregado (“Vinicius Aguiar”, 4500, new GregorianCalendar(1992,6,13); vetEmpregado[1] =new Empregado (“Carlos Ribeiro”, 5500, new GregorianCalendar(1993,7,14); vetEmpregado[2] =new Empregado (“Marco Aurelio”, 3500, new GregorianCalendar(1990,4,30); OrdenaObjetos.ordenar(vetEmpregados); ... } // passando array de Empregados (Sortable) for ( int i = 0; i < vetEmpregados.length; i++ ) System.out.println( vetEmpregados[ i ] ); } }

abstract class Sortable { public abstract int compareTo( Sortable b ); } // método que todo Sortable deve codificar

Page 50: Curso Básico de Linguagem Java

50

import java.util.*;class OrdenaObjetos { public static void ordenar( Sortable a[ ] ) { // recebe um array de Sortable int n = a.length; boolean troca = true; while ( troca ) { troca = false; for ( int i = 0; i < n – 1; i++ ) { Sortable temp = a[ i ]; if ( temp.compareTo( a[ i + 1 ] ) > 0 ) { // chama o compareTo() do Sortable correspondente a[ i ] = a[ i + 1 ]; a[ i + 1 ] = temp; troca = true; } } } } }

• Existe um problema em se usar classe abstrata para expressar propriedade genérica: suponha uma classe que já estenda diretamente uma outra, neste caso não seria possível estender Sortable pois em java uma classe só pode ter um pai. Ex: class ClasseFilho extends ClassePai, Sortable; ERRO ! • A interface soluciona isso e é um compromisso de que sua classe irá implementar certos métodos com a mesma assinatura definida. Inclusive utiliza-se até a palavra implements para indicar esse compromisso.Ex. public interface Comparable // java.lang.Comparable { pubic int compareTo(Object b); } class ClasseFilho extends ClassePai implements Comparable, ...

• Interfaces, assim como classes abstratas, também não podem ser instanciadas com new, mas podem fazer referência a objetos de classes que a implementem como se fosse uma superclasse.Ex. class Empregado implements Comparable { . . . } Comparable x = new Empregado( . . . ); if ( y instanceof Comparable ) { . . . }

JAVA

Page 51: Curso Básico de Linguagem Java

51

• Uma Interface pode estender outra criando uma cadeia de interfaces e, embora não seja permitido campos de instância e nem métodos de classe, é possível se ter constantes.

• Ex. public interface Y extends X { • { public static final int CONSTANTE = 10;• public int umMetodo(); } • É possível se implementar várias interfaces para maior flexibilidade. Como exemplo uma classe na qual se possa clonar e comparar objetos.

• Ex. public Gerente extends Empregado implements Clonable, Comparable;

Prática: Faça o Exercício Classes Abstratas e Interfaces

• Classes Internas: São classes definidas dentro de outras classes. A motivação para o uso são as seguintes:–Os métodos da classe interna podem acessar os membros da classe externa diretamente;–As classes internas podem ser escondidas de outras classes no mesmo pacote;–As classes internas anônimas poupam muito código quando utilizadas;

import java.awt.*;import java.awt.event;import java.util.*;import javax.swing.*;import javax.swing.Timer;

public class InnerClassTest {public static void main(String args[ ]) { TalkingClock clock = new TalkingClock(1000, true); JOptionPane.showMessageDialog(null, “Sair do programa ? “); System.exit(0); } }

JAVA

Page 52: Curso Básico de Linguagem Java

52

JAVAclass TalkingClock { private int interval; private boolean beep; public TalkingClock ( int interval, boolean beep) { this.interval = interval; this.beep = beep; } public void start() { ActionLintener listener = new TimePrinter(); // Internamente new TimePrinter(this); Timer t = new Timer ( interval, listener); t.start(); } private class TimePrinter implements ActionListener { // Classe Interna private // Aqui existe uma referência do tipo TimeClock outer; public void actionPerformed(ActionEvent e) { Date now = new Date(); System.out.println(“ Agora são: “+ now); if (beep) // Variável da classe externa – Internamente (outer.beep) Toolkit.getDefaultTookit().beep(); } }} Obs: É gerado internamente um construtor do tipo : public TimePrinter( TalkingClock clock) {

outer = clock; }

Page 53: Curso Básico de Linguagem Java

53

JAVA•Classe Interna Anônima: Quando se tem que criar uma classe interna para se usar somente um objeto dessa classe, é possível se criar o obj sem sequer dar nome a classe que além de ser interna passa a ser também anônima.

public void start() { ActionLintener listener = new ActionListener() // new no supertipo da classe (com ou sem argumentos) ou interface // Cria o obj listener, de uma classe sem nome que implementa ActionListener, e possui a descrição abaixo { // Abre chaves depois dos parênteses indica a presença de classe anônima public void actionPerformed(ActionEvent e) { Date now = new Date(); System.out.println(“ Agora são: “+ now); if (beep) // Variável da classe externa – Internamente (outer.beep) Toolkit.getDefaultTookit().beep(); } }; // Fim da declaração da classe interna anônima Timer t = new Timer ( interval, listener); t.start(); }

Significado: Crie um objeto de uma classe que implementa ActionListener e tem como método o actionPerformed.

classe Interna anônima não pode ter construtores mas, caso seja necessário, pode-se passar parâmetros aos construtores da superclasse caso a classe anônima esteja estendendo uma classe e não uma interface.

Page 54: Curso Básico de Linguagem Java

54

• Interfaces gráficas com Swing: O pacote Swing não é um substituto do AWT ( Abstract Window Toolkit ), o pacote gráfico utilizado nas primeiras versões de java. Em vez disso, o Swing é visto como uma camada disposta sobre o AWT e que utiliza internamente os componentes da AWT. Diferentemente da AWT, onde alguns componentes gráficos utilizavam a capacidade de renderização da interfaces gráficas em que o aplicativo estava sendo executado, os componentes do Swing são todos escritos em puro java.• A idéia da AWT de utilizar a API nativa para a construção de GUI trouxe os seguintes problemas:

•Diferenças nos comportamentos dos componentes em diferentes sistemas operacionais•Alguns sistemas operacionais possuem conjuntos limitados de componentes GUI•Erros na biblioteca de interface AWT para diferentes plataformas

•A abordagem Swing derivada da Internet Fundation Classes, adotou a filosofia de manter o tratamento de eventos da AWT e obter da plataforma apenas a janela gráfica (Frame) e os demais componentes são renderizados sobre ela pelo próprio Java.•Desenhar os componentes de uma única forma trouxe diferentes aparências o que foi contornado em Java criando-se diferentes “look and feel” nos padrões Windows, Motif e Metal.

JAVA

List Button Container Label CheckBox

Component

Window

Frame JComponent

Hierarquia Parcial dos componentes da AWT

Page 55: Curso Básico de Linguagem Java

55

JAVA

• Um componente do pacote Swing é reconhecido pela letra J antecedendo o nome do mesmo componente no pacote AWT.

• A classe JFrame: Consiste na classe que representa a janela principal de um aplicativo de interface gráfica usando Swing. Esta classe estende diretamente a classe Frame do AWT.

import javax.swing.*; // importa o pacote javax.swing

public class PrimeiraJanela extends JFrame // estende JFrame

{

public PrimeiraJanela()

{ super (“Nossa primeira Janela”); // chama o construtor de JFrame especificando um título

setSize(300, 150); // Ajusta o tamanho da janela (largura x altura) em pixel

setVisible(true); // Exibe a janela

}

public static void main (String args[ ])

{

PrimeiraJanela pj = new PrimeiraJanela(); // Cria uma instância de PrimeiraJanela

pj.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // Informa o que fazer ao fechar a janela

}

}

• Embora a janela criada possa ter o comportamento esperado de uma janela Window o seu fechamento não faz com que a aplicação pare a execução, mas apenas feche a janela. Para que isto aconteça é necessário existir a última instrução pj.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE).

Page 56: Curso Básico de Linguagem Java

56

JAVA

• Existe uma outra forma de fechar a janela e a aplicação, e está relacionada aos possíveis eventos gerados a partir de uma janela. Para isto basta importar o pacote java.awt.event.* e trocar a instrução anterior pela instrução abaixo, pois as novas classes utilizadas pertencem a este pacote. Ex: Pj.addWindowListener ( new WindowAdapter( ) // obj de Classe Interna anônima que estende uma classe Adaptadora { public void windowClosing ( WindowEvent e) // Sobre escreve este método dos sete oferecidos { System.exit( 0 ); } } );

• Especificando um título para a Janela: É possível se especificar um título para a janela durante a execução do programa usando o método setTitle( String titulo) da classe JFrame.Ex: JFrame janela = new MinhaJanela(); janela.setTitle(“ Texto da minha janela” );

• Definindo um ícone para a janela do aplicativo: É possível se definir um ícone para a janela em tempo de execução com as seguintes instruções: Ex: ImageIcon icone = new ImageIcon(“box.gif”); // A localização do arquivo é transformada em URL janela.setIconImage( icone.getImage() );

• Definindo o modo de exibição de uma janela: Para definir o modo de exibição de uma janela utiliza-se o método setExtendedState( int modo ) herdado da classe Frame; onde modo pode ser uma das três constantes: NORMAL, ICONFIED, MAXIMIZED_BOTH, ou seja, padrão, minimizada ou maximizada. •Ex: janela.setExtendedState( ICONFIED );

• Fixando as dimensões de uma janela: Para habilitar ou desabilitar o redimensionamento de uma janela utiliza-se o método setResizable( boolean valor) herdado de Frame. Ex: janela.setResizable(false); // Impossibilita o seu redimensionamento.

• Especificando as dimensões de uma janela: Para especificar o tamanho de uma janela utiliza-se o método setSize( largura, altura ); Ex: janela.setSize(300, 200);

Page 57: Curso Básico de Linguagem Java

57

JAVA// Um Exemplo de utilização dos métodos da classe JFrame construindo uma Janela padrãoimport javax.swing.*;public class Janela extends JFrame{ protected int largura = 300, altura = 150; protected String titulo = "Sem título"; protected String icone = "padrão"; protected boolean redimensionavel = true; protected String modo = "normal"; public void mostrar() { this.setSize(largura, altura); this.setTitle(titulo); if(icone != "padrão") { ImageIcon iconeImg = new ImageIcon(icone); setIconImage(iconeImg.getImage()); }

this.setResizable(redimensionavel); this.setVisible(true);

if(modo == "normal") setExtendedState(NORMAL); else if(modo == "minimizada") setExtendedState(ICONIFIED); else setExtendedState(MAXIMIZED_BOTH); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); }}

Page 58: Curso Básico de Linguagem Java

58

JAVA// Exemplo de uma classe que utiliza a classe Janela como padrãoimport javax.swing.*;public class MinhaJanela extends Janela { public MinhaJanela(){ titulo = "Esta é uma classe personalizada"; altura = 600; largura = 800; redimensionavel = true; icone = "box.gif"; modo = "maximizada"; mostrar(); } public static void main(String args[]) { MinhaJanela app = new MinhaJanela(); } }

. Anexando controles a janela: De uma forma geral são necessários três passos para se anexar controles nas janelas:

1) Obter uma referência ao objeto Container da janela. A classe JFrame é composta de 4 painéis dos quais o painel de conteúdo é o que nos interessa pois os demais são para controle interno da aparência;

Ex: Container tela = janela.getContentPane();2) Definir a forma como os componentes serão dispostos no Container usando um gerenciador de janelas.

Inicialmente usaremos a classe FlowLayout que aloca os componentes da esquerda para a direita de forma centralizada por default até atingirem a borda da direita, e então passam para a próxima linha.

Ex: FlowLayout layout = new FlowLayout(); tela.setLayout ( layout ); Os componentes são dispostos por default a 5 pixels de distância na largura e na altura da borda da janela

e entre eles. É possível alterar o alinhamento dos componentes usando as constantes: ( CENTER , LEFT e RIGHT) e o distanciamento passando os novos valores no construtor.

Ex: tela.setLayout( new FlowLayout( FlowLayout.LEFT, 20, 10);

Page 59: Curso Básico de Linguagem Java

59

JAVA

3) Efetuar a chamada ao método add() da classe Container para adicionar os componentes ao Container. Ex: JButton btn = new JButton( “Clique aqui” ); tela.add( btn);

• Um exemplo usando um label, um botão e uma caixa de texto

import javax.swing.*;import java.awt.*;public class Controles2 extends JFrame { public Controles2() { super("Adicionando controles à janela"); Container tela = getContentPane(); // Obtendo o Container de JFrame (painel de conteúdo) FlowLayout layout = new FlowLayout(); // Obtendo um gerenciador de lay-out layout.setAlignment(FlowLayout.LEFT); // Ajustando a posição dos componentes a esquerda tela.setLayout(layout); // Informando ao Container para usar o lay-out criado JLabel rotulo = new JLabel("Seu Nome:"); // Cria um label com o texto “Seu nome” JTextField nome = new JTextField(10); // Cria uma caixa de texto com tamanho de 10 caracteres JButton btn = new JButton("OK!"); // Cria um botão com o rótulo “OK” tela.add(rotulo); tela.add(nome); // Adiciona os componentes criados ao Container tela.add(btn); setSize(300, 100); // Ajusta o tamanho da janela setVisible(true); // Exibe a janela } public static void main(String args[]) { Controles2 app = new Controles2(); app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); } }

Page 60: Curso Básico de Linguagem Java

60

JAVA• Definindo a cor de fundo da janela: A cor de fundo da janela pode ser alterada com o método setBackground() do painel de conteúdo, ou seja, do objeto Container de JFrame. As cores podem ser estabelecidas através de constantes da classe Color ou através de valores do padrão RGB (Red-Green-Blue) que definen as tonalidades de vermelho, verde e azul variando de 0 a 255.Ex: Container tela = janela.getContentPane( ); tela.setBackground( Color.white); ou tela.setBackground( new Color(220, 220, 220) );

• Introdução a Manipulação de Eventos: Java fornece muita flexibilidade na manipulação de eventos podendo-se determinar qual objeto responderá a que evento. A manipulação na AWT em geral funciona da seguinte forma:

• Um objeto ouvinte é uma instância de uma classe que implementa uma interface listner como ActionListener ou WindowListener;• Uma origem do evento é um objeto que pode reconhecer eventos, criar objetos que representem estes eventos e informar aos objetos ouvintes registrados a ocorrência destes eventos passando o objeto evento criado. Objetos eventos são derivações da classe java.util.EventObject como ActionEvent e WindowEvent;• A origem do evento envia o objeto evento a todos os objetos ouvintes registrados quando estes ocorrem;•Os objetos ouvintes então irão usar a informação do objeto evento recebido para determinar sua reação ao evento.

• Eventos Semânticos: São os eventos que expressam o que o usuário está fazendo como clicar um botão, alterar uma caixa de texto e outros. Estes eventos são representados por quatro interfaces: • ActionEvent: clique em botão, seleção em menu, duplo clique em lista ou enter em caixa de texto; • AjustmentEvent: ajuste na barra de rolagem;• ItemEvent: Seleção em caixas de seleção ou itens de um listBox;• TextEvent: Alteração em uma caixa de texto ou área de texto.

•Eventos de baixo nível: São os eventos que tornam o reconhecimento dos eventos semânticos possível. Há seis classes para representar esses eventos:•ComponentEvent: O componente foi redimensionado, movido ou ocultado;•KeyEvent: Uma tecla foi pressionada ou liberada;

Page 61: Curso Básico de Linguagem Java

61

JAVA• MouseEvent: O botão do mouse foi pressionado, liberado movido ou arrastado;• FocusEvent: Um componente recebeu ou perdeu o foco;• WindowEvent: Uma janela foi ativada, desativada, minimizada, restaurada ou fechada;• ContainerEvent: Um componente foi adicionado ou removido

• Assim como existem diversas classes de eventos também existem diversas classes de ouvintes para estes eventos. O pacote básico de eventos java.awt.event disponibiliza 11 interfaces para este fim. São elas: ActionListener, AdjustmentListener,ComponentListener, ContainerListener, FocusListener, ItemListener, KeyListener, MouseListener, MouseMotionListener, TextListener e WindowListener. Sete dessas interfaces possuem classes adaptadoras por possuírem mais de um método. Estas classes visam facilitar a utilização: ComponentAdapter, ContainerAdapter, FocusAdapter, KeyAdapter, MouseAdapter, MouseMotionAdapter e WindowAdapter.

. Respondendo aos eventos ActionEvents: Para responder a estes eventos são necessários os seguintes passos:1) Criar um objeto origem que é um componente capaz de gerar um ActionEvent, como um botão ou uma caixa de texto por exemplo.

Ex: JButton btn = new JButton(“Clique aqui”);

2) Criar um objeto ouvinte que é uma instância de uma classe que implemente a interface ActionListener, e fornecer código ao seu único método actionPerformed( ActionEvent e) que recebe o objeto evento.

Ex: class TrataEventos implements ActionListener // Criação da classe ouvinte { public void actionPerformed( ActionEvent e ) { . . . // A reação ao clique do botão vem aqui ! } } TrataEventos trat = new TrataEventos( ) ; // Criação do objeto ouvinte

3) Adicionar o objeto ouvinte ao objeto origem para que este saiba a quem passar o objeto evento quando um ActionEvent ocorrer.

Ex: btn.addActionListener(trat)

Page 62: Curso Básico de Linguagem Java

62

JAVA// Um Exemplo de tratamento de eventosimport javax.swing.*;import java.awt.*;import java.awt.event.*;public class Eventos extends JFrame{ JTextField texto; public Eventos(){ super("Introdução ao uso de eventos"); Container tela = getContentPane(); FlowLayout layout = new FlowLayout(FlowLayout.LEFT); // Ajusta a exibição dos componentes tela.setLayout(layout); JLabel rotulo = new JLabel("Texto:"); // Criação de um Label texto = new JTextField(10); // Criação de uma caixa de texto com tamanho 10 JButton btn = new JButton("Exibir!"); // Criação de um botão TratEventos trat = new TratEventos(); // Criação do objeto ouvinte btn.addActionListener(trat); // Ligação do objeto origem (botão) ao objeto ouvinte tela.add(rotulo); tela.add(texto); // Adicionando componentes tela.add(btn); setSize(300, 100); setVisible(true); } public static void main(String args[]) { Eventos app = new Eventos(); app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); } private class TratEventos implements ActionListener{ // Classe ouvinte definida como Interna para facilitar public void actionPerformed(ActionEvent evento){ // Método que trata o evento String txt = "Você digitou: " + texto.getText(); // Acessando a variável texto da classe externa JOptionPane.showMessageDialog(null, txt); } } } // Caixa de diálogo tipo mensagem

Page 63: Curso Básico de Linguagem Java

63

• Capturando o Objeto Evento: O objeto evento passado ao método actionPerformed( ) é do tipo ActionEvent, e esta classe permite saber qual o objeto origem gerou o evento através do método getSource() que retorna um Object.Ex: public void actionPerformed( ActionEvent e ) { Object source = e.getSource( ); String nomeClasse = source.getClass().getName(); // Capturando o nome da classe if ( source == blueButton ) ... // Identificando o objeto origem

•Inclusão de Textos e Imagens: Para a inclusão de textos é necessária a utilização da classe JLabel. É possível controlar várias propriedades do texto como alinhamento, tipo de letra, tamanho, cor e etc. Uma Imagem também pode ser incluída a partir da classe ImageIcon que representa a imagem. De posse do objeto ImageIcon é possível exibi-lo em um JLabel exclusivamente ou em conjunto com um texto. Ex:import java.awt.*;import java.awt.event.*;import javax.swing.*;class TextosImagens extends JFrame{ JLabel L1, L2, L3, L4; ImageIcon icone = new ImageIcon("C:/Teste/Imagem.gif"); TextosImagens() { setTitle("Inserindo Labels e Imagens na Janela"); setSize(350,120); setLocation(50,50); // Posicionamento em relação ao Container getContentPane().setBackground(new Color(220,220,220)); // Cor de fundo da janela

// Continua página seguinte

JAVA

Page 64: Curso Básico de Linguagem Java

64

JAVA

L1 = new JLabel("Aprendendo",JLabel.LEFT); // Alinhamento do texto a esquerda L1.setForeground(Color.red); // Cor da Fonte do Label L2 = new JLabel(icone); L3 = new JLabel("Inserir ",JLabel.RIGHT); L3.setForeground(Color.blue); L4 = new JLabel("Labels e Imagens",icone,JLabel.CENTER); L4.setFont(new Font("Serif",Font.BOLD,20)); L4.setForeground(Color.black); getContentPane().setLayout(new GridLayout(4,1)); // Divide a Janela em um Grid (linhas,colunas) getContentPane().add(L1); getContentPane().add(L2); getContentPane().add(L3); getContentPane().add(L4); }

public static void main(String args[]) { JFrame Janela=new TextosImagens(); Janela.show();

WindowListener x = new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } }; Janela.addWindowListener(x); } } • O método setPreferredSize( Dimension preferredSize ) permite que se defina o tamanho de um componente, ou seja, a área que ele ocupará na janela. A classe Dimension encapsula largura e altura de um componente.•Ex. label1.setPreferredSize ( new Dimension ( 300, 200 ) ); // Ajusta o tamanho do label1 para 300 x 200.

Page 65: Curso Básico de Linguagem Java

65

JAVA

•Inserindo Botões: Para adicionar Botões utiliza-se a classe JButton. Assim como o JLabel, JButton possui muitas propriedades que podem ser manipuladas.

import java.awt.*;import java.awt.event.*;import javax.swing.*;

public class TesteBotao extends JFrame implements ActionListener { // O JFrame é o obj ouvinte de ActionEvents JButton b1,b2; ImageIcon icone = new ImageIcon("tomcat.gif");

public TesteBotao() { setTitle("Inserindo botoes na janela"); setSize(350,100); setLocation(50,50); getContentPane().setBackground(new Color(180,180,180)); b1 = new JButton("Busca",icone); b1.setHorizontalTextPosition(AbstractButton.LEFT); // Posicao do texto em relação a imagem (default e direita) // b1.setVerticalTextPosition(AbstractButton.TOP); // Posicao do vertical do texto em relação a imagem (botton) b1.setBackground(new Color(100,180,180)); // Cor de fundo do botão b1.setForeground(Color.black); // Cor do texto do botão b1.setFont(new Font("ScriptS",Font.BOLD,20)); // Define a fonte do botão b1.setEnabled(true); // Habilita/Desabilita o botão b1.addActionListener(this); b1.setToolTipText("Pressione aqui para realizar uma busca"); // Coloca uma dica da funcionalidade do botão b1.setMnemonic(KeyEvent.VK_B); // Permite acionar o botão com a combinação ALT+B

Page 66: Curso Básico de Linguagem Java

66

JAVA b2 = new JButton("Cancelar"); b2.addActionListener(this); b2.setMnemonic(KeyEvent.VK_C); b2.setToolTipText("Pressione aqui para cancelar"); getContentPane().setLayout(new FlowLayout()); // gerenciador de layout FlowLayout getContentPane().add(b1); getContentPane().add(b2); }

public void actionPerformed(ActionEvent e) // metodo definido na Interface ActionListener { if (e.getSource() == b1) { System.out.println("Botao 1 pressionado"); } if (e.getSource() == b2) { System.out.println("Botao 2 pressionado"); } }

public static void main(String args[]) {

JFrame Janela = new TesteBotao(); Janela.show(); WindowListener x = new WindowAdapter() //para fechar a janela { public void windowClosing(WindowEvent e) { System.exit(0); } }; Janela.addWindowListener(x); }

}

Page 67: Curso Básico de Linguagem Java

67

JAVA

• Incluindo Caixas de Texto: Para inclusão de caixas de texto utiliza-se a classe JTextField que também possui várias propriedades que podem ser modificadas. O exemplo abaixo exemplifica o seu uso com uma simples calculadora onde o usuário digita dois números em JTextFields e clica em um dos quatro botões de operação.

import java.awt.*;import java.awt.event.*;import javax.swing.*;

class TesteJTextField extends JFrame implements ActionListener { JLabel L1,L2,L3; JButton B1, B2, B3, B4, B5; JTextField T1,T2,T3;

public static void main(String args[]) { JFrame Janela=new TesteJTextField(); Janela.setVisible(true); WindowListener x = new WindowAdapter() // Para fechar a janela { public void windowClosing(WindowEvent e) { System.exit(0); } }; Janela.addWindowListener(x); }

Page 68: Curso Básico de Linguagem Java

68

TesteJTextField() { setTitle("Calculadora"); setSize(350,90); setLocation(50,50); getContentPane().setBackground(new Color(150,150,150)); // Cor de Fundo getContentPane().setLayout(new GridLayout(3,4)); // Define o layout com 3 linhas e 4 colunas L1 = new JLabel("Num.1"); L1.setForeground(Color.black); // Cor da fonte do Label L1 L1.setFont(new Font("",Font.BOLD,14)); // Tipo da fonte do Label L1 L2 = new JLabel("Num.2"); L2.setForeground(Color.black); L2.setFont(new Font("",Font.BOLD,14)); L3 = new JLabel("Total"); L3.setFont(new Font("",Font.BOLD,14)); B1 = new JButton ("+"); B1.addActionListener(this); //Adiciona o obj JFrame que esta sendo construído B2 = new JButton ("-"); B2.addActionListener(this); // para que seja o objeto ouvinte dos botões para B3 = new JButton ("x"); B3.addActionListener(this); // ActionEvents B4 = new JButton ("/"); B4.addActionListener(this); B5 = new JButton ("Limpar"); B5.addActionListener(this); B5.setBackground(Color.black); // Cor de fundo do botão B5.setForeground(Color.white); // Cor do texto do botão T1 = new JTextField(); // Cria os JTextFields T2 = new JTextField(); T3 = new JTextField(); T3.setEditable(false); // Define que o textField é somente para leitura

JAVA

Page 69: Curso Básico de Linguagem Java

69

getContentPane().add(L1); // Adiciona os botões, labels e getContentPane().add(T1); // textFields ao ContentPane() getContentPane().add(B1); getContentPane().add(B2); getContentPane().add(L2); getContentPane().add(T2); getContentPane().add(B3); getContentPane().add(B4); getContentPane().add(L3); getContentPane().add(T3); getContentPane().add(B5); }

public void actionPerformed(ActionEvent e) // Para tratar ActionEvents gerados{ float N1=0, N2=0, result=0; if (e.getSource()==B5) // Se objeto origem do evento for o botão B5 { T1.setText(""); T2.setText(""); T3.setText(""); return; } try { N1 = Float.parseFloat(T1.getText()); N2 = Float.parseFloat(T2.getText()); } catch (NumberFormatException erro) { T3.setText("Erro"); return; }

JAVA

Page 70: Curso Básico de Linguagem Java

70

if (e.getSource() == B1) { result = N1 + N2; } if (e.getSource() == B2) { result = N1 - N2; } if (e.getSource() == B3) { result = N1 * N2; } if (e.getSource() == B4) { result = N1 / N2; } T3.setText(""+result); // Ajusta o resultado }}

• Para o uso de password utiliza-se a classe JPasswordField que substitui os caracteres digitados por “*” por default. Entretanto é possível especificar o caractere de eco através do método setEchoChar(); . . . JPasswordField P1 = new JPasswordField(); P1.setEchoChar('?'); P1.addActionListener(this); // Adiciona o objeto corrente como objeto ouvinte para ActionEvents como um // <enter> em um JTextField ou click em botões public void actionPerformed(ActionEvent e) { if (P1.getText().equals("JAVA")) // Está depreciado método getText(), melhor trocá-lo por getPassword() String texto = new String(P1.getPassword()); if (texto == “java”) T1.setText("Senha Valida"); else T1.setText("Senha Invalida"); }

JAVA

Page 71: Curso Básico de Linguagem Java

71

JAVA

•Listas de Seleção: As listas de seleção são objetos que possibilitam a escolha de um ou vários valores armazenados em uma lista de opções. Esta lista é representada pela classe JList e para sua utilização deve-se seguir os seguintes passos:1. Declarar um objeto JList;2. Declarar um objeto que conterá uma lista de opções ( DefaultListModel ) e adicionar a ele todas as opções3. Instanciar um objeto do item 1 passando um objeto do item 2;4. Criar um painel de rolagem ( JScrolPane );5. Adicionar o objeto do item 1 ao painel de rolagem. O exemplo a seguir demonstra o uso dos principais métodos em uma lista de seleção, onde se pode adicionar e remover itens da lista.

import java.awt.*;import java.awt.event.*;import javax.swing.*;import javax.swing.event.*; // Devido ao ListSelectionListener

public class TesteJList extends JFrame implements ListSelectionListener, ActionListener{ JLabel L1; JTextField T1; JList lista; // Declaração do JList JButton bquant, bindice, bclear; DefaultListModel listModel; // Declaração do objeto que conterá uma lista de opções

public static void main(String args[]) { JFrame Janela = new TesteJList(); Janela.setVisible(true);

Page 72: Curso Básico de Linguagem Java

72

JAVA WindowListener x = new WindowAdapter() // Classe Interna para o evento WindowListener { public void windowClosing(WindowEvent e) { System.exit(0); } }; Janela.addWindowListener(x); } TesteJList() { setLocation(300,100); setTitle("Uso do JList"); setSize(200,250); T1 = new JTextField(); T1.addActionListener(this); // Adiciona o JFrame como ouvinte para ActionEvents de T1 L1 = new JLabel("Sem selecao"); L1.setForeground(Color.black); bquant = new JButton("Quantidade de itens"); bquant.addActionListener(this); // Idem acima para bquant bindice = new JButton("Indice selecionado"); bindice.addActionListener(this); // Idem acima para bindice bclear = new JButton("Remove item"); bclear.addActionListener(this); // Idem acima para bclear listModel = new DefaultListModel(); // Criação do objeto que conterá a lista de opções listModel.addElement("Banana"); // Adição das opções da lista listModel.addElement("Pera"); listModel.addElement("Maça"); listModel.addElement("Uva"); lista = new JList(listModel); // Criação do JList com as opções da lista no objeto listModel

Page 73: Curso Básico de Linguagem Java

73

lista.addListSelectionListener(this); // Adiciona o JFrame como objeto ouvinte para seleções na listaJScrollPane Painel = new JScrollPane(lista); // Adiciona o JList lista ao Painel com barra de Rolagem (JScrollPane) getContentPane().setLayout(new GridLayout(6,1)); // Adiciona o gerenciador GridLayout com 6 linhas e 1 coluna getContentPane().add(L1); getContentPane().add(T1); getContentPane().add(Painel); getContentPane().add(bquant); getContentPane().add(bindice); getContentPane().add(bclear);}public void actionPerformed(ActionEvent e) // Método do JFrame para tratar ActionEvents{ if (e.getSource()==T1) { listModel.addElement(T1.getText()); //adiciona itens a lista T1.setText(""); } if (e.getSource() == bquant) T1.setText("Quantidade: " + listModel.getSize()); if (e.getSource() == bindice) T1.setText("Indice selecionado: " + lista.getSelectedIndex()); if (e.getSource() == bclear) { int index = lista.getSelectedIndex(); L1.setText("Removido : "+ lista.getSelectedValue()); listModel.remove(index); } }public void valueChanged(ListSelectionEvent e) // Método do JFrame para tratar alterações na lista de seleção { L1.setText("Selecionado : "+ lista.getSelectedValue()); }} Ex: Ao remover um item não selecionado no exemplo acima provoca erro, corrija de modo a verificar se há algum item selecionado antes de removê-lo.

JAVA

Page 74: Curso Básico de Linguagem Java

74

JAVA

•Incluindo Caixas de Seleção (ComboBox): Criadas a partir da classe JComboBox funciona praticamente igual ao JList porém há diferenças entre os métodos para a manipulação de suas propriedades. Um Exemplo:import java.awt.*;import java.awt.event.*;import javax.swing.*;

public class TesteComboBox extends JFrame implements ActionListener, ItemListener // Trata ItemEvents { JLabel L1; JTextField T1,T2,T3; JComboBox combo; // Declara os ComboBox JButton B1,B2,B3,B4,B5,B6,B7,B8;

public static void main(String args[]) { JFrame Janela = new TesteComboBox(); Janela.setVisible(true); WindowListener x = new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } }; Janela.addWindowListener(x); }

Page 75: Curso Básico de Linguagem Java

75

TesteComboBox() { setTitle("Uso do JComboBox"); setSize(400,170); getContentPane().setBackground(new Color(190,190,190)); L1 = new JLabel("Conteudo"); L1.setForeground(Color.blue); L1.setFont(new Font("Arial", Font.BOLD, 15)); B1 = new JButton("Mostra Texto"); B1.addActionListener(this); B2 = new JButton("Mostra Indice"); B2.addActionListener(this); B3 = new JButton("Adiciona Item"); B3.addActionListener(this); B4 = new JButton("Remove Item"); B4.addActionListener(this); B5 = new JButton("Remove Todos"); B5.addActionListener(this); B6 = new JButton("Quant. Itens"); B6.addActionListener(this); T1 = new JTextField(); T2 = new JTextField(); String[] cores = {"Branco","Vermelho","Azul","Verde"}; // Cria um vetor com estas opções combo = new JComboBox(cores); // Cria um JComboBox com as opções do vetor cores combo.addItemListener(this); // Informa que o objeto ouvinte para ItemEvents do Combo é o JFrame getContentPane().setLayout(new GridLayout(5,2)); getContentPane().add(L1); getContentPane().add(combo); getContentPane().add(B1); getContentPane().add(B4); getContentPane().add(B2); getContentPane().add(B5); getContentPane().add(B3); getContentPane().add(T1); getContentPane().add(B6); getContentPane().add(T2); }

JAVA

Page 76: Curso Básico de Linguagem Java

76

public void actionPerformed(ActionEvent e) // Trata os ActionsEvents dos botões { if (e.getSource()==B1) // mostra texto L1.setText("Texto: "+combo.getSelectedItem()); if (e.getSource()==B2) // mostra indice L1.setText("Indice: " + combo.getSelectedIndex()); if (e.getSource()==B3) // adiciona item if (T1.getText().length() != 0) { combo.addItem(T1.getText()); T1.setText(""); } if (e.getSource()==B4) // remove item a partir do índice do item selecionado combo.removeItemAt(combo.getSelectedIndex()); if (e.getSource()==B5) // remove todos os itens combo.removeAllItems(); if (e.getSource()==B6) //quantidade de itens no combo T2.setText(""+combo.getItemCount()); }

public void itemStateChanged(ItemEvent e) // Se ocorrer alterações(ItemEvents) no Combo ... { T1.setText(""+combo.getSelectedItem()); } }

JAVA

Page 77: Curso Básico de Linguagem Java

77

JAVA•Incluindo Caixas de Opção (CheckBox): Criadas a partir de JCheckBox permitem apresentar vária opções como caixas nas quais o usuário pode marcar nenhuma, uma ou várias delas. Exemplo:import java.awt.*;import java.awt.event.*;import javax.swing.*;public class TestaCheckBox extends JFrame implements ItemListener // JFrame como ouvinte de ItemEvent { JLabel L1; JCheckBox C1, C2; // Declara os CheckBox static int negrito=0, italico=0;public static void main(String args[]) { JFrame Janela = new TestaCheckBox(); Janela.ssetVisible(true); WindowListener x = new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } }; Janela.addWindowListener(x); }

TestaCheckBox() { getContentPane().setBackground(new Color(180,180,180)); setTitle("Uso do JCheckBox"); setSize(300,70); getContentPane().setLayout(new FlowLayout(FlowLayout.CENTER));

Page 78: Curso Básico de Linguagem Java

78

L1 = new JLabel("Java"); L1.setFont(new Font("Arial",Font.PLAIN,20)); L1.setForeground(Color.black); C1 = new JCheckBox("Negrito"); // Cria o checkbox sem marcação. Poderia ser (“Negrito”,true). C1.setBackground(new Color(180,180,180)); C1.addItemListener(this); // Adiciona o JFrame para ser o objeto ouvinte de ItemEvents do C1 C2 = new JCheckBox("Italico"); C2.setBackground(new Color(180,180,180)); C2.addItemListener(this); // Adiciona o JFrame para o objeto ouvinte de ItemEvents do C2 getContentPane().add(L1); getContentPane().add(C1); getContentPane().add(C2); }

public void itemStateChanged(ItemEvent e) // Método do JFrame que trata o ItemEvent ocorrido { if(e.getSource()==C1) { // Testa se foi do checkbox C1 if(e.getStateChange() == ItemEvent.SELECTED) // Poderia ser DESELECTED negrito=Font.BOLD; else negrito=Font.PLAIN; } if(e.getSource()==C2) { if(e.getStateChange() == ItemEvent.SELECTED) italico=Font.ITALIC; else italico=Font.PLAIN; } L1.setFont(new Font("Arial",negrito+italico,20)); }}

JAVA

Page 79: Curso Básico de Linguagem Java

79

JAVA

•Incluindo Painéis e Botões de Radio: Os painéis são criados a partir da classe JPainel e são utilizados como containers. Os botões de radio são criados a partir da classe JRadioButton e, diferentemente dos checkboxes, permitem que apenas uma entre várias opções seja marcada pelo usuário. Estes devem sempre ser agrupados em um ButtonGroup para cada conjunto de botões de rádio no Frame. Um exemplo completo:import java.awt.*;import java.awt.event.*;import javax.swing.*;class TestePainel_RadioButton extends JFrame implements ItemListener // O JFrame é Ouvinte de ItemEvents{ JLabel L1,L2; float N1=0,result=0; JTextField T1, T2; JPanel P1, P2; // Declara os painéis JRadioButton radio1,radio2,radio3; // Declara os RadioButtons ButtonGroup radiogroup; // Declara o RadioGroup public static void main(String args[]) { JFrame Janela = new TestePainel_RadioButton(); Janela.setVisible(true); WindowListener x = new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } }; Janela.addWindowListener(x); }

Page 80: Curso Básico de Linguagem Java

80

JAVA

TestePainel_RadioButton() { setTitle("Uso de botoes de Radio "); setSize(340,120); getContentPane().setLayout(new FlowLayout(FlowLayout.CENTER)); L1 = new JLabel("Digite um valor"); L1.setForeground(Color.blue); L2 = new JLabel("% do Valor :"); L2.setForeground(Color.blue); T1 = new JTextField(5); T2 = new JTextField(5); P1 = new JPanel(); P2 = new JPanel(); T2.setEditable(false); radio1 = new JRadioButton("10% do valor"); radio2 = new JRadioButton("20% do valor"); radio3 = new JRadioButton("30% do valor"); radio1.setMnemonic(KeyEvent.VK_1); // Cria Teclas de Atalho para acionar os RadioButtons radio2.setMnemonic(KeyEvent.VK_2); radio3.setMnemonic(KeyEvent.VK_3); radiogroup = new ButtonGroup(); radiogroup.add(radio1); radiogroup.add(radio2); radiogroup.add(radio3); radio1.addItemListener(this); radio2.addItemListener(this); radio3.addItemListener(this); P1.setLayout(new FlowLayout(FlowLayout.CENTER)); P1.setBackground(new Color(200,200,200));

Page 81: Curso Básico de Linguagem Java

81

P2.setLayout(new GridLayout(2,3)); P2.setBackground(new Color(200,200,200)); P1.add(L1); P1.add(T1); P2.add(radio1); P2.add(radio2); P2.add(radio3); P2.add(L2); P2.add(T2); getContentPane().add(P1); getContentPane().add(P2); }

public void itemStateChanged(ItemEvent e) { if (T1.getText().length()==0) return; try { N1 = Float.parseFloat(T1.getText()); if (e.getSource()==radio1) result = (N1 * 10)/100; if (e.getSource()==radio2) result = (N1 * 20)/100; if(e.getSource()==radio3) result = (N1 * 30)/100; } catch(NumberFormatException erro) { T2.setText("Erro"); return; } T2.setText(""+result); } }

Prática: Fazer os exercícios Usando Swing

JAVA