41bb726c

Dia 3

Fundamentos de Java

Laura Lemay


CONTEÚDOS

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:

Nota técnica
Java olha muito como C ++, e - por C parecido à extensão. A maior parte da sintaxe será muito familiar para você se estiver acostumado a trabalhar nestas línguas. Se for um C experimentado ou C ++ programador, pode querer prestar a atenção especial às notas técnicas (como este), porque fornecem a informação sobre as diferenças específicas entre estas e outras línguas tradicionais e Java.

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.

Observar
Diferentemente de outras línguas, Java não tem variáveis globais - isto é, variáveis que são globais a todas as partes de um programa. O exemplo e as variáveis de classe podem usar-se para comunicar a informação global entre e entre objetos. Lembre-se de que Java é uma língua orientada ao objeto, portanto deve pensar quanto a objetos e como interagem, em vez de quanto a programas.

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.

Aviso
A especificação Unicode é um jogo de dois volumes de listas de milhares de carateres. Se não entender Unicode ou não pensar que tem um uso para ele, está o mais seguro somente usar números claros e cartas nos seus nomes da variável. Aprenderá um pouco mais sobre Unicode depois.

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:

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.

A tabela 3.1. Tipos de número inteiro.

Datilografar
Tamanho
Variedade
byte
8 bits
- 128 a 127
short
16 bits
- 32,768 a 32.767
int
32 bits
- 2,147,483,648 para 2.147.483.647
long
64 bits
- 9,223,372,036,854,775,808 a 9,223,372,036,854,775,807

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.

Nota técnica
Java não tem uma afirmação de typedef (como em C e C ++). Para declarar novos tipos em Java, declara uma nova classe; então pode declarar-se que as variáveis sejam do tipo daquela classe.

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.

Novo termo
Um literal é um valor simples onde "o que datilografa é o que adquire". Os números, os carateres e as cadeias são todos os exemplos de literais.

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

A tabela 3.2. Códigos de fuga de caráter.

Fuga
Significação
\n
Newline
\t
Etiqueta
\b
Tecla de retrocesso
\r
Retorno de carro
\f
Formfeed
\\
Barra oblíqua invertida
\'
Citação única
\"
Citação dupla
\ddd
Octal
\xdd
Hexadecimal
\udddd
Caráter de Unicode

Nota técnica
C e C ++ os programadores devem observar que Java não inclui códigos de caráter de \a (sino) ou \v (etiqueta vertical).

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 ( ).

Observar
Somente porque pode representar um caráter usando uma fuga de Unicode não significa que o seu computador pode expor aquele caráter - o sistema de computador ou sistema operacional que dirige pode não apoiar Unicode, ou a fonte que usa pode não ter um glyph (quadro) daquele caráter. Todo o que as fugas de Unicode em Java fornecem é um modo de codificar carateres de Unicode de sistemas aquele suporte Unicode.
Java 1.1 fornecerá melhores capacidades para a exposição de carateres de Unicode e para tratar conjuntos de caracteres internacionais.

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.

Novo termo
As expressões são afirmações que devolvem um valor.

Novo termo
Os operadores são símbolos especiais que se usam comumente em expressões.

Aritmética

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

A tabela 3.3. Operadores aritméticos.

Operador
Significação
Exemplo
+
Adição
3 + 4
-
Subtração
5 - 7
*
Multiplicação
5 * 5
/
Divisão
14 / 7
%
Módulo
20 % 7

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

Análise
Nesta aplicação de Java simples (observam o método de main()), inicialmente define quatro variáveis em linhas 3 para 6: x e y, que são números inteiros (datilografam int), e a e b, que são números de ponto flutuante (datilografam float). Tenha em mente que o tipo à revelia de literais de ponto flutuante (como 12.5) é double, assim para assegurar-se que estes são os números do tipo float, tem de usar um f depois de cada um (linhas 5 e 6).

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.

A tabela 3.4. Operadores de nomeação.

Expressão
Significação
x += y
x = x + y
x -= y
x = x - y
x *= y
x = x * y
x /= y
x = x / y

Nota técnica
Tecnicamente, a nomeação de estenografia e as expressões escritas à mão não são exatamente equivalentes, em particular em casos onde x ou y podem ser expressões complicadas e o seu código confia em efeitos de lado daquelas expressões. Na maior parte de exemplos, contudo, são funcionalmente equivalentes. Para mais informação sobre expressões muito complicadas, ordem de avaliação e efeitos de lado, pode querer consultar a Especificação de Língua de Java.

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.

Nota técnica
Tecnicamente, esta descrição não é inteiramente correta. Na verdade, Java sempre completamente avalia todas as expressões à direita de uma expressão antes de destinar aquele valor a uma variável, portanto o conceito de "destinar x a y antes x se incrementa" não é precisamente direito. Em vez disso, Java toma o valor de x e "lembra-se" dele, avalia (incrementa) x, e logo destina o valor original de x a y. Embora nos casos mais simples esta distinção possa não ser importante, para expressões mais complexas com efeitos de lado, pode modificar o comportamento da expressão em geral. Ver a Especificação de Língua de muitos outros detalhes sobre a avaliação de expressão em Java.

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.

A tabela 3.5. Operadores de comparação.

Operador
Significação
Exemplo
==
Igual
x = = 3
!=
Não igual
x != 3
<
Menos do que
x < 3
>
Maior do que
x > 3
<=
Menos do que ou igual a
x <= 3
>=
Maior do que ou igual a
x >= 3

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.

A tabela 3.6. Operadores de Bitwise.

Operador
Significação
&
Bitwise AND
|
Bitwise OR
^
Bitwise XOR
<<
Turno esquerdo
>>
Turno direito
>>>
O zero enche o turno direito
~
Complemento de Bitwise
<<=
Nomeação de turno esquerda (x = x << y)
>>=
Nomeação de turno direita (x = x >> y)
>>>=
O zero enche a nomeação de turno direita (x = x >>> y)
x&=y
Nomeação de AND (x = x & y)
x|=y
Nomeação de OR (x = x | y)
x^=y
Nomeação de XOR (x = x ^ y)

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.

A tabela 3.7. Precedência de operador.

OperadorNotas
. [] () Os parênteses (()) acostumam-se a expressões de grupo; o ponto (.) usa-se para o acesso a métodos e variáveis dentro de objetos e classes (discutido amanhã); os suportes de forma triangular quadrados ([]) usam-se para tabelas (isto discute-se mais tarde na semana)
++ -- ! ~ instanceof O operador instanceof devolve true ou false baseado em se o objeto é um exemplo da classe denominada ou alguma de subclasses daquela classe (discutido amanhã)
Expressão de new (type) O operador new usa-se para criar novos exemplos de classes; () neste caso é para lançar um valor a outro tipo (aprenderá sobre ambos destes amanhã)
* / % Multiplicação, divisão, módulo
+ - Adição, subtração
<< >> >>> Bitwise turno esquerdo e direito
< > <= >= Testes de comparação relacionados
== != Igualdade
& AND
^ XOR
| OR
&& AND lógico
|| OR lógico
? : Estenografia de if...then...else (discutido em dia 5)
= += -= *= /= %= ^= Várias nomeações
&= |= <<= >>= >>>= Mais nomeações

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.

Nota técnica
Um objeto ou o tipo podem converter-se em uma cadeia se implementar o método toString(). Todos os objetos têm uma representação de cadeia à revelia, mas a maior parte de classes ignoram toString() para fornecer uma representação pronta para impressão mais significativa.

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.

A tabela 3.8. Sumário de operador.

Operador
Significação
+
Adição
-
Subtração
*
Multiplicação
/
Divisão
%
Módulo
<
Menos do que
>
Maior do que
<=
Menos do que ou igual a
>=
Maior do que ou igual a
==
Igual
!=
Não igual
&&
AND lógico
||
OR lógico
!
NOT lógico
&
AND
|
OR
^
XOR
<<
Turno esquerdo
>>
Turno direito
>>>
O zero enche o turno direito
~
Complemento
=
Nomeação
++
Incremento
----
Decremento
+=
Acrescente e destine
-=
Subtraia e destine
*=
Multiplique e destine
/=
Divida e destine
%=
O módulo e destina
&=
AND e destina
|=
OR e destina
<<=
O turno esquerdo e destina
^=
XOR e destina
>>=
O turno direito e destina
>>>=
O zero enche o turno direito e destina

Perguntas e Respostas

Q:
Não vi nenhum modo de definir constantes.
A:
Não pode criar constantes locais em Java; pode criar exemplo só constante e variáveis de classe. Aprenderá como fazer isto amanhã.
Q:
O que acontece se destinar um valor inteiro a uma variável que é demasiado grande para aquela variável para manter-se?
A:
Logicamente, pensaria que a variável somente se converte no seguinte tipo maior, mas isto não é o que acontece. O que realmente acontece chama-se o excesso. Isto significa que se um número ficar demasiado grande para a sua variável, que o número enrola em volta ao número negativo mais pequeno possível daquele tipo e começa a contar para cima em direção ao zero novamente.

Como isto pode resultar em alguns muito confusos (e mal) resultados, assegure-se que declara o tipo de número inteiro direito de todos os seus números. Se houver uma possibilidade um número inundará o seu tipo, usar o seguinte tipo maior em vez disso.

Q:
Como pode descobrir o tipo de uma variável dada?
A:
Se estiver usando algum dos tipos primitivos (int, float, boolean), e assim por diante, não pode. Se se preocupar com o tipo, pode converter o valor em algum outro tipo usando o arremesso. (Aprenderá sobre isto amanhã.)

Se estiver usando tipos de classe, pode usar o operador instanceof, sobre o qual aprenderá mais amanhã.

Q:
Porque Java tem todos estes operadores de estenografia de aritmética e nomeação? É realmente difícil ler aquele caminho.
A:
A sintaxe de Java é baseada em C ++, e por isso em C. Uma de metas implícitas de C é a capacidade de fazer coisas muito potentes com um mínimo da datilografia. Por causa disto, os operadores de estenografia, como a larga tabela de nomeações, são comuns.

Não há regra que diz que tem de usar estes operadores nos seus próprios programas, de qualquer modo. Se encontrar que o seu código é a utilização mais legível da forma larga, ninguém virá à sua casa e o fará modificá-la.

Q:
Cobriu a matemática simples nesta utilização de seção operadores. Estou supondo que Java tenha modos de fazer operações matemáticas mais complexas?
A:
Assume corretamente. Uma classe especial no pacote de java.lang, chamado java.lang.Math, tem um número de métodos de, e outras operações matemáticas básicas exponenciais, trigonométricas. De fato, porque chama estes métodos usando a própria classe de Math, estes são exemplos principais de métodos de classe. Aprenderá mais sobre isto amanhã.