Laura Lemay
Este apêndice contém uma referência sumária ou rápida da língua de Java, como descrito neste livro.
| Nota técnica |
Isto não é um resumo de gramática, nem é um resumo técnico da própria língua. É uma referência rápida a usar-se depois que já sabe os fundamentos de como a língua trabalha. Se precisar de uma descrição técnica da língua, a sua aposta melhor deve visitar o Web site de Java (http://java.sun.com) e carregar da especificação real, que inclui uma gramática BNF cheia. |
As palavras-chave de língua e os símbolos mostram-se em uma fonte monoespacial. Os argumentos e outras partes a substituir-se estão no monoespaço itálico.
As partes opcionais indicam-se por suportes de forma triangular (exceto na seção de sintaxe de tabela). Se houver várias opções que são mutuamente exclusivas, mostram-se separados por tubos ([|]) como isto:
[ public | private | protected ] type varname
As seguintes palavras reservam-se para o uso pela própria língua de Java (alguns deles reservam-se mas não atualmente usam-se). Não pode usar estas palavras para referir-se a classes, métodos ou nomes da variável:
| abstract | bóia | público |
| boolean | para | devolver |
| break | goto | curto |
| byte | se | estático |
| case | instrumentos | super |
| catch | importação | comutador |
| char | instanceof | sincronizar |
| class | número interno | isto |
| const | interface | lançamento |
| continue | muito tempo | lançamentos |
| do | natural | processo transitório |
| double | novo | tentar |
| else | nulo | vazio |
| extends | packa | volatilege |
| final | privado | enquanto |
| finally | protegido |
/* this is a multiline comment */ // this is a single-line comment /** Javadoc comment */
| number | Datilografe número interno |
| number[l | L] | Datilografe muito tempo |
| 0xhex | Número inteiro de bruxa |
| 0Xhex | Número inteiro de bruxa |
| 0octal | Número inteiro octal |
| [ number ].number | Datilografe duplo |
| number[ f | f] | Datilografe bóia |
| number[ d | D] | Datilografe duplo |
| [ + | - ] number | Assinado |
| numberenumber | Representante |
| numberEnumber | Representante |
| 'character' | Caráter único |
| "characters" | Cadeia |
| "" | Cadeia vazia |
| \b | Tecla de retrocesso |
| \t | Etiqueta |
| \n | Alimentos de linha |
| \f | Alimentos de forma |
| \r | Retorno de carro |
| \" | Citação dupla |
| \' | Citação única |
| \\ | Barra oblíqua invertida |
| \uNNNN | A fuga de Unicode (NNNN é bruxa) |
| true | Booleano |
| false | Booleano |
| [ byte | short | int | long ] varname | Os números inteiros (escolhem um tipo) |
| [ float | double ] varname | As bóias (escolhem um tipo) |
| char varname | Carateres |
| boolean varname | Booleano |
| classname varname | Tipos de classe |
| interfacename varname | Tipos de interface |
| type varname, varname, varname | Múltiplas variáveis |
As seguintes opções estão só disponíveis para variáveis de exemplo e classe. Alguma destas opções pode usar-se com uma declaração variável:
| [ static ] variableDeclaration | Variável de classe |
| [ final ] variableDeclaration | Constantes |
| [ public | private | protected ] variableDeclaration | Controle de acesso |
| [volatile] varname | Modificado assincronamente |
| [transient] varname | Não persistente (não ainda implementado) |
| variable = value | Nomeação |
| variable++ | Incremento de posembaraço |
| ++variable | Incremento de prefixo |
| variable-- | Decremento de posembaraço |
| --variable | Decremento de prefixo |
| variable += value | Acrescente e destine |
| variable -= value | Subtraia e destine |
| variable *= value | Multiplique e destine |
| variable /= value | Divida e destine |
| variable %= value | O módulo e destina |
| variable &= value | E e destinar |
| variable |= value | OU e destinar |
| variable ^= value | XOR e destinam |
| variable <<= value | O turno esquerdo e destina |
| variable >>= value | O turno direito e destina |
| variable >>>= value | O zero - enche o turno direito e destina |
| arg + arg | Adição |
| arg - arg | Subtração |
| arg * arg | Multiplicação |
| arg / arg | Divisão |
| arg % arg | Módulo |
| arg < arg | Menos do que |
| arg > arg | Maior do que |
| arg <= arg | Menos do que ou igual a |
| arg >= arg | Maior do que ou igual a |
| arg == arg | Igual |
| arg != arg | Não igual |
| arg && arg | Lógico E |
| arg || arg | Lógico OU |
| ! arg | Lógico NÃO |
| arg & arg | E |
| arg | arg | OU |
| arg ^ arg | XOR |
| arg << arg | Turno esquerdo |
| arg >> arg | Turno direito |
| arg >>> arg | Zero - enche turno direito |
| ~ arg | Complemento |
| (type)thing | Arremesso |
| arg instanceof class | Exemplo de |
| test ? trueOp : falseOp | Ternário (se) operador |
| new class() | Cria o novo exemplo |
| new class(arg,arg,arg...) | Novo exemplo com parâmetros |
| object.variable | Variável de exemplo |
| object.classvar | Variável de classe |
| Class.classvar | Variável de classe |
| object.method() | Método de exemplo (nenhum args) |
| object.method(arg,arg,arg...) | Método de exemplo |
| object.classmethod() | Método de classe (nenhum args) |
| object.classmethod(arg,arg,arg...) | Método de classe |
| Class.classmethod() | Método de classe (nenhum args) |
| Class.classmethod(arg,arg,arg...) | Método de classe |
| Observar |
Os suportes de forma triangular nesta seção são partes da criação de tabela ou afirmações de acesso. Não denotam partes opcionais como fazem em outras partes deste apêndice. |
| Type varname[] | Variável de tabela |
| type[] varname | Variável de tabela |
| new type[numElements] | Novo objeto de tabela |
| array[index] | Acesso a elemento |
| array.length | Comprimento de tabela |
| if ( test) block | Condicional |
| if ( test ) block else block | Condicional com mais |
| comutador (teste) { case value : statements case value : statements ... default: afirmação } | comutador (só com número inteiro ou tipos de trabalho a dias) |
| for (initializer; test; change ) block | para laço |
| while ( test ) block | enquanto laço |
| do block
while (test) | realmente fazer um laço |
| break [ label ] | intervalo de laço ou comutador |
| continue [ label ] | continue o laço |
| label: | Laço etiquetado |
| class classname block | Definição de classe simples |
| Algum dos seguintes modificadores opcionais pode acrescentar-se à definição de classe: | |
| [ final ] class classname block | Não pode subclassificar-se |
| [ abstract ] class classname block | Não pode ser instantiated |
| [ public ] class classname block | Pacote exterior acessível |
| class classname [ extends Superclass ] block | Defina superclasse |
| class classname [ implements interfaces ] block | Implemente uma ou várias interfaces |
O método básico parece a isto, onde returnType é um nome de tipo, um nome de classe ou void.
| ReturnType methodName() block | Método básico |
| returnType methodName(parameter, parameter, ...) block | Método com parâmetros |
Os parâmetros de método parecem a isto:
| type parameterName |
As variações de método podem incluir alguma das seguintes palavras-chave opcionais:
| [ abstract ] returnType methodName() block | Método abstrato |
| [ static ] returnType methodName() block | Método de classe |
| [ native ] returnType methodName() block | Método nativo |
| [ final ] returnType methodName() block | final method |
| [ synchronized ] returnType methodName() block | Fechadura de fio antes de execução |
| [ public | private | protected ] returnType methodName() | Controle de acesso |
Os construtores parecem a isto:
| classname() block | Construtor básico |
| classname(parameter, parameter, parameter...) block | Construtor com parâmetros |
| [ public | private | protected] classname() block | Controle de acesso |
No corpo de método/construtor pode usar estas referências e métodos:
| this | Refere-se ao objeto atual |
| super | Refere-se à superclasse |
| super.methodName() | Chama o método de uma superclasse |
| this(...) | O construtor de classe de chamadas |
| super(...) | O construtor de superclasse de chamadas |
| return [ value ] | Devolve um valor |
| import package.className | Importa o nome de classe específico |
| import package.* | Importações todas as classes públicas em pacote |
| package packagename | As classes neste arquivo pertencem a este pacote |
| interface interfaceName [ extends anotherInterface ] block |
| [ public ] interface interfaceName block |
| [ abstract ] interface interfaceName block |
| synchronized ( object ) block | Espera pela fechadura no objeto |
| try block | Afirmações cautelosas |
| catch ( exception ) block | Realizado se a exceção se lança |
| [ finally block ] | Código de limpeza |
| tente o bloco [proveito (exceção) bloco] finalmente bloco | Mesmo como exemplo prévio (pode usar o proveito opcional ou finalmente, ou ambos) |