Java 6 - Guia de Consulta Rápida by Novatec Editora

Guia de Consulta Rรกpida

Java 6 Peter Jandl Jr.

Novatec Editora

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

Versão inicial.

1997

1.1

Classes internas.

1998

1.2

Declaração strictfp. Compilação JIT.

2000

1.3

Tecnologia HotSpot para JVM.

2002

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

long

inteiros positivos e negativos

float

valores em ponto flutuante

double

valores em ponto flutuante

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

1234567890L

float

0.345f

octal hexadecimal

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

double

else

enum

extends

false

final

finally

float

for

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’;

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

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;

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

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

B=byte, D=double, F=float, I=int, L=long, S=short

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

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[]) {