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: novatec@novatec.com.br

Site: www.novatec.com.br

Sobre o autorPeter 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 ............................................. 4Java: uma brevíssima apresentação .................................. 4Ambiente Java ................................................................ 4Programa mínimo, compilação e execução ....................... 5Variáveis ......................................................................... 7Entrada e saída básicas ................................................. 10Operadores e expressões ................................................12Diretivas (statements) ....................................................17Tratamento genérico de exceções ................................... 23Modificadores especiais ................................................ 24Arranjos (arrays) .......................................................... 25Matrizes ....................................................................... 26Argumentos da linha de comando ................................. 28

Parte II: Orientação a Objetos ............................................... 29Conceitos fundamentais ............................................... 29Exceções (exceptions).................................................... 39Criação de Pacotes ........................................................ 42Herança (inheritance) ................................................... 44Interfaces ...................................................................... 48Polimorfismo ................................................................ 50Classes aninhadas, internas e anônimas ..........................52Classes Wrapper ........................................................... 54Enumerações (Java 5 ou +) ........................................... 56Genéricos (Java 5 ou +) ................................................. 57

Parte III: API Java .................................................................. 63Introdução ................................................................... 63Usando a Documentação do JDK .................................. 64

Pacote java.lang ..................................................................... 65Interfaces de java.lang ................................................... 65Classes de java.lang ....................................................... 66Enumerações de java.lang ............................................. 87Exceções de java.lang .................................................... 87Erros de java.lang ......................................................... 88

Pacote java.util ...................................................................... 90Interfaces de java.util .................................................... 90Classes de java.util ........................................................ 96Enumerações de java.util .............................................120Exceções de java.util .................................................... 121Erros de java.util.......................................................... 121

Pacote java.io .......................................................................122Interfaces de java.io ......................................................122Classes de java.io .........................................................125Exceções de java.io ......................................................140Erros de java.io ............................................................140

Índice remissivo ................................................................... 141

�

Parte I: Elementos fundamentais

Java: uma brevíssima apresentaçãoCriado 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 Novas características da linguagem Java

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.

Ambiente JavaJava é 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çãoO 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 isoladoimport 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 � – Compilação e execução.

VariáveisA 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

Tipo Descrição Tam. Intervalobyte inteiros positivos e negativos 1 -128 a +127short inteiros positivos e negativos 2 -32.768 a +32.767

int inteiros positivos e negativos 4 -2.147.483.648 a +2.147.483.647

long inteiros positivos e negativos 8 -2^64 a +2^64 – 1

float valores em ponto flutuante 4positivos: +1,4013E-45 a +3.4028E+38 negativos: -3.4028E+38 a -1.4013E-45

double valores em ponto flutuante 8positivos: +4,9407E-324 a +1.7977E+308 negativos: -1.7977E+308 a -4.9407E-324

char caracteres individuais 2 De \u0000 a \uFFFFboolean tipo lógico 1 false ou true

� 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 � – Sufixos ou prefixos predefinidos

Tipo Sufixo Prefixo Exemplolong L 1234567890L

float f 0.345f

octal 0 053

hexadecimal 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

\’ Apóstrofe.\” Aspas duplas.\\ Barra invertida.\f Nova página (form feed).\b Retrocesso (backspace).\u143F Caractere UNICODE 143F.\n Quebra de linha (newline ou linefeed).\fca Caractere hexadecimal FCA.\r Retorno de carro (carriage return).\g43 Caractere octal 43.\t 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 Classe da API que disponibiliza um objeto in.in Objeto que representa a entrada de dados do console.read 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 Classe da API que disponibiliza um objeto out.out Objeto que representa a saída para o console.println Método que imprime valores, mensagens e objetos.

11Entrada e saída básicas

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 linhaSystem.out.printf(“Guia Java 6%n”);// exibe mensagem e valor inteiroSystem.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õesOperadores 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 literaisint a = 2, b = 3;// variável iniciada com expressão válidadouble 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); // exibe 4System.out.println(c / d); // 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); // exibe 1System.out.println(c % d); // exibe 0

Operadores de incremento e decremento

Efetuam o incremento ou decremento de variáveis numéricas.

1�Operadores e expressões

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 � – Promoção automática de tipos

2º operando

B S I L F D

1o o

pera

ndo

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

1� Elementos fundamentais

Exemplo:

int i = 3; long l = 12; float f = 1.5f; double d = 2.25;// resultado é 10, mas do tipo doubledouble 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 é truncadaint x = (int) d;// resultado 2*3.47 é convertido para floatfloat 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

&& Elógico(and).|| Oulógico(or).! Negação(not).

1�Operadores e expressões

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 expr_true, senão é retornado o resultado de expr_false.

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 (a

0 com b

0, a

1 com b

1 e assim por diante).

• ~ só toma um operando e efetua seu complemento de 2.

• << e >> rotacionam os bits do 1º operando, à esquerda ou direita, 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[]) {