Professional Documents
Culture Documents
Ementa da Disciplina
Fundamentos do paradigma orientado a objetos em Java.
Bibliotecas de suporte, componentes gráficos,
interfaces e estruturas de dados, classes coletivas.
Tratamento de exceção.
Gerência de memória.
Multithreading (concorrência).
Applets Java.
Bibliografia
LIVRO TEXTO:
DEITEL, H.M., DEITEL, P.J. Java, Como Programar. 4ª Edição. Porto Alegre: Bookman, 2003.
LEMAY, L. e CADENHEAD, R. Aprenda em 21 Dias Java 2: Professional Reference. 3a. Ed. São Paulo:
Campus, 2003.
OBRAS DE REFERÊNCIA:
HORSTMANN, Cay. Big Java. Porto Alegre: Bookman, 2004.
HORSTMANN, Cay, et al. Core Java 2, Volume 1: Fundamentos. S. Paulo: Makron Books, 2001.
HORSTMANN, Cay, et al. Core Java 2, Volume 2: Recursos Avançados. S. Paulo: Makron Books, 2001.
FURGERI, Sérgio. Java 2 Ensino Didático. São Paulo: Editora Érica, 2002.
CAMARÃO, C. e FIGUEIREDO, L. Programação de Computadores em Java. Rio de Janeiro: LTC, 2003
SANTOS, R. Introdução à Programação Orientada a Objetos usando Java. Rio de Janeiro: Campus, 2003.
MECENAS, I. Java 2 Fundamentos, Swing e JDBC. Rio de Janeiro: Alta Books, 2003.
OLIVEIRA, Alcione P. Notas de Aula DPI-UFV. Viçosa, 2001.
CHAN, Mark C. et al. Java: 1001 Dicas de Programação. São Paulo: Makron Books, 1999.
ECKEL, Bruce. Thinking in Java, 3rd Edition. (e-book).
DAVIS, Stephen R. Aprenda Java Agora. Rio de Janeiro: Campus, 1997.
LALANI, Suleiman S. e JAMSA, Kris. Java: Biblioteca do Programador. São Paulo: Makron Books, 1997.
NEWMAN, A. et al. Usando Java: O Guia de Referência Mais Completo. Rio de Janeiro: Campus, 1997.
WUTKA, Mark. Java: Técnicas Profissionais. São Paulo: Berkeley, 1997.
DAMASCENO JR., Américo. Aprendendo Java: Programação na Internet. São Paulo: Érica, 1996.
JEPSON, Brian. Programando Banco de Dados em Java. São Paulo: Makron Books, 1997.
RITCHEY, Tim. Java! Indianápolis, EUA: New Riders, 1995.
FLANAGAN, David. Java in a Nutshell. O’Reilley & Associates, 1997.
A história de Java
Origem: projeto de pesquisa da Sun Microsystems, iniciado em 1991,
destinado a desenvolver uma linguagem para a programação de dispositivos
eletrônicos em geral (pagers, celulares, PDAs, TV a cabo, etc).
Baseada em C e C++.
Seu criador, James Gosling, inicialmente a chamou de Oak, mas descobriu-se
que, na época, já havia uma outra linguagem com este mesmo nome. Conta a
lenda, que o nome Java foi escolhido em uma cafeteria, e refere-se a uma
variedade de café, originário da ilha homônima, do Pacífico.
Impulso ao uso de Java: a World Wide Web explode em popularidade a partir
de 1993 e a Sun percebe o seu grande potencial para a construção de páginas
com conteúdo dinâmico.
Carregador
Fase 3
de Classe
O carregador de classe
coloca bytecodes na
memória principal
Disco
Um ambiente Java típico (cont.)
Verificador O verificador de
Fase 4 bytecodes confirma
de Bytecodes
que todos os bytecodes
são válidos e não violam
restrições de segurança
de Java
javac AloMundo.java
A compilação vai gerar um arquivo de bytecodes chamado AloMundo.class
Para executar o programa, também a partir da janela de comando, digite:
java AloMundo
System.out.println("Alo, Mundo!");
Nem toda classe necessariamente deve possuir um método main e, portanto, ser
um aplicativo Java. O exemplo a seguir ilustra isto:
import javax.swing.JOptionPane;
System.exit(0);
int numero;
String nome;
double preco;
boolean flag;
class Teste {
int numero;
public static void main(String args[]) {
Teste teste = new Teste();
System.out.println(teste.numero);
}
}
\n nova linha
\t tabulação
\b retrocesso
\\ barra
\' apóstrofo
\" aspas
Grandioso Atlético
O primeiro argumento de printf é a string de formatação, composta de
constantes string e caracteres de formatação. No exemplo acima, o
delimitador % seguido de s indica que o método deve ter um outro
argumento do tipo String.
Os caracteres de formatação podem também ser usados para compor uma
String, usando o método String.format, conforme no exemplo a seguir:
public class Main {
public static void main(String[] args) {
int a = 65;
String s = String.format("char: %c integer: %d
hexa: %h octal: %o",a,a,a,a);
System.out.println(s);
}
}
Para o exemplo acima, onde é usado o mesmo argumento para a formatação,
existem alternativas para a codificação:
import java.util.Scanner;
public class Teste {
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
String string;
System.out.print("Digite Sim: ");
string = entrada.nextLine();
if(string == "Sim")
System.out.println("Iguais");
else
System.out.println("Diferentes");
}
}
O resultado impresso será Diferentes, uma vez que o objeto sim referencia
uma posição de memória diferente do literal Sim.
Para comparar se o conteúdo de dois objetos String são idênticos, uma
sugestão é empregar o método equals() da classe String.
import java.util.Scanner;
public class Teste {
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
String string;
System.out.print("Digite Sim: ");
string = entrada.nextLine();
if(string == "Sim")
System.out.println("Iguais");
else
System.out.println("Diferentes");
}
}
import javax.swing.JApplet;
import java.awt.Graphics;
public class AloMundoApplet extends JApplet {
public void paint(Graphics g){
g.drawString("Alô, Mundo!",25,25);
}
}
<html>
<applet code="AloMundoApplet.class" width=300 height=30>
</applet>
</html>
A palavra-chave extends indica que a
classe AloMundoApplet é uma subclasse
(ou classe derivada) de JApplet (chamada
superclasse ou classe básica).
A classe JApplet faz parte do pacote
javax.swing.
d inteiros em decimal.
t,T formato para data e hora (com códigos adicionais para dia, mês, ano, etc.)
import java.util.Date;
public class Teste {
public static void main(String args[]){
System.out.printf("Hoje: %1$td de %1$tB de
%1$tY", new Date());
}
}
++ pré-fixado ++a
++ pós-fixado a++
-- pré-fixado --b
-- pós-fixado b--
public class Incremento {
public static void main(String args[]) {
int i;
i = 1;
System.out.println(i);
System.out.println(i++);
System.out.println(i);
i = 1;
System.out.println(i);
System.out.println(++i);
System.out.println(i);
}
}
import java.awt.Graphics;
import javax.swing.JApplet;
public class TesteFor extends JApplet {
public void paint(Graphics g) {
for (int i = 1; i <= 10; i++)
g.drawLine(10, 10, 250, i * 10);
}
}
import javax.swing.JOptionPane;
import static javax.swing.JOptionPane.*;
public class SomaPar {
public static void main(String args[]) {
int soma = 0;
for (int i = 2; i <= 100; i += 2)
soma += i;
JOptionPane.showMessageDialog(null,
"Valor da soma: " + soma,
"Soma dos pares até 100",
INFORMATION_MESSAGE);
System.exit(0);
}
}
Exemplo: programa para calcular a potência de 2 dos números inteiros de 1 a 10.
import javax.swing.*;
public class Potencia {
public static void main(String args[]) {
double potencia;
JTextArea area = new JTextArea();
area.setText("Numero\tQuadrado\n");
for (int i = 1; i <= 10; i++) {
potencia = Math.pow(i, 2);
area.append("" + i + '\t' + potencia + '\n');
}
JOptionPane.showMessageDialog(null, area,
"Quadrado dos numeros de 1 a 10",
JOptionPane.INFORMATION_MESSAGE);
System.exit(0);
}
}
Para combinações AND, os operadores lógicos & e && são utilizados. Se & for
empregado, as expressões em ambos os lados são avaliadas.
Para combinações OR, os operadores lógicos | e || são utilizados. A combina-
ção XOR possui o operador lógico ^. Isto resulta em um valor true se a
expressão contiver um valor true e um false. A combinação NOT utiliza o
operador lógico !.
public class TestaOR1 {
public static void main(String args[]) {
int i = 2;
int j = 3;
if((j == i++) | (i < ++j))
System.out.println("i = " + i + " j = " + j);
}
}
public class TestaOR2 {
public static void main(String args[]) {
int i = 2;
int j = 3;
if((j == i++) || (i < ++j))
System.out.println("i = " + i + " j = " + j);
}
}
Os dois exemplos retornam o mesmo resultado. Na prática, para avaliação de
expressões lógicas, recomenda-se empregar os operadores && e ||.
public class TestaXOR {
public static void main(String args[]) {
int i = 2;
int j = 3;
if((j == i++) ^ (i < ++j))
System.out.println("XOR OK");
else
System.out.println("XOR not OK");
}
}
Métodos
A maioria dos programas de computador usados profissionalmente são muito
mais extensos do que os exemplos apresentados. A abordagem para grandes
programas é construí-los a partir de pequenas partes ou módulos.
Os módulos em Java são chamados métodos e classes. Os programas são
escritos combinando novos métodos e classes do usuário com métodos e classes
disponíveis na Java API e também com métodos e classes já disponibilizados
por outros programadores.
args[0] = "um"
args[1] = "dois"
args[2] = "três"
O espaço serve como separador de argumentos. Se for necessário tratar uma
cadeia de caracteres com espaço como um único argumento será preciso delimitá-
la com aspas duplas. Assim, o comando java teste um "dois três"
resulta no seguinte vetor:
args[0] = "um"
args[1] = "dois três"
O exemplo a seguir imprime a soma dos argumentos passados na linha de
comando.
public class Argumentos {
public static void main(String[] args) {
int soma = 0;
for(int i = 0; i < args.length; i++)
soma += Integer.parseInt(args[i]);
System.out.print("Soma dos argumentos: ");
System.out.println(soma);
}
}
s1 diferente de s2
Na realidade, o usuário nunca cria uma classe a partir do zero. Neste exemplo, a
classe Produto herda os atributos (dados) e comportamentos (métodos) da
classe Object.
A palavra-chave public é um modificadores de acesso aos membros da classe.
O modificador public indica que o acesso é permitido a outras classes.
A classe Produto possui um método chamado Produto. Este é o método
construtor da classe. Um construtor é um método especial que inicializa as
variáveis de instância de um objeto de classe.
System.out.println(produto.codigo + s +
produto.nome);
System.out.println(produto.quantidade + s +
produto.preco);
produto.quantidade = 100;
System.out.println(produto.quantidade + s +
produto.preco);
produto.preco *= 1.10;
System.out.println(produto.quantidade + s +
produto.preco);
}
}
A classe TestaProd declara uma variável produto do tipo Produto e a
instancia, através do comando new, que invoca o método construtor.
A linha tracejada indica
que a classe
TestaProd usa
métodos e/ou atributos
da classe Produto.
Rita 1050.0
Maria 1260.0
Julia 1575.0
class Empregado {
private String nome;
private double salario;
public Empregado(String n, double s) {
nome = n;
salario = s;
}
public Empregado(String n) {
nome = n;
salario = 500;
}
Métodos set e get
As variáveis de instância definidas como privadas só podem ser manipuladas
através de métodos da própria classe. Todavia, as classes podem fornecer
métodos public para permitir a clientes da classe atribuir valores (set) ou
obter (get) variáveis de instância declarados como private.
public class Cliente {
private String nome;
private String endereco;
private String telefone;
public Cliente(String n, String e, String t) {
nome = n;
endereco = e;
telefone = t;
}
public void setNome(String n) {nome = n;}
public void setEndereco(String e) {endereco = e;}
public void setTelefone(String t) {telefone = t;}
public String getNome() {return nome;}
public String getEndereco() {return endereco;}
public String getTelefone() {return telefone;}
}
public class TestaCliente {
public static void main(String args[]) {
Cliente fulano = new Cliente
("Fulano", "Rua Halfeld", "3213-5000");
Cliente beltrano = new Cliente
("Beltrano", "Rua Marechal", "3224-1000");
System.out.println("Cliente 1: " + fulano.getNome()+
", " + fulano.getEndereco() + ", " +
fulano.getTelefone() + "\n");
System.out.println("Cliente 2: " + beltrano.getNome() +
", "+ beltrano.getEndereco() + ", " +
beltrano.getTelefone() + "\n");
fulano.setNome("Ciclano");
beltrano.setEndereco("Rua Sao Joao");
fulano.setTelefone(beltrano.getTelefone());
System.out.println("Cliente 1: " + fulano.getNome()+
", " + fulano.getEndereco() + ", " +
fulano.getTelefone() + "\n");
System.out.println("Cliente 2: " + beltrano.getNome() +
", "+ beltrano.getEndereco() + ", " +
beltrano.getTelefone() + "\n");
}
}
Cliente 1: Fulano, Rua Halfeld, 3213-5000
Cliente 2: Beltrano, Rua Marechal, 3224-1000
Cliente 1: Ciclano, Rua Halfeld, 3224-1000
Cliente 2: Beltrano, Rua Sao Joao, 3224-1000
class VarOla {
public static void printSaudação(String... nomes) {
for(String n : nomes) {
System.out.println("Olá " + n + ". ");
}
}
public static void main(String[] args) {
printSaudação("Wander", "Rita", "Julia","Augusto");
}
}
class VarOla {
public static void printSaudação(String... nomes) {
for(String n : nomes) {
System.out.println("Olá " + n + ". ");
}
}
public static void main(String... args) {
printSaudação(args);
}
}
A Sun, inclusive, aconselha o uso de varargs em lugar de arrays na assinatura
do método main.
Sobrecarga com Varargs
O exemplo a seguir ilustra o comportamento do compilador Java no caso de
haver métodos sobrecarregados com e sem varargs disputando a execução.
import java.awt.Color;
public class ObjGeo {
private Color cor;
private int larg;
private int alt;
public ObjGeo (Color cor, int larg, int alt) {
this.cor = cor; this.larg = larg; this.alt =
alt;
}
public Color getCor() {return cor;}
public int getLarg() {return larg;}
public int getAlt() {return alt;}
import java.awt.Color;
public class TestaObjGeo {
public static void main(String args[]) {
ObjGeo obj = new ObjGeo(Color.red,4,8);
System.out.println("Cor: " + obj.getCor());
System.out.println("Largura: " + obj.getLarg());
System.out.println("Altura: " + obj.getAlt());
}
}
Cor: java.awt.Color[r=255,g=0,b=0]
Largura: 4
Altura: 8
Socios do clube:
Pedro, Rua Santa Rita
Paulo, Av. dos Andradas
Jose, Av. Rio Branco
Numero de socios: 3
Pacotes
Pacotes é a solução proposta pela Sun para reunir interfaces e classes
relacionadas formando uma biblioteca. Esta organização evita a colisão de
nomes de classes. Veja a extensão do problema: sendo Java uma linguagem para
atuar na internet, como evitar que classes obtidas por download não tenham os
mesmos nomes de classes já existentes na máquina?!
Observe que você pode criar objetos (instâncias) da classe Forma e também da
classe Circulo, utilizando o BlueJ.
import java.awt.Color;
public class TestaHeranca {
public static void main(String[] args) {
FormaGeo fg = new FormaGeo(Color.red, 4, 8);
Circulo circ = new Circul
(Color.blue, 2, 5, 10);
System.out.println
("Cor da Forma Geometrica: " + fg.getCor());
System.out.println
("Cor do Circulo: " + circ.getCor());
System.out.println
("Area do Circulo: " + circ.area());
System.out.println
("Coordenada X da Forma Geometrica: " +
fg.getX());
System.out.println("Coordenada Y do Circulo: " +
circ.getX());
}
}
Outro exemplo utilizando herança:
public class Ponto extends Object {
protected int x;
protected int y;
public Ponto(int a, int b) {
x = a;
y = b;
System.out.println("Ponto - " + this);
}
public String toString() {
return "Centro: [" + x + ", " + y + "]";
}
}
Considerando que todos os métodos de uma interface são abstratos, quando uma
classe implementa esta interface, deve escrever o código de todos esses métodos
abstratos. Este é o chamado contrato entre a interface e a classe que a
implementa.
import java.util.Date;
public interface Relogio {
void setHorario(Date d);
Date getHorario();
}
Voltando a classe Externa da página anterior, este exemplo ilustra como criar
um objeto da classe interna fora do código da instância da classe externa.
A instanciação de uma classe interna é o único cenário em Java em que se faz
necessário chamar new a partir de uma instância.
Classes Internas Anônimas
Java permite que se crie um objeto de uma classe interna sem nome, chamada
classe interna anônima.
class Externa {
public void imprime(){
System.out.println("Eu sou a classe externa");
}
}
public class TestaAnonima {
Externa ex = new Externa() {
public void imprime() {
System.out.println
("Eu sou a classe interna anônima");
}
};
public static void main(String[] args){
TestaAnonima ta = new TestaAnonima();
ta.ex.imprime();
}
}
Tratamento de exceções
Um erro para o qual pode existir um tratamento é chamado, em computação, de
exceção. Exemplos de exceções incluem divisão por zero, parâmetros de
métodos inválidos, overflow e subscrito de arrays fora dos limites.
Utilizar tratamento de exceções permite ao programador remover o código de
tratamento de erros da linha principal de execução do programa. Isso melhora a
clareza e a modificabilidade do código fonte.
public class Excecao {
public static void main(String[] args) {
System.out.println("Antes do erro");
try {
System.out.print(10 / 0);
}
catch(RuntimeException e){
System.out.println("Erro");
}
System.out.println("Depois do erro");
}
}
Exceções são objetos que pertencem a classes organizadas em uma hierarquia. A
classe que se encontra no topo desta hierarquia é a classe Throwable, que
possui duas subclasses: Exception e Error. Exception e suas subclasses
são usadas para indicar condições que podem ser recuperadas. Error e suas
subclasses indicam condições que em geral não podem ser recuperadas, causando
a terminação do programa.
Um método pode lançar mais de uma exceção, portanto, muitas vezes é preciso
definir um bloco try/catch capaz de tratar mais de uma exceção. Neste caso,
cada cláusula catch trata uma exceção.
class Matematica {
public static void main(String[] args) {
try {
int op1 = Integer.parseInt(args[0]);
int op2 = Integer.parseInt(args[1]);
System.out.println("Soma = " + (op1 + op2));
System.out.println("Subtracao = " + (op1 - op2));
System.out.println("Produto = " + (op1 * op2));
System.out.println("Divisao = " + (op1 / op2));
} catch(ArithmeticException ae) {
System.out.println("Erro de divisao por zero");
} catch(ArrayIndexOutOfBoundsException aie) {
System.out.println("Numero de argumentos invalido");
} catch(NumberFormatException nfe) {
System.out.println("Digite apenas numeros inteiros");
}
}
}
Para indicar que um método pode lançar uma exceção, Java utiliza a palavra
reservada throws, usada na declaração do método, e colocada antes da chave
de abertura do corpo do método.
Os métodos setHorizontalTextPosition e
setVerticalTextPosition do objeto Jlabel permitem especificar o
alinhamento do arquivo gráfico em relação ao texto do rótulo. Respectivamente,
controlam o alinhamento horizontal e vertical do ícone. O argumento
SwingConstants possui as opções LEFT, RIGHT e CENTER (horizontal) e
TOP e BOTTOM (vertical).
O método setToolTipText é herdado pela classe Jlabel da classe
JComponent e é utilizado para especificar um componente GUI com uma
dica de ferramenta.
Um objeto da classe ImageIcon é um objeto Icon, uma
vez que a classe ImageIcon implementa a classe Icon.
Tratamento de eventos
As GUIs são baseadas em eventos, tais como mover o mouse, clicar um
botão, selecionar um item de um menu, fechar uma janela, etc. Informações
de eventos são armazenados em objetos de classes que estendem AWTEvent.
Importante: Para processar um evento é necessário registrar um ouvinte de
eventos e implementar um tratador de eventos.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
class Calcula extends JFrame implements ActionListener
{
JLabel L1,L2,L3; //Cria 3 rótulos
JButton B1,B2,B3,B4,B5; //Cria 5 botões
JTextField T1,T2,T3; //Cria 3 caixas de texto
public static void main(String args[]){
Calcula calc = new Calcula();
calc.show();
calc.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
public Calcula()
{
setTitle("Calculadora");
setSize(350,150);
setLocation(50,50);
getContentPane().setLayout(new GridLayout(3,4));
L1 = new JLabel("Operando1");
L2 = new JLabel("Operando2");
L3 = new JLabel("Resultado");
B1 = new JButton("+");
B1.addActionListener(this);
B2 = new JButton("-");
B2.addActionListener(this); Associa ouvintes
B3 = new JButton("x");
B3.addActionListener(this);
de eventos para
B4 = new JButton("/"); cada um dos
B4.addActionListener(this); botões criados
B5 = new JButton("Limpar");
B5.addActionListener(this);
T1 = new JTextField();
T2 = new JTextField(); Torna a caixa de texto T3
T3 = new JTextField(); não-editável pelo usuário
T3.setEditable(false);
getContentPane().add(L1);
getContentPane().add(T1);
getContentPane().add(B1);
getContentPane().add(B2); Aloca os objetos de
getContentPane().add(L2); rótulos, botões e caixas
getContentPane().add(T2);
getContentPane().add(B3);
de texto ao gerenciador
getContentPane().add(B4); de leiaute.
getContentPane().add(L3);
getContentPane().add(T3);
getContentPane().add(B5);
}
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
public class Quitanda extends JFrame implements
ListSelectionListener
{
JTextField tf;
JList lista;
DefaultListModel dlm;
double[] preco = {0.8, 4.0, 3.5, 5.0, 0.7};
public static void main(String args[]){
Quitanda q = new Quitanda();
q.show();
q.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
Quitanda() {
setLocation(300,100);
setTitle("Quitanda do Prof. Wander");
setSize(250,70);
tf = new JTextField();
tf.setEditable(false);
dlm = new DefaultListModel();
dlm.addElement("Banana"); Os itens devem ser inseridos
dlm.addElement("Pera");
dlm.addElement("Maçã"); em um objeto da classe
dlm.addElement("Uva"); DefaultListModel
dlm.addElement("Laranja");
lista = new JList(dlm);
lista.addListSelectionListener(this);
JScrollPane painel = new JScrollPane(lista);
getContentPane().setLayout(new GridLayout(2,1));
getContentPane().add(painel);
getContentPane().add(tf);
}
public void valueChanged(ListSelectionEvent e){
tf.setText("Fruta: " + lista.getSelectedValue() +
" - Preço: R$ " + preco[lista.getSelectedIndex()]);
}
}
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
public class Quitanda extends JFrame implements ItemListener
{
JTextField tf;
JComboBox cb;
double[] preco = {0.8, 4.0, 3.5, 5.0, 0.7};
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class Estilo extends JFrame implements ItemListener
{
JLabel jl;
JCheckBox cb1,cb2; // cria dois objetos JCheckBox
static int negrito=0,italico=0;
public static void main(String args[]) {
Estilo est = new Estilo();
est.show();
est.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
} //fim do método main
Estilo()
Cria uma cor com os
{
getContentPane().setBackground valores RGB
(newColor(180,180,180)); 180, 180, 180
setTitle("Estilo de letras");
setSize(300,70); Cria um rótulo
getContentPane().setLayout usando a fonte
(newFlowLayout(FlowLayout.CENTER)); Arial, corpo 20
jl = new JLabel("Tupi ");
jl.setFont(new Font("Arial",Font.PLAIN,20));
jl.setForeground(Color.black);
cb1 = new JCheckBox("Negrito");
cb1.setBackground(new Color(180,180,180));
cb1.addItemListener(this);
cb2 = new JCheckBox("Italico");
cb2.setBackground(new Color(180,180,180));
cb2.addItemListener(this);
getContentPane().add(jl);
getContentPane().add(cb1);
getContentPane().add(cb2);
}
public void itemStateChanged(ItemEvent e) {
if(e.getSource()==cb1) {
if(e.getStateChange()==ItemEvent.SELECTED)
negrito=Font.BOLD;
else
negrito=Font.PLAIN;
}
if(e.getSource()==cb2) {
if(e.getStateChange()==ItemEvent.SELECTED)
italico=Font.ITALIC;
else
italico=Font.PLAIN;
}
jl.setFont(new Font("Arial",negrito+italico,20));
} //fim do método itemStateChanged
}
Ao se utilizar o padrão RGB (red-green-blue) para definir uma nova cor para
um objeto swing, os valores numéricos para estas três tonalidades devem variar
entre 0 e 255.
Para que a seleção seja reconhecida pelo método itemStateChanged, é
necessário invocar o método addItemListener para cada um dos objetos
JCheckBox instanciados. O método addItemListener será executado
sempre que o usuário clicar em um dos botões JCheckBox.
A comparação e.getStateChange()==ItemEvent.SELECTED é
utilizada para verificar se o componente JCheckBox está marcado ou não.
As propriedades SELECTED e DESELECTED indicam que o objeto está,
respectivamente, marcado e desmarcado.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.text.DecimalFormat;
public class Conversao extends Jframe
implements AdjustmentListener {
JScrollBar sb1;
JLabel l1,l2;
DecimalFormat df;
public static void main(String args[]) {
JFrame c = new Conversao();
c.show();
c.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
Conversao()
{
setSize(250,100);
setTitle("Conversão de Medidas");
getContentPane().setLayout(new GridLayout(3,1));
sb1 = new JScrollBar(JScrollBar.HORIZONTAL,0,5,0,105);
sb1.addAdjustmentListener(this);
l1 = new JLabel(”Centímetros",JLabel.CENTER);
l2 = new JLabel(”Polegadas",JLabel.CENTER);
getContentPane().add(sb1);
getContentPane().add(l1);
getContentPane().add(l2);
}
public void adjustmentValueChanged(AdjustmentEvent e) {
l1.setText(sb1.getValue() + " Centímetros");
DecimalFormat nf;
df = new DecimalFormat(“0.000”);
double pol = sb1.getValue() / 2.54;
l2.setText(df.format(pol) +" Polegadas");
}
}
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class Profissa extends JFrame implements ActionListener
{
JMenuBar mb;
JMenu Arquivo, Save;
JMenuItem Novo, Abrir, Sair, Salvar, SalvarComo, SalvarTudo;
public static void main(String args[])
{
JFrame p = new Profissa();
p.show();
p.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
public Profissa() {
setTitle("Menu Profissional");
setSize(250,150);
mb = new JMenuBar(); //cria a barra de menus
Arquivo = new JMenu("Arquivo"); //cria um novo menu
Arquivo.setMnemonic(KeyEvent.VK_A);
Arquivo.addActionListener(this);
Save = new JMenu("Save"); //cria um novo menu
Novo = new JMenuItem ("Novo",new ImageIcon("icon2.gif"));
Novo.addActionListener(this);
Novo.setAccelerator(KeyStroke.getKeyStroke
(KeyEvent.VK_N, ActionEvent.ALT_MASK));
Novo.setMnemonic(KeyEvent.VK_N);
Abrir = new JMenuItem ("Abrir",new ImageIcon("PASTA2.gif"));
Abrir.addActionListener(this);
Abrir.setAccelerator(KeyStroke.getKeyStroke
(KeyEvent.VK_A, ActionEvent.ALT_MASK));
Abrir.setMnemonic(KeyEvent.VK_B);
Salvar = new JMenuItem ("Salvar",new ImageIcon("disk_cat.gif"));
Salvar.addActionListener(this);
Salvar.setAccelerator(KeyStroke.getKeyStroke
(KeyEvent.VK_S, ActionEvent.CTRL_MASK));
Salvar.setMnemonic(KeyEvent.VK_S);
SalvarComo = new JMenuItem ("Salvar Como");
SalvarComo.setAccelerator(KeyStroke.getKeyStroke
(KeyEvent.VK_C, ActionEvent.CTRL_MASK));
SalvarComo.addActionListener(this);
SalvarComo.setMnemonic(KeyEvent.VK_C);
SalvarTudo = new JMenuItem ("Salvar Tudo");
SalvarTudo.addActionListener(this);
SalvarTudo.setAccelerator(KeyStroke.getKeyStroke
(KeyEvent.VK_T, ActionEvent.CTRL_MASK));
SalvarTudo.setMnemonic(KeyEvent.VK_T);
Sair = new JMenuItem ("Sair",new ImageIcon("DOOR_EXI.gif"));
Sair.addActionListener(this);
Sair.setAccelerator(KeyStroke.getKeyStroke
(KeyEvent.VK_X, ActionEvent.ALT_MASK));
Sair.setMnemonic(KeyEvent.VK_A);
Save.add(Salvar); //adiciona o item ao menu
Save.add(SalvarComo); //adiciona o item ao menu
Save.add(SalvarTudo); //adiciona o item ao menu
Arquivo.add(Novo); //adiciona o item ao menu
Arquivo.add(Abrir); //adiciona o item ao menu
Arquivo.add(Save); //adiciona o item ao menu
Arquivo.addSeparator(); //adiciona uma barra divisória
Arquivo.add(Sair); //adiciona o item ao menu
mb.add(Arquivo); //adiciona o menu à barra
setJMenuBar(mb); //define a barra de menus como padrão
}
public void actionPerformed(ActionEvent e) {
if (e.getSource() == Novo)
JOptionPane.showMessageDialog(null,"menu Novo.",
"Usando menus",JOptionPane.INFORMATION_MESSAGE);
if (e.getSource() == Abrir)
JOptionPane.showMessageDialog(null,"menu Abrir.",
"Usando menus",JOptionPane.INFORMATION_MESSAGE);
if (e.getSource() == Salvar)
JOptionPane.showMessageDialog(null,"Sub-menu Salvar.",
"Usando menus",JOptionPane.INFORMATION_MESSAGE);
if (e.getSource() == SalvarComo)
JOptionPane.showMessageDialog(null,"Sub-menu Salvar Como.",
"Usando menus",JOptionPane.INFORMATION_MESSAGE);
if (e.getSource() == SalvarTudo)
JOptionPane.showMessageDialog(null,"Sub-menu Salvar Tudo.",
"Usando menus",JOptionPane.INFORMATION_MESSAGE);
if (e.getSource() == Sair)
System.exit(0);
}
}