Java 6 - Martins Fontes

Guia de Consulta Rápida
Java 6
Peter Jandl Jr.
Novatec Editora
Copyright  2008 da Novatec Editora Ltda.
Todos os direitos reservados e protegidos pela Lei 9.610 de
19/02/1998. É proibida a reprodução desta obra, mesmo parcial,
por qualquer processo, sem prévia autorização, por escrito, do
autor e da Editora.
Editor: Rubens Prates
ISBN: 978-85-7522-159-6
Novatec Editora Ltda.
Rua Luís Antônio dos Santos 110
02460-000 São Paulo SP – Brasil
Tel.: +55 11 2959-6529
Fax: +55 11 2950-8869
E-mail: [email protected]
Site: www.novatec.com.br
Sobre o autor
Peter Jandl Junior é engenheiro eletricista pela Unicamp, mestre
em educação pela USF, e Programador Certificado pela Sun
Microsystems para a Plataforma Java 2. Já trabalhou em várias
empresas, entre elas IBM e Promon, lecionando a mais de 20 anos.
Atualmente é coordenador do curso de ciência da computação da
FAJ e também professor nos cursos de graduação e pós-graduação
do UniAnchieta e Policamp.
Sumário
Parte I: Elementos fundamentais.............................................. 4
Java: uma brevíssima apresentação................................... 4
Ambiente Java................................................................. 4
Programa mínimo, compilação e execução........................ 5
Variáveis.......................................................................... 7
Entrada e saída básicas.................................................. 10
Operadores e expressões.................................................12
Diretivas (statements).....................................................17
Tratamento genérico de exceções.................................... 23
Modificadores especiais................................................. 24
Arranjos (arrays)........................................................... 25
Matrizes........................................................................ 26
Argumentos da linha de comando.................................. 28
Parte II: Orientação a Objetos................................................ 29
Conceitos fundamentais................................................ 29
Exceções (exceptions).................................................... 39
Criação de Pacotes......................................................... 42
Herança (inheritance).................................................... 44
Interfaces....................................................................... 48
Polimorfismo................................................................. 50
Classes aninhadas, internas e anônimas...........................52
Classes Wrapper............................................................ 54
Enumerações (Java 5 ou +)............................................ 56
Genéricos (Java 5 ou +).................................................. 57
Parte III: API Java................................................................... 63
Introdução.................................................................... 63
Usando a Documentação do JDK................................... 64
Pacote java.lang...................................................................... 65
Interfaces de java.lang.................................................... 65
Classes de java.lang........................................................ 66
Enumerações de java.lang.............................................. 87
Exceções de java.lang..................................................... 87
Erros de java.lang.......................................................... 88
Pacote java.util....................................................................... 90
Interfaces de java.util..................................................... 90
Classes de java.util......................................................... 96
Enumerações de java.util..............................................120
Exceções de java.util..................................................... 121
Erros de java.util.......................................................... 121
Pacote java.io........................................................................122
Interfaces de java.io.......................................................122
Classes de java.io..........................................................125
Exceções de java.io.......................................................140
Erros de java.io.............................................................140
Índice remissivo.................................................................... 141
Parte I: Elementos fundamentais
Java: uma brevíssima apresentação
Criado a partir de um projeto da Sun Microsystems voltado para
dispositivos portáteis inteligentes, o Java foi lançado em 1995 como
uma alternativa para construção de aplicações web e tornou-se um
sucesso acadêmico e corporativo devido suas características.
A plataforma de programação Java é formada de uma linguagem
de mesmo nome e de uma extensa biblioteca de classes 100%
orientada a objetos, independente de plataforma, segura e de ótima
performance. Atualmente possui três divisões:
Divisão
Descrição
Java ME Java Micro Edition: destinada a dispositivos computacionais
móveis, tais como celulares, PDAs e set-top boxes.
Java SE Java Standard Edition: integra os elementos padrão do Java
e permite criar aplicações de pequeno e médio porte.
Java EE Java Enterprise Edition: voltada para o desenvolvimento de
aplicações corporativas complexas.
É usada no desenvolvimento de aplicações desktop, em rede,
com arquivos, interfaces gráficas, componentes, imagens, conteúdo
multimídia, bancos de dados, threads, voltadas ou não para a web
e que podem ser integradas a outros sistemas existentes.
Embora a API (Application Programming Interface) Java tenha
sido ampliada enormemente, ocorreram poucas mudanças na
linguagem em si. A versão 5 (denominada Tiger) incorporou a maior
parte dos novos elementos na linguagem (Tabela 1).
Tabela 1 – Histórico da plataforma Java
Ano
Versão
Versão
Interna
1996
1.0
1.0
Versão inicial.
1997
1.1
1.1
Classes internas.
1998
1.2
1.2
Declaração strictfp. Compilação JIT.
2000
1.3
1.3
Tecnologia HotSpot para JVM.
2002
1.4
1.4
Diretiva assert.
2004
5.0
1.5
Genéricos. Autoboxing. Metadata (Anotações).
Enumerações.
2006
6.0
1.6
Suporte para scripting. Melhorias nas anotações.
Novas características da linguagem Java
Ambiente Java
Java é independente de plataforma porque seus programas são
compilados em um formato neutro, os bytecodes, armazenados
em arquivos de classe .class. Em cada combinação de hardware
e SO (sistema operacional) deve existir uma JVM (Java Virtual
Machine), programa que interpreta os bytecodes como código
nativo do sistema, usando os serviços oferecidos pelo sistema
operacional (Figura 1).
Ambiente Java
Figura 1 – Código-fonte, bytecodes e código nativo.
O ambiente Java (Figura 2) se compõe de uma JVM, da API Java e
pelas classes da aplicação. O Sun JavaRE (Java Runtime Environment)
provê um ambiente mínimo. O endereço para download gratuito é:
http://java.sun.com/javase/downloads/index.jsp.
Figura 2 – Ambiente Java.
Programa mínimo, compilação e execução
O Sun JavaSE Development Kit (JDK) é um ambiente de
desenvolvimento Java considerado padrão e inclui um conjunto
útil de ferramentas de desenvolvimento, além do próprio JRE.
Seu download gratuito pode ser feito em http://java.sun.com/
javase/downloads/index.jsp. Além do JDK será necessário um editor
de texto simples, tal como o Bloco de notas dos sistemas Windows
ou vi dos sistemas Unix e Linux.
Instalando e configurando o JDK
Instale o JDK seguindo as instruções do programa instalador. Para
seu funcionamento correto é preciso alguns ajustes no sistema.
1. Criar uma variável de ambiente CLASSPATH, cujo conteúdo inicial
seja . (um ponto indica o diretório atual).
2. Editar a variável de ambiente PATH, que em geral existe, e adicionar
o diretório bin do JDK (na plataforma Windows é C:\Arquivos de
programas\Java\jdk1.6.0_05\bin).
Num sistema com Windows XP, abra o Explorer, localize Meu
Computador, no seu menu de contexto selecione Propriedades.
Na janela que aparece selecione a guia Avançado e então o botão
Variáveis de ambiente para criar e editar as variáveis de usuário
necessárias. Feche a janela e a configuração estará em vigor.
Estrutura dos programas Java
Um programa em Java se compõe de um ou mais arquivos-fonte
onde cada um pode conter:
• uma declaração de pacote (package);
• uma ou mais diretivas de importação (import);
Elementos fundamentais
• uma ou mais declarações de classes (class);
• uma ou mais declarações de interfaces (interface).
O início de todo programa é o método main(String [ ]), declarado
em alguma de suas classes e também o mínimo exigido.
Programa mínimo
O menor programa Java é constituído de uma classe na qual exista
o método main(String [ ]).
Exemplo (HelloWorld.java)
public class HelloWorld { // declaração da classe HelloWorld
// declaração do método main, que dá início ao programa
public static void main (String args[ ]) {
// impressão da mensagem
System.out.println (“Hello world!”);
} }
Com um editor, digite e salve o programa em um arquivo
denominado HelloWorld.java num diretório de sua preferência.
Uso de maiúsculas e minúsculas
O Java é uma linguagem sensível ao caixa, i.e., que distingue
maiúsculas de minúsculas: public é diferente de Public.
Comentários
Fragmentos de texto usados para anotar explicações no próprio
programa e desconsiderados pelo compilador, neles podem figurar
qualquer caractere ou acentuação.
Delimitador
Descrição
//
/* */
/** */
Comentário de linha.
Comentário de bloco (múltiplas linhas).
Comentário de documentação.
Exemplos:
// comentário de uma linha isolado
import java.util.*; // comentário de linha com comando
/* Comentário de bloco, que pode utilizar-se de uma
ou mais linhas livremente. */
double a = 10.3; /* comentário de bloco com comando */
/** Comentário de documentação
Classe que define ponto no espaço 3D. */
public classe Ponto3D { ... }
Os comentários de documentação são colocados antes da
declaração dos elementos do programa. A ferramenta javadoc do
JDK pode extraí-los do fonte e criar páginas de documentação
em formato HTML, organizadas conforme a estrutura das classes.
Várias tags HTML podem ser usadas, além das marcações ‘@’ que
permitem criar referências cruzadas e outros elementos.
Compilação
A compilação no JDK usa um Console ou Prompt de comando. A
sintaxe do compilador javac é:
javac [-opções] <nomeDoArquivo.java>
Para compilar um programa (p.e. HelloWorld.java), navegue até
o diretório onde o arquivo fonte foi salvo e digite:
> javac HelloWorld.java
Programa mínimo, compilação e execução
A extensão .java deve ser fornecida. A compilação produz os
arquivos de classe correspondentes (no caso HelloWorld.class) e não
exibe mensagem quando correta. Caso ocorram erros, use um editor
para efetuar as correções nas linhas indicadas.
Execução
A execução é feita por meio do programa java (JVM) cuja sintaxe é:
java [-opções] <nomeDaClasse>
Usando um Console ou um Prompt de comando, no diretório
onde o programa foi compilado, digite:
> java HelloWorld
A extensão .class nunca é fornecida quando se executa um
programa Java. A Figura 3 mostra um Prompt de comando com a
compilação e execução do exemplo HelloWorld.java.
Figura 3 – Compilação e execução.
Variáveis
A declaração de variáveis em Java requer: um tipo de dados, um
nome (identificador) e, opcionalmente, um valor inicial.
Tipos de dados primitivos
Definem o conjunto de valores que podem ser armazenados em
uma variável e também as operações sobre seus valores. O Java
possui oito tipos primitivos (Tabela 2).
Tabela 2 – Tipos de dados primitivos
Descrição
Tam.
Intervalo
byte
Tipo
short
inteiros positivos e negativos
inteiros positivos e negativos
1
2
int
inteiros positivos e negativos
4
long
inteiros positivos e negativos
8
float
valores em ponto flutuante
4
double
valores em ponto flutuante
8
char
caracteres individuais
tipo lógico
2
1
-128 a +127
-32.768 a +32.767
-2.147.483.648 a
+2.147.483.647
-2^64 a +2^64 – 1
positivos: +1,4013E-45 a
+3.4028E+38 negativos:
-3.4028E+38 a -1.4013E-45
positivos: +4,9407E-324 a
+1.7977E+308 negativos:
-1.7977E+308 a -4.9407E-324
De \u0000 a \uFFFF
false ou true
boolean
Elementos fundamentais
Os tipos inteiros diferem apenas em seus limites, assim como
tipos em ponto flutuante diferem em relação à precisão oferecida
devido ao número de bytes que ocupam na memória. Todos os tipos
numéricos suportam valores positivos e negativos.
O tipo char representa um caractere individual no padrão
UNICODE, o qual permite representar idiomas complexos, tais
como árabe, chinês, hindu, japonês etc.
Valores literais
São aqueles escritos diretamente no programa. Valores inteiros são
tratados como int e em ponto flutuante são tratados como double.
Outros tipos devem usar sufixos ou prefixos predefinidos:
Tabela 3 – Sufixos ou prefixos predefinidos
Tipo
Sufixo
Prefixo
Exemplo
long
L
1234567890L
float
f
0.345f
octal
hexadecimal
0
053
0x ou 0X 0x75DA
O caractere ponto . deve ser usado como separador de casas
decimais. Expoentes (em base 10) para notação científica usam os
caracteres e ou E.
O tipo boolean representa os valores lógicos correspondentes aos
literais false e true. Não existe qualquer equivalência entre valores
lógicos e inteiros, como em C/C++.
Caracteres literais do tipo char devem figurar entre aspas simples,
tal como ‘P’ ou ‘j’.
Caracteres especiais
Caracteres de controle que não têm representação visual são expressos
pela combinação da barra invertida \ com outro código.
Código
Descrição
\’
\”
\\
\f
\b
\u143F
\n
\fca
\r
\g43
\t
Apóstrofe.
Aspas duplas.
Barra invertida.
Nova página (form feed).
Retrocesso (backspace).
Caractere UNICODE 143F.
Quebra de linha (newline ou linefeed).
Caractere hexadecimal FCA.
Retorno de carro (carriage return).
Caractere octal 43.
Tabulação horizontal (horizontal tab).
Nomes das variáveis (identificadores)
Formados por um ou mais caracteres de a a z (maiúsculas diferentes
das minúsculas), dígitos de 0 a 9, o cifrão $ e o sublinhado _. Os
nomes devem ser iniciados pelos caracteres alfabéticos, $ ou _. Outros
caracteres, operadores, símbolos ou espaços são proibidos.
Variáveis
Apenas os 32 primeiros caracteres são usados para distinguir
um nome dos demais. Exemplos válidos são: raio, A, x12, _mktg,
$especial, valorTotal, DIF, Nome23d, num_Minimo, a$d98.
Palavras reservadas
São nomes que não podem ser utilizados como identificadores de
variáveis, métodos ou outras construções do programador. São usadas
para a denominação de tipos, diretivas, especificadores etc.
abstract
assert
boolean
break
byte
case
catch
char
class
continue
default
do
double
else
enum
extends
false
final
finally
float
for
if
implements
import
instanceof
int
interface
long
native
new
null
package
private
protected
public
return
short
static
strictfp
super
switch
synchronized
this
throw
throws
transient
true
try
void
volatile
while
Além dessas existem const e goto, que são reservadas, mas sem
uso definido.
Nomenclatura de variáveis
Segundo a convenção de nomenclatura Java os nomes de variáveis
devem: usar letras minúsculas; se constituídos de uma única
letra sugere-se a inicial de seus tipos; caso sejam compostos de
várias palavras, a primeira inicial deve ser minúscula e as demais
iniciais maiúsculas para melhorar a legibilidade. O uso de dígitos
é livre, mas não se recomenda o uso do cifrão $ ou sublinhado
_. Exemplos adequados são: i, f, b12, x14, sinal, posicaoSuperior,
valorMinimoEsperado.
Declaração de variáveis
A declaração de uma variável deve indicar seu tipo e seu nome:
<Tipo> <nome1> [, nome2 [, nome3 [...] ] ];
Exemplos possíveis e válidos são:
int resultado;
float total;
boolean flag;
É possível declarar várias variáveis ao mesmo tempo:
short nLinha, nColuna, s;
long contagem, valorMaximo, valorMinimo;
double altura, largura, profundidade, area, volume;
Também é possível declarar e inicializar uma variável:
byte br, mascara = 0xFF;
float angulo = 1.57f, temp = -14.75f;
long limite = 1234567890L;
double taxa = 0.075, cpmf = 38e-4;
boolean continua = false, ok = true;
char opcao = ‘s’;
10
Elementos fundamentais
Escopo de variáveis
Escopo é a região do programa onde uma declaração tem validade,
delimitado por pares de chaves { e } (blocos). Variáveis podem ser
declaradas em praticamente qualquer ponto do programa e estão
em seu escopo quando usadas no bloco onde foram declaradas e
nos escopos internos, a partir da sua declaração.
Exemplo (Escopo.java)
public class Escopo {
public static void main (String args[]) { // bloco 1
System.out.print(“Bloco 1: “);
int i = 1; // variável declarada no bloco 1
System.out.println(“i=” + i);
{ // bloco 2
System.out.print(“Bloco 2: “);
int j = 2; // variável declarada no bloco 2
System.out.println(“i=” + i + “ j=” + j);
{ // bloco 3
System.out.print(“Bloco 3: “);
int k = i + j; // variável declarada no bloco 3
System.out.println(“i=”+i+“ j=”+j+“ k=”+k);
} // uso de k torna-se inválido
System.out.print(“Bloco 2: “);
System.out.println(“i=” + i + “ j=” + j);
} // uso de j e k tornam-se inválidos
System.out.print(“Bloco 1: “);
System.out.println(“i=” + i);
} }
Ao encerrar-se um bloco, as variáveis ali declaradas deixam
de existir. Embora possam ser declaradas novas variáveis, não se
podem utilizar os nomes dos escopos exteriores, pois o compilador
não consegue distinguí-las gerando erros.
Entrada e saída básicas
Entrada não formatada
A entrada simples de dados se faz através do console (teclado):
char c = System.in.read();
// lê um caractere
Nesta chamada temos:
Item
Descrição
System
in
read
Classe da API que disponibiliza um objeto in.
Objeto que representa a entrada de dados do console.
Método que lê caracteres individuais da entrada.
O uso direto de in é complexo, pois suporta apenas a leitura de
caracteres, exigindo sua associação com outras classes.
Saída não formatada
A saída simples de dados em um programa também se dá através
do console, exibindo informações em modo texto:
System.out.println(“Olá!”); // exibe a mensagem Olá!
Nesta chamada temos:
Item
Descrição
System
out
println
Classe da API que disponibiliza um objeto out.
Objeto que representa a saída para o console.
Método que imprime valores, mensagens e objetos.
Entrada e saída básicas
11
Com println se exibem mensagens, valores literais, conteúdo de
variáveis, expressões e qualquer combinação entre estes elementos,
finalizando a linha em que ocorre a exibição.
O método print realiza as mesmas tarefas, mas não finaliza a
linha de exibição, possibilitando a adição de outras mensagens.
Entrada formatada (Java 5 ou +)
A classe Scanner pode efetuar a entrada formatada de dados, como
mostra o exemplo EntradaSaida.java.
Exemplo (EntradaSaida.java)
import java.util.Scanner;
public class EntradaSaida {
public static void main (String args[]) {
System.out.println(“Ola!”); // Mensagem inicial
// Exibe mensagem e prepara entrada de dados
System.out.print(“Digite um inteiro: “);
Scanner s = new Scanner(System.in);
int valor = s.nextInt(); // declara e inicia variável
// exibição do valor lido
System.out.println(“Valor digitado = “ + valor);
} }
A classe Scanner, do pacote java.util, é importada através da
diretiva import. Outros tipos primitivos diferentes de int podem ser
lidos trocando-se a chamada nextInt() por outra do tipo desejado
(nextByte(), nextDouble(), nextFloat(), nextLong(), nextShort()). O tipo
String pode ser lido através de next() (que retorna uma palavra) ou
nextLine() (retorna uma linha inteira).
Saída formatada (Java 5 ou +)
O método printf, usado através do objeto out da classe System, é
conveniente para realizar a saída formatada de dados. Sua sintaxe é:
System.out.printf(<formatação> [, expr1 [, expr2 [ ...]]] );
A formatação é uma String que pode conter uma mensagem
simples ou intercalada de marcadores para inclusão de valores.
Quando marcadores estão presentes, deve existir o mesmo número
de expressões para prover seus valores. Durante a impressão, cada
marcador é substituído pelo valor da expressão correspondente,
formatado conforme seu tipo. Exemplos:
// exibe mensagem “Guia Java 6” e quebra linha
System.out.printf(“Guia Java 6%n”);
// exibe mensagem e valor inteiro
System.out.printf(“Valor inteiro: %d %n”, 20);
int x = 10, y = 3;
System.out.printf(“%d/%d = %f%n”, x, y, (float)(x/y));
Este método é como a função printf da linguagem C. Detalhes da
sintaxe de formatação se encontram na classe java.util.Formatter.
Exemplo (SaidaFormatada.java)
import java.util.Scanner;
public class SaidaFormatada {
public static void main(String a[]) {
Scanner sc = new Scanner(System.in);
System.out.print(“No final? “);
int limite = sc.nextInt();
int soma = 0;
12
Elementos fundamentais
for(int i=1; i<=limite; i++) {
System.out.printf(
“%3da. soma parcial = %6d%n”, i, soma);
soma += i;
}
System.out.printf(“Total[0..%3d] = %6d%n”, limite, soma);
} }
Operadores e expressões
Operadores são símbolos que indicam as operações de atribuição,
aritméticas, bit a bit, relacionais e lógicas.
Uma expressão pode ser um valor literal simples, uma constante,
uma variável, a chamada de um método ou uma combinação
qualquer de literais, variáveis, operadores e chamadas de métodos
que produz um resultado numérico ou lógico.
Operador de atribuição
Operador Descrição
=
Atribui o valor de um elemento ou resultado de uma
expressão a uma variável.
Exemplos:
i = 0;
tempF = 1.8 * tempC + 32.0;
xComp = amplitude * Math.cos(1.57);
As atribuições também podem ser incluídas nas declarações de
variáveis fazendo que estas recebam um valor inicial:
// variáveis iniciadas com valores literais
int a = 2, b = 3;
// variável iniciada com expressão válida
double c = 2.3*a + b/3.0;
Operadores aritméticos
Realizam operações algébricas sobre variáveis numéricas.
Operador Descrição
+
-
*
/
%
-
+
Adição.
Subtração.
Multiplicação.
Divisão.
Resto da divisão inteira.
Sinal negativo (- unário).
Sinal positivo (+unário).
• Na divisão entre valores de tipos inteiros o resultado também
é inteiro. Frações resultantes são descartadas.
int a = 9, b = 2, c = 6, d = 3;
System.out.println(a / b);
System.out.println(c / d);
// exibe 4
// exibe 2
• O operador ‘%’ permite obter o resto da divisão inteira entre
dois valores inteiros.
int a = 9, b = 2, c = 6, d = 3;
System.out.println(a % b);
System.out.println(c % d);
// exibe 1
// exibe 0
Operadores de incremento e decremento
Efetuam o incremento ou decremento de variáveis numéricas.
Operadores e expressões
13
Operador
Descrição
++
--
Incremento unitário (adiciona uma unidade).
Decremento unitário (subtrai uma unidade).
• Se usado como prefixo, a operação é realizada antes do uso do
valor da variável (pré-incremento ou pré-decremento).
int a = 1, b;
b = ++a; // b recebe 2, a contém 2
• Se usado como sufixo, a operação é realizada depois do uso do
valor da variável (pós-incremento ou pós-decremento).
int a = 1, b;
b = a++; // b recebe 1, a contém 2
Exemplo (OperArit.java)
import java.util.Scanner;
public class OperArit {
public static void main (String args[]) {
int a, b, c; // qualquer tipo numérico pode ser usado
// lê valores para a e b
Scanner s = new Scanner(System.in);
// leitura usa método apropriado p/ tipo declarado
System.out.print(“a ? “); a = s.nextInt();
System.out.print(“b ? “); b = s.nextInt();
// realiza operações com valores dados
c = a + b;
System.out.println(“a + b = “ + c);
System.out.println(“b - a = “ + (b - a));
System.out.println(“a * b = “ + (a * b));
System.out.println(“a / b = “ + (a / b));
System.out.println(“a % b = “ + (a % b));
System.out.println(“a = “ + a + “ b = “ + b);
System.out.println(“c = -a = “ + (-a));
System.out.println(“c = ++a = “ + (++a));
System.out.println(“c = b-- = “ + (b--));
System.out.println(“a = “ + a + “ b = “ + b);
} }
Promoção automática de tipos
Quando tipos diferentes são misturados numa expressão, os mais
simples são transformados nos tipos mais complexos presentes
através da promoção automática (Tabela 4).
Tabela 4 – Promoção automática de tipos
1o operando
2º operando
B
S
I
L
F
D
B
B
S
I
L
F
D
S
S
S
I
L
F
D
I
I
I
I
L
F
D
L
L
L
L
L
F
D
F
F
F
F
F
F
D
D
D
D
D
D
D
D
B=byte, D=double, F=float, I=int, L=long, S=short
14
Elementos fundamentais
Exemplo:
int i = 3; long l = 12; float f = 1.5f; double d = 2.25;
// resultado é 10, mas do tipo double
double res = (i + l) * f / d;
A promoção é automática porque não existe perda de precisão
quando um tipo simples é convertido em outro complexo.
Coerção (type casting)
Coerção (type casting) é a conversão de um tipo mais complexo
em outro mais simples. Como provoca perda de precisão, deve ser
explicitada para que o compilador autorize a operação.
Esta indicação se faz com a colocação do tipo desejado entre
parêntesis antes da expressão cujo resultado será convertido:
double d = 3.47;
// x recebe 3, parte fracionária é truncada
int x = (int) d;
// resultado 2*3.47 é convertido para float
float f = (float) (2 * d);
A coerção de tipos também pode ser aplicada a objetos.
Operadores relacionais
Comparam expressões numéricas retornando um resultado lógico.
Operador Descrição
==
!=
>
>=
<
<=
Igualdade.
Diferença.
Maior que.
Maior que ou igual a.
Menor que.
Menor que ou igual a.
• O operador de igualdade “==” não deve ser confundido com
o operador de atribuição ‘=’.
• Não podem ser usados na comparação de strings ou objetos.
Exemplo (OperRelac.java)
import java.util.Scanner;
public class OperRelac {
public static void main (String args[]) {
double a, b; // declara variáveis
// lê valores para a e b
Scanner s = new Scanner(System.in);
System.out.print(“a ? “); a = s.nextDouble();
System.out.print(“b ? “); b = s.nextDouble();
// realiza as operações relacionais
System.out.println(“a == b = “ + (a == b));
System.out.println(“a != b = “ + (a != b));
System.out.println(“a > b = “ + (a > b));
System.out.println(“a >= b = “ + (a >= b));
System.out.println(“a < b = “ + (a < b));
System.out.println(“a <= b = “ + (a <= b));
} }
Operadores lógicos
Interligam expressões lógicas produzindo um resultado lógico.
Operador
Descrição
&&
||
!
E lógico (and).
Ou lógico (or).
Negação (not).
Operadores e expressões
15
Exemplo (OperLogic.java)
public class OperLogic {
public static void main (String args[]) {
// declara e inicializa algumas variáveis
boolean a = true, b = false;
// exibe valores de a e b
System.out.println(“a = “ + a + “ b = “ + b);
// realiza as operações lógicas
System.out.println(“a && b = “ + (a && b));
System.out.println(“a || b = “ + (a || b));
System.out.println(“
!a = “ + (!a));
System.out.println(“
!b = “ + (!b));
} }
Operador ternário
É um avaliador simples que permite usar o valor de duas expressões
diferentes conforme o resultado da condição. Sua sintaxe é:
<cond> ? <expr_true> : <expr_false>
Se a expressão cond é verdadeira, é retornado o resultado de
é retornado o resultado de expr_false.
expr_true, senão
Exemplo (OperTernario.java)
import java.util.Scanner;
public class OperTernario {
public static void main (String args[]) {
Scanner sc = new Scanner(System.in);
System.out.print(“Preco Alcool: “);
double alcool = sc.nextDouble();
System.out.print(“Preco Gasolina: “);
double gasolina = sc.nextDouble();
// atribui o maior valor
double maior = gasolina > alcool ? gasolina : alcool;
// exibe qual combustível é mais vantajoso
System.out.println(“Eh mais vantajoso abastecer com “
+ (alcool/gasolina<0.7 ? “alcool” : “gasolina”) + “.”);
} }
Operadores bit a bit (bitwise)
Manipulam os bits de seus operandos.
Operador Descrição
&
|
^
~
<<
>>
>>>
E bit-a-bit (bitwise and).
Ou bit-a-bit (bitwise or).
Ou-exclusivo bit-a-bit (bitwise xor).
Complemento de 2.
Rotação à esquerda (left shift) de n bits.
Rotação à direita (right shift) de n bits.
Rotação à direita sem sinal (unsigned right shift).
• As operações bitwise E, Ou e Ou-Exclusivo são realizadas bit a
bit (a0 com b0, a1 com b1 e assim por diante).
•
~
•
<< e >> rotacionam os bits do 1º operando, à esquerda ou direita,
só toma um operando e efetua seu complemento de 2.
de n posições (2º operando). Equivalem a multiplicar ou dividir
por 2n.
•
>>>
também rotaciona à direita, mas toma o bit de sinal como
parte do valor do operando.
Exemplo (OperBitwise.java)
public class OperBitwise {
public static void main (String args[]) {