Dia 3

Fundamentos de Java

Laura Lemay

• Afirmações e expressões
• Variáveis e tipos de dados
  • Declaração de variáveis
  • Notas de nomes da variável
  • Tipos variáveis
  • Destinar valores a variáveis
• Comentários
• Literais
  • Literais de número
  • Literais booleanos
  • Literais de caráter
  • Literais de cadeia
• Expressões e operadores
  • Aritmética
  • Mais sobre nomeação
  • Incrementing e Decrementing
  • Comparações
  • Operadores lógicos
  • Operadores de Bitwise
  • Precedência de operador
• Aritmética de cadeia
• Sumário
• Perguntas e Respostas
  

Já nesta semana aprendeu sobre a programação de Java em termos muito largos - o que um programa Java e uma olhada executável como, e como criar classes simples. Para o resto desta semana, vai começar detalhes e tratar com a especificação da que a língua de Java parece.

Hoje não definirá nenhuma classe ou objetos ou vai se incomodar com como algum deles se comunica dentro de um programa Java. Melhor desenhará mais perto e examinará afirmações de Java simples - as coisas básicas que pode fazer em Java dentro de uma definição de método como main().

Hoje aprenderá sobre o seguinte:

• Afirmações de Java e expressões
• Variáveis e tipos de dados
• Comentários
• Literais
• Aritmética
• Comparações
• Operadores lógicos

Afirmações e expressões

Uma afirmação indica as tarefas mais simples que pode realizar em Java; uma afirmação forma uma operação de Java única. Todo o seguinte é afirmações de Java simples:

int i = 1;
import java.awt.Font;
System.out.println("This motorcycle is a "
    + color + " " + make);
m.engineState = true;

As afirmações às vezes valores de retorno por exemplo, quando acrescenta dois números em conjunto ou teste para ver se um valor é igual ao outro. Estes a espécie de afirmações chamam-se expressões. Aprenderá sobre estes depois hoje.

O espaço branco em afirmações de Java, como com C, é sem importância. Uma afirmação pode conter-se em uma linha única ou em múltiplas linhas, e o compilador de Java será capaz de lê-la somente perfeito. A coisa mais importante a lembrar-se sobre afirmações de Java consiste em que cada um termina em um ponto-e-vírgula (;). Esqueça o ponto-e-vírgula, e o seu programa Java não compilará.

Java também tem afirmações compostas ou blocos, que podem colocar-se onde quer que uma afirmação única possa. As afirmações de bloco rodeiam-se de tiras ({}). Aprenderá mais sobre blocos no Dia 5, "Tabelas, Condicionais e Laços".

Variáveis e tipos de dados

As variáveis são posições na memória na qual os valores podem guardar-se. Cada um tem um nome, um tipo e um valor. Antes que possa usar uma variável, tem de declará-lo. Depois que se declara, então pode destinar-lhe valores (também pode declarar e destinar um valor a uma variável ao mesmo tempo, como aprenderá nesta seção).

Java de fato tem três espécies de variáveis: variáveis de exemplo, variáveis de classe e variáveis locais.

As variáveis de exemplo, como aprendeu ontem, usam-se para definir os atributos de um determinado objeto. As variáveis de classe são semelhantes a variáveis de exemplo, exceto os seus valores aplicam a exemplos de toda aquela classe (e à própria classe) em vez de ter valores diferentes de cada objeto.

As variáveis locais declaram-se e usaram definições de método interiores, por exemplo, para balcões de índice em laços, como variáveis temporárias, ou manter valores de que só precisa dentro da própria definição de método. Também podem usar-se dentro de blocos, sobre os quais aprenderá no Dia 5. Uma vez que o método (ou bloco) termina de realizar, a definição variável e o seu valor deixam de existir. Use variáveis locais para guardar a informação necessária por um método único e variáveis de exemplo para guardar a informação necessária por múltiplos métodos no objeto.

Embora as três espécies de variáveis se declarem de modos quase os mesmos, a classe e as variáveis de exemplo acessam-se e destinam-se de modos ligeiramente diferentes de variáveis locais. Hoje vai se concentrar em variáveis como usado dentro de definições de método; amanhã aprenderá como tratar com exemplo e variáveis de classe.

Declaração de variáveis

Para usar qualquer variável em um programa Java, deve declará-lo primeiro. As declarações variáveis compõem-se de um tipo e um nome da variável:

int myAge;
String myName;
boolean isTired;

As definições variáveis podem ir em qualquer lugar em uma definição de método (isto é, em qualquer lugar uma afirmação de Java regular pode ir), embora se declarem o mais comumente no início da definição antes que se usem:

public static void main (String args[]) {
    int count;
    String title;
    boolean isAsleep;
...
}

Pode esticar em conjunto nomes da variável com o mesmo tipo em uma linha:

int x, y, z;
String firstName, LastName;

Também pode dar a cada variável um valor inicial quando o declara:

int myAge, mySize, numShoes = 28;
String myName = "Laura";
boolean isTired = true;
int a = 4, b = 5, c = 6;

Se houver múltiplas variáveis na mesma linha com só um initializer (como no primeiro dos exemplos prévios), o valor inicial só aplica à variável última em uma declaração. Também pode agrupar variáveis individuais e initializers na mesma linha usando vírgulas, que com o exemplo último.

As variáveis locais devem dar-se valores antes que possam usar-se (o seu programa Java não compilará se tentar usar uma variável local não destinada). Por essa razão, é uma boa ideia sempre para dar a variáveis locais valores iniciais. O exemplo e as definições de variável de classe não têm esta restrição. (O seu valor inicial depende do tipo da variável: null de exemplos de classes, 0 de variáveis numéricas, '\0' de carateres e false de booleans.)

Notas de nomes da variável

Os nomes da variável em Java podem começar com uma carta, um sublinhar (_) ou sinal de dólar ($). Não podem começar com um número. Depois do primeiro caráter, os seus nomes da variável podem incluir qualquer carta ou número. Os símbolos, como %, *, @, e assim por diante, muitas vezes reservam-se para operadores em Java, assim ter cuidado usando símbolos em nomes da variável.

Além disso, a língua de Java usa o conjunto de caracteres de Unicode. Unicode é uma definição de conjunto de caracteres que não só oferece carateres no conjunto de caracteres de ASCII padrão, mas também inclui vários miles outros carateres para representar a maior parte de alfabetos internacionais. Isto significa que pode usar carateres acentuados e outro glyphs como carateres legais em nomes da variável, enquanto têm um número de caráter de Unicode acima de 00C0.

Finalmente, observe que a língua de Java é caso sensível, que significa que as maiúsculas são diferentes de cartas em letras minúsculas. Isto significa que o X variável é diferente do x variável, e um rose não é um Rose não é um ROSE. Lembre-se disto como escreve os seus próprios programas Java e como lê Java codificam outras pessoas escreveram.

Pela convenção, as variáveis de Java têm nomes significativos, muitas vezes compostos de várias palavras combinadas. A primeira palavra é letra minúscula, mas todo depois de palavras tem uma maiúscula inicial:

Button theButton;
long reallyBigNumber;
boolean currentWeatherStateOfPlanetXShortVersion;

Tipos variáveis

Além do nome da variável, cada declaração variável deve ter um tipo, que define o que valoriza aquela variável pode manter-se. O tipo variável pode ser uma de três coisas:

• Um de oito tipos de dados primitivos
• O nome de uma classe ou interface
• Uma tabela

Aprenderá sobre como declarar e usar variáveis de tabela no Dia 5; esta lição concentra-se nos tipos primitivos e tipos de classe.

Tipos primitivos

Oito tipos de dados primitivos tratam tipos comuns de números inteiros, números de ponto flutuante, carateres e valores booleanos (true ou false). Chamam-nos primitivos porque se incorporam no sistema e não são objetos reais, que os faz mais eficientes para usar. Observe que estes tipos de dados são independentes da máquina, que significa que pode confiar nos seus tamanhos e características para ser consistente através dos seus programas Java.

Há quatro tipos de número inteiro de Java, cada um com uma variedade diferente de valores (como enumerado na Tabela 3.1). Todos assinam-se, que significa que podem manter números negativos ou positivos. Que o datilografam selecionam para as suas variáveis depende da variedade de valores que espera que aquela variável mantenha; se um valor ficar demasiado grande para o tipo variável, é silenciosamente truncado.

Os números de ponto flutuante usam-se para números com uma parte decimal. Os números de ponto flutuante de Java são complacentes com IEEE 754 (um padrão internacional para definir números de ponto flutuante e aritmética). Há dois tipos de ponto flutuante: float (32 bits, precisão única) and double (64 bits, precisão dupla).

O tipo de char usa-se para carateres individuais. Como Java usa o conjunto de caracteres de Unicode, o tipo de char tem 16 bits da precisão, não assinada.

Finalmente, o tipo booleano pode ter um de dois valores, true ou false. Observe que diferentemente de em outro parecido às linguagem C, boolean não é um número, nem pode tratar-se como um. Todos os testes de variáveis booleanas devem testar para true ou false.

Observe que todos os tipos primitivos estão na letra minúscula. Tenha cuidado quando os usa nos seus programas que realmente usa a letra minúscula, porque também há as classes com os mesmos nomes (e uma carta de capital inicial) que têm o comportamento assim diferente, por exemplo, o tipo primitivo boolean é diferente da classe de Boolean. Aprenderá mais sobre estas classes especiais e para que se usam no Dia 4, "Trabalhando com Objetos".

Tipos de classe

Além de oito tipos de dados primitivos, também pode declarar-se que as variáveis em Java mantenham um exemplo de uma determinada classe:

String LastName;
Font basicFont;
OvalShape myOval;

Cada uma destas variáveis pode manter exemplos da classe denominada ou de alguma das suas subclasses. O último é útil quando quer que uma variável seja capaz de manter exemplos diferentes de classes relacionadas. Por exemplo, digamos tinha o grupo de classes-Apple de fruto, Pear, Strawberry, e assim por diante todo de que herdado da classe geral Fruit. Declarando uma variável do tipo Fruit, aquela variável então pode manter exemplos de alguma das classes de Fruit. Declarar uma variável do tipo Object significa que a variável pode manter qualquer objeto.

Destinar valores a variáveis

Uma vez que uma variável declarou-se, pode destinar um valor àquela variável usando o operador = de nomeação, como isto:

size = 14;
tooMuchCaffiene = true;

Comentários

Java tem três espécies de comentários: dois para comentários regulares em texto fonte e um para o sistema de documentação especial javadoc.

Os símbolos /* e */ rodeiam comentários com múltiplas linhas, como em C ou C ++. Todo o texto entre os dois delimiters ignora-se:

/* I don't know how I wrote this next part; I was working
    really late one night and it just sort of appeared. I
    suspect the code elves did it for me. It might be wise
    not to try and change it.
*/

Estes comentários não podem aninhar-se; isto é, não pode ter um comentário dentro de um comentário.

Os golpes duplos (//) podem usar-se para uma linha única do comentário. Todo o texto até o fim da linha ignora-se:

int vices = 7; // are there really only 7 vices?

O tipo final do comentário começa com /** e termina em */. Os conteúdos destes comentários especiais usam-se pelo sistema de javadoc, mas acostumam-se de outra maneira identicamente ao primeiro tipo do comentário. javadoc usa-se para gerar a documentação API do código. Aprenderá mais sobre javadoc no Dia 22, "Instrumentos de Programação de Java".

Literais

Literal é um termo de linguagem de programação que essencialmente significa que o que datilografa é o que adquire. Por exemplo, se datilografa 4 em um programa Java, automaticamente adquire um número inteiro com o valor 4. Se datilografar 'a', adquire um caráter com o valor a. Os literais usam-se para indicar valores simples nos seus programas Java.

Os literais podem parecer intuitivos a maior parte do tempo, mas há alguns casos especiais de literais em Java de tipos diferentes de números, carateres, cadeias e valores booleanos.

Literais de número

Há vários literais de número inteiro. 4, por exemplo, é um número inteiro decimal literal do tipo int (embora possa destiná-lo a uma variável do tipo byte ou short porque é bastante pequeno para ajustar-se naqueles tipos). Um número inteiro decimal literal maior do que um int é automaticamente do tipo long. Também pode forçar um mais pequeno número para um long acrescentando um L ou l àquele número (por exemplo, 4L é um número inteiro de long do valor 4). Os números inteiros negativos precedem-se por um menos assinam do exemplo, -45.

Os números inteiros também podem exprimir-se como octais ou hexadecimais: Um 0 principal indica que um número é octal por exemplo, 0777 ou 0004. Um 0x principal (ou 0X) significa que está na bruxa (0xFF, 0XAf45). Os números hexadecimais podem conter os dígitos (0-9) regulares ou superior - ou dígitos de bruxa em letras minúsculos (a-f ou A-F).

Os literais de ponto flutuante normalmente têm duas partes, a parte de número inteiro e a parte por exemplo decimal, 5.77777. Um ponto flutuante resultados literais em um número de ponto flutuante de tipo double, apesar da precisão do número. Pode forçar o número para o tipo float acrescentando a carta f (ou F) àquele número por exemplo, 2.56F.

Pode usar representantes em literais de ponto flutuante usando a carta e ou E seguido do representante (que pode ser um número negativo): 10e45 ou .36E-2.

Literais booleanos

Os literais booleanos compõem-se das palavras-chave true e false. Estas palavras-chave podem usar-se em qualquer lugar precisa de um teste ou como os únicos valores possíveis de variáveis booleanas.

Literais de caráter

Os literais de caráter exprimem-se por um caráter único rodeado de citações únicas: 'a', '#', '3', e assim por diante. Os carateres guardam-se como carateres de Unicode de 16 bits. A tabela 3.2 enumera os códigos especiais que podem representar carateres não-prontos para impressão, bem como carateres do conjunto de caracteres de Unicode. A carta d no octal, bruxa e fugas de Unicode representa um número ou um dígito hexadecimal (a-f ou A-F).

Literais de cadeia

Uma combinação de carateres é uma cadeia. As cadeias em Java são os exemplos da classe String. As cadeias não são simplesmente as tabelas dos carateres como estão em C ou C ++, embora realmente tenham muitas características parecidas a uma tabela (por exemplo, pode testar o seu comprimento e acesso e modificar carateres individuais). Como os objetos de cadeia são verdadeiros objetos em Java, têm métodos que lhe permitem combinar, testar e modificar cadeias muito facilmente.

Os literais de cadeia compõem-se de uma série de carateres dentro de citações duplas:

"Hi, I'm a string literal."
"" //an empty string

As cadeias podem conter constantes de caráter como newline, etiqueta e carateres de Unicode:

"A string with a \t tab in it"
"Nested strings are \"strings inside of\" other strings"
"This string brought to you by Java\u2122"

No exemplo último, a sequência de código de Unicode de \u2122 produz um símbolo de marca de comércio ( ).

Quando usa uma cadeia literal no seu programa Java, Java automaticamente cria um exemplo da classe String para você com o valor que lhe dá. As cadeias são excepcionais neste aspecto; outros literais não se comportam deste modo (nenhum dos tipos de dados primitivos é objetos reais), e normalmente a criação de um novo objeto implica explicitamente a criação de um novo exemplo de uma classe. Aprenderá mais sobre cadeias, a classe de String e as coisas que pode fazer com cadeias depois hoje e amanhã.

Expressões e operadores

As expressões são a forma mais simples da afirmação em Java que de fato realiza algo: Todas as expressões, quando avaliado, devolvem um valor (outras afirmações não necessariamente fazem assim). A aritmética e os testes de igualdade e magnitude são exemplos comuns de expressões. Como devolvem um valor, pode destinar aquele resultado a uma variável ou teste que valorizam em outras afirmações de Java.

A maioria das expressões em Java usam operadores. Os operadores são símbolos especiais de coisas como aritmética, várias formas de nomeação, incremento e decremento e operações lógicas.

Aritmética

Java tem cinco operadores da aritmética básica (ver a Tabela 3.3).

Cada operador toma dois operands, um de ambos os lados do operador. O operador de subtração (-) também pode usar-se para negar um operand único.

A divisão de número inteiro resulta em um número inteiro. Como os números inteiros não têm frações decimais, qualquer resto ignora-se. O 31 / 9 de expressão, por exemplo, resulta em 3 (9 entra 31 só 3 vezes).

O módulo (%) dá o resto uma vez que os operands se dividiram exatamente. Por exemplo, 31 % 9 resulta em 4 porque 9 entra 31 três vezes, com 4 deixados.

Observe que o tipo de resultado da maior parte de operações aritméticas que implicam números inteiros é um int apesar do tipo original do operands (short s e byte os s convertem-se ambos automaticamente em int). Se ou ambos operands for do tipo long, o resultado é do tipo long. Se um operand for um número inteiro e o outro é um número de ponto flutuante, o resultado é um ponto flutuante. (Se se interessar nos detalhes de como Java promove e converte tipos numéricos de um tipo ao outro, pode querer verificar a Especificação de Língua de Java no Web site de Java oficial de Sol em http://java.sun.com/; isto é mais detalhe do que quero cobrir aqui.)

A listagem 3.1 é um exemplo da aritmética simples em Java.

A listagem 3.1. Aritmética simples.

 1: class ArithmeticTest {
 2: public static void main (String args[]) {
 3:     short x = 6;
 4:     int y = 4;
 5:     float a = 12.5f;
 6:     float b = 7f;
 7:
 8:     System.out.println("x is " + x + ", y is " + y);
 9:     System.out.println("x + y = " + (x + y));
10:     System.out.println("x - y = " + (x - y));
11:     System.out.println("x / y = " + (x / y));
12:     System.out.println("x % y = " + (x % y));
13:
14:     System.out.println("a is " + a + ", b is " + b);
15:     System.out.println("a / b = " + (a / b));
16: }
17: }

x is 6, y is 4
x + y = 10
x - y = 2
x / y = 1
x % y = 2
a is 12.5, b is 7
a / b = 1.78571

O resto do programa simplesmente faz alguma matemática com números inteiros e números de ponto flutuante e imprime os resultados.

Há uma outra coisa a mencionar sobre este programa: o método System.out.println(). Viu este método em prévios dias, mas realmente não aprendeu exatamente o que faz. O método de System.out.println() simplesmente imprime uma mensagem para a produção padrão do seu sistema - à tela, a uma janela especial, ou talvez somente a um arquivo de log especial, dependendo do seu sistema e o ambiente de desenvolvimento que dirige. O método de System.out.println() toma uma cadeia de argumento-a única - mas pode usar + para concatenar múltiplos valores em uma cadeia única, como aprenderá depois hoje.

Mais sobre nomeação

A nomeação variável é uma forma da expressão; de fato, porque uma expressão de nomeação resulta em um valor, pode esticá-los em conjunto como isto:

x = y = z = 0;

Neste exemplo, as três variáveis agora têm o valor 0.

O lado direito de uma expressão de nomeação sempre se avalia antes que a nomeação se realize. Isto significa que as expressões como x = x + 2 fazem a coisa direita; 2 acrescenta-se ao valor de x, e logo que o novo valor se redestina a x. De fato, este tipo da operação é tanto comum que Java tem vários operadores para fazer uma versão de estenografia disto, emprestado de C e C ++. A tabela 3.4 mostra a estes operadores de nomeação de estenografia.

Incrementing e Decrementing

Como em C e C ++, os operadores ++ e -- usam-se para incrementar ou decremento o valor de uma variável por 1. Por exemplo, x++ incrementa o valor de x por 1 exatamente como se tinha usado a expressão x = x + 1. De mesmo modo decrementos de x-- o valor de x por 1. (Diferentemente de C e C ++, Java permite a x ser ponto flutuante.)

Estes incrementam e os operadores de decremento podem prefixar-se ou posfixar-se; isto é, o ++ ou -- podem aparecer antes ou depois do valor incrementa ou decrementos. Para incremento simples ou expressões de decremento, que usa não é demais importante. Em nomeações complexas, onde destina o resultado de um incremento ou expressão de decremento, que usa faz uma diferença.

Tome, por exemplo, duas seguintes expressões:

y = x++;
y = ++x;

Estas duas expressões produzem resultados muito diferentes por causa da diferença entre prefixo e posembaraço. Quando usa operadores de posembaraço (x++ ou x--), y adquire o valor de x antes que x se modifique; usando o prefixo, o valor de x destina-se a y depois que a modificação ocorreu. A listagem 3.2 é um exemplo de Java de como tudo isso trabalha.

A listagem 3.2. O teste de prefixo e posembaraço incrementa operadores.

 1: class PrePostFixTest {
 2:
 3: public static void main (String args[]) {
 4:     int x = 0;
 5:     int y = 0;
 6:
 7:     System.out.println("x and y are " + x + " and " + y );
 8:     x++;
 9:     System.out.println("x++ results in " + x);
10:     ++x;
11:     System.out.println("++x results in " + x);
12:     System.out.println("Resetting x back to 0.");
13:     x = 0;
14:     System.out.println("------------");
15:     y = x++;
16:     System.out.println("y = x++ (postfix) results in:");
17:     System.out.println("x is " + x);
18:     System.out.println("y is " + y);
19:     System.out.println("------------");
20:
21:     y = ++x;
22:     System.out.println("y = ++x (prefix) results in:");
23:     System.out.println("x is " + x);
24:     System.out.println("y is " + y);
25:     System.out.println("------------");
26:
27: }
28: }

x and y are 0 and 0
x++ results in 1
++x results in 2
Resetting x back to 0.
------------
y = x++ (postfix) results in:
x is 1
y is 0
------------
y = ++x (prefix) results in:
x is 2
y is 2
------------

Na primeira parte deste exemplo, incrementa x sozinho usar tanto prefix como postfix incrementam operadores. Em cada um, x incrementa-se por 1 cada vez. Nesta forma simples, usando prefix ou postfix trabalha o mesmo caminho.

Na segunda parte deste exemplo, usa a expressão y = x++, no qual o operador de incremento de postfix se usa. Neste resultado, o valor de x incrementa-se depois que aquele valor destina-se a y. Daqui o resultado: y destina-se o valor original de x (0), e logo x incrementa-se por 1.

Na terceira parte, usa a expressão de prefix y = ++x. Aqui, o reverso ocorre: x incrementa-se antes que o seu valor se destine a y. Como x é 1 do passo prévio, o seu valor incrementa-se (a 2), e logo que o valor se destina a y. Tanto x como y terminam de ser 2.

Comparações

Java tem várias expressões para testar a igualdade e a magnitude. Todas destas expressões devolvem um valor booleano (isto é, true ou false). A tabela 3.5 mostra aos operadores de comparação.

Operadores lógicos

As expressões que resultam em valores booleanos (por exemplo, os operadores de comparação) podem combinar-se usando operadores lógicos que representam as combinações lógicas AND, OR, XOR e NOT lógico.

Para combinações de AND, use qualquer os operadores & ou &&. A expressão inteira só será verdade se ambas as expressões de ambos os lados do operador também forem verdade; se qualquer expressão for falsa, a expressão inteira é falsa. A diferença entre os dois operadores está na avaliação de expressão. Usando &, ambos os lados da expressão avaliam-se apesar do resultado. Usando &&, se o lado abandonado da expressão for falso, supõe-se que a expressão inteira seja falsa (o valor do lado direito não importa), portanto a expressão devolve false, e o lado direito da expressão nunca se avalia. (Isto muitas vezes chama-se uma expressão "posta em curto-circuito".)

Para expressões de OR, use | ou ||. as expressões de OR resultam no verdadeiro se ou ambas das expressões de ambos os lados também for verdade; se amba a expressão operands for falsa, a expressão é falsa. Como com & e &&, o | único avalia ambos os lados da expressão apesar do resultado; e || põe-se em curto-circuito: Se a expressão esquerda for verdade, a expressão devolve true e o lado direito nunca se avalia.

Além disso, há operador XOR ^, que devolve true só se os seus operands forem diferentes (um verdadeiro e um falso, ou vice-versa) e false de outra maneira (mesmo se ambos forem verdade).

Em geral, só o && e || se usam comumente como combinações lógicas reais. &, | e ^ usam-se mais comumente para operações lógicas bitwise.

Para NOT, use o operador ! com um argumento de expressão único. O valor da expressão de NOT é a negação da expressão; se x for verdade, !x é falso.

Operadores de Bitwise

Finalmente, aqui está um sumário curto dos operadores bitwise em Java. A maioria destas expressões herdam-se de C e C ++ e usam-se para executar operações em bits individuais em números inteiros. Este livro não entra em operações bitwise; é um tópico promovido coberto melhor em livros sobre C ou C ++. A tabela 3.6 resume os operadores bitwise.

Precedência de operador

A precedência de operador determina a ordem na qual as expressões se avaliam. Isto, em alguns casos, pode determinar o valor total da expressão. Por exemplo, tome a seguinte expressão:

y = 6 + 4 / 2

Dependendo de se a expressão de 6 + 4 ou o 4 / 2 expressão se avaliam primeiro, o valor de y pode terminar de ser 5 ou 8. A precedência de operador determina a ordem na qual as expressões se avaliam, portanto pode predizer o resultado de uma expressão. Em geral, o incremento e o decremento avaliam-se antes da aritmética, as expressões aritméticas avaliam-se antes que as comparações e as comparações se avaliem antes de expressões lógicas. As expressões de nomeação avaliam-se últimas.

A tabela 3.7 mostra a precedência específica de vários operadores em Java. Os operadores além disso na mesa avaliam-se primeiro; os operadores na mesma linha têm a mesma precedência e avaliam-se da esquerda à direita baseados em como aparecem na própria expressão. Por exemplo, dado que a mesma expressão y = 6 + 4 / 2, agora sabe, segundo esta mesa, que a divisão se avalia antes da adição, portanto o valor de y será 8.

Sempre pode modificar a ordem na qual as expressões se avaliam usando parênteses em volta das expressões que quer avaliar primeiro. Pode aninhar parênteses para assegurar-se que as expressões avaliam na ordem quê-los a (a expressão parentética íntima avalia-se primeiro). A seguinte expressão resulta em um valor de 5, porque a expressão de 6 + 4 se avalia primeiro, e logo o resultado daquela expressão (10) divide-se por 2:

y = (6 + 4) / 2

Os parênteses também podem ser úteis em casos onde a precedência de uma expressão não é imediatamente clara em outras palavras, podem fazer o seu código mais fácil ler. A soma de parênteses não dói, portanto se o ajudarem a compreender como as expressões se avaliam, progridem e os usam.

Aritmética de cadeia

Uma expressão especial em Java é o uso do operador de adição (+) para criar e concatenar cadeias. Na maioria dos exemplos mostrados hoje e em lições mais adiantadas, viu muitas linhas que olharam algo como isto:

System.out.println(name + " is a " + color + " beetle");

A produção daquela linha (à produção padrão) é uma cadeia única, com os valores das variáveis (name e color), inserido nos lugares apropriados na cadeia. Então o que está acontecendo aqui?

O operador +, quando usado com cadeias e outros objetos, cria uma cadeia única que contém a concatenação de todo o seu operands. Se algum dos operands na concatenação de cadeia não for uma cadeia, converte-se automaticamente em uma cadeia, alívio para criar estes tipos de linhas de produção.

A concatenação de cadeia faz linhas como a prévia especialmente fáceis construir. Para criar uma cadeia, somente acrescente todas as partes em conjunto - descrições mais as variáveis - e imprima-a para a produção padrão, para a tela, a um applet, ou em qualquer lugar.

O operador +=, sobre o qual aprendeu antes, também trabalha para cadeias. Por exemplo, tome a seguinte expressão:

myName += " Jr.";

Esta expressão é equivalente a isto:

myName = myName + " Jr.";

tão como seria para números. Neste caso, modifica o valor de myName, que poderia ser algo como John Smith para ter um Jr. no fim (John Smith Jr.).

Sumário

Como aprendeu em duas lições últimas, um programa Java compõe-se principalmente de classes e objetos. As classes e os objetos, à sua vez, compõem-se de métodos e variáveis, e os métodos compõem-se de afirmações e expressões. São aquelas duas coisas últimas sobre que aprendeu hoje; os blocos de edifício básicos que lhe permitem criar classes e métodos e construi-los até um programa Java crescido.

Hoje, aprendeu sobre variáveis, como declará-los e destinar-lhes valores; literais para criar facilmente números, carateres e cadeias; e operadores de aritmética, testes e outras operações simples. Com esta sintaxe básica, pode mudar amanhã à aprendizagem sobre trabalho com objetos e criação de programas Java simples, úteis.

Para terminar este sumário, a Tabela 3.8 é uma lista de todos os operadores sobre os quais aprendeu hoje para que possa referir-se atrás a eles.

Perguntas e Respostas