Modificadores de acesso:
private: é usada na declaração de método, campo ou classe interna; membros privados somente podem ser acessados por outros membros da própria classe.
protected: é usada na declaração de método, campo ou classe interna; membros protegidos somente podem ser acessados por membros da própria classe, por suas subclasses, e por classes do mesmo pacote.
public: é usada na declaração de classe, método ou campo; classes, métodos e campos públicos podem ser acessados por qualquer membro de outras classes, do mesmo e de outros pacotes.
Modificadores de Classes, Métodos e Variáveis
abstract: é usada para declarar uma classe ou método que será abstrato. Um método abstrato não tem implementação; todas as classes que contém métodos abstratos devem ser abstratas, contudo nem todas as classes abstratas tem métodos abstratos. Objetos de uma classe que é abstrata não podem ser instanciadas, mas podem ser extendidos por outras classes. Todas as subclasses de uma classe abstrata devem prover implementações para todos os métodos abstratos, ou ela também deve ser abstrata.
class: tipo que define a implementação de um tipo particular de objeto. Uma definição de classe define instância, campos, métodos e classes internas, tão bem como especifica a interface da qual implementa e da superclasse imediatamente superior a ela. Se a superclasse não especificar explicitamente, a superclasse é um objeto implícito.
extends: é usada em declaração de classes para especificar a superclasse; usada em uma declaração de interface para especificar uma ou mais superinterfaces. Classe X estende da classe Y para adicionar funcionalidades, tanto adicionando campos ou métodos na classe Y, como sobrescrevendo métodos da classe Y. Uma interface Z estende uma ou mais interfaces adicionando métodos. Classe X é dita ser uma subclasse de Y; interface Z é dita ser uma subinterface das interfaces que ela estende.
final: define uma entidade única que não pode ser alterada nem derivada depois. Mais especificamente: uma classe final não pode ser herdada, um método final não pode ser sobrescrito, e uma variável final não pode ocorrer mais de uma vez em uma expressão. Todos os métodos em uma classe final são implicitamente final.
implements: incluída na declaração da classe para especificar uma ou mais interfaces que são implementadas por ela. Uma classe herda os tipos e métodos abstratos declarados nas interfaces.
interface: usada para declarar um tipo especial de classe que contém somente métodos abstratos, constantes (static final) e interfaces static. Ela pode depois ser implementada por classes que declaram a interface com a palavra reservado implements.
native: usada em declaração de métodos para especificar que o método não é implementado em Java, mas em outra linguagem como C++, por exemplo.
new: usada para criar uma instância de uma classe ou array.
static: usada para declarar um campo, método ou classe interna como um campo da própria classe. static faz o método ou campo pertencer a classe ao invés da instância, não sendo necessário instanciar um objeto para ter acesso.
strictfp: usada para restringir a precisão e arredondamento do cálculo de ponto flutuante para assegurar portabilidade.
synchronized: usada na declaração de um método ou bloco de código para adquirir o bloqueio mutex para um objeto enquanto uma threat executa o código. Para métodos estáticos, o objeto bloqueado é uma Class. Garante que mais de uma thread execute o código uma de cada vez. O bloqueio mutex é automaticamente liberado quando a execução sai do código sincronizado. Campos, classes e interfaces não podem ser declaradas como synchronized.
transient: declara que um campo de instância não fará parte da serialização padrão de um objeto. Quando um objeto é serializado, somente os valores de seus campos não transientes serão incluídos. Quando um objeto é desserializado, campos transientes são inicializados somente com seus valores padrão.
volatile: usada em declaração de campos para especificar que a variável pode ser modificada fora da sincronização. Métodos, classes e interfaces consequentemente não podem ser declaradas volatile.
Controle de fluxo
break: usada para sair do bloco de execução, continuando na sentença imediatamente posterior ao bloco. Se seguida por um rótulo, o programa continua a execução na sentença imediatamente posterior ao bloco rotulado.
case: é usada para criar casos individuais em uma sentença switch.
continue: usada para continuar a execução do programa no fim do corpo do loop atual. Se seguido por um rótulo, continue continua a execução no fim do bloco rotulado.
default: pode opcionalmente ser usada na cláusula switch para identificar um bloco de sentenças que serão executadas se nenhum case coincidir com os valores especificados.
do: é usada em conjunto com while para criar um loop do-while, que executa um bloco de sentenças associadas com o loop e então testa a expressão booleana associada com o while. Se a expressão retornar true, o bloco é executado novamente; ele continua até a expressão retorne false.
else: é usada em conjunto com if para criar a sentença if-else, que testa uma expressão booleana; se a expressão retornar true, o bloco associado com o if é executado; se retornar false, o bloco associado com o else é executado.
for: é usada para criar um loop for, que especifica uma variável de inicialização, uma expressão booleana, e um incrementador. A variável é inicializada primeiro, e então a expressão é avaliada. Se a expressão retornar true, o bloco associado com o loop é executado, e então a variável é incrementada. A expressão é avaliada novamente; ele continua até a expressão retornar false. A partir da versão 5.0, for pode ser usado para iterações com array ou objetos Iterable; cada iteração executa o bloco usando um elemento diferente do array ou Iterable.
if: é usada para criar uma sentença if, que testa uma expressão booleana; se a expressão retornar true, o bloco associado ao if é executado. A palavra reservada pode também ser usada para criar uma sentença if-else.
instanceof: um operador binário que pega a referência de um objeto como primeiro operando e uma classe ou interface como segundo operando e produz um resultado booleano. O operador instanceof retorna verdadeiro se e somente se o tipo em execução do objeto passado é compatível com a classe ou interface.
return: usada para finalizar a execução de um método. Pode estar seguido por um valor requerido pela definição do método que é retornado para a rotina que solicitou.
switch: é usada em conjunto com case e default para criar a sentença switch, que avalia uma variável, compara seu valor com um case específico e executa o bloco de instruções associados com aquele case. Se nenhum case coincidir com o valor, o bloco opcional marcado com default é executado, se incluído.
while: é usada para criar um loop while, que testa uma expressão booleana e executa o bloco associado com o loop se a expressão for verdadeira; ele continua até a expressão retornar falso. Esta palavra chave pode ser usada para criar um loop do-while.
Manipuladores de erro
assert: a palavra chave assert, que foi incluída na versão 1.4, é usada para fazer uma asserção – uma sentença que o programador acredita que é sempre verdadeira naquele ponto do programa. Se asserções são habilitadas quando o programa está rodando e uma delas retornar falso, um AssertionError é lançado e o programa termina.
catch: define um tratamento de exceção – um grupo de sentenças que são executadas se uma exceção é lançada no bloco definido pelo try. O código é executado somente se a exceção lançada é compatível com a classe de exceção declarada no catch.
finally: usada para definir um bloco de instruções que serão executadas após as instruções do bloco try e qualquer bloco catch associado ao try, ou após deixar um try ou catch usando o return.
throw: lança uma instância da exceção declarada. throw continua lançando a exceção até a primeira cláusula catch compativel com a exceção tratá-la. Se nenhum tratamento for encontrado, o método lança a exceção para o método que o invocou. Se nenhum método de tratamento é encontrado na pilha, então a exceção é passada para o tratador de erros não capturado.
throws: usada em declarações de métodos para especificar que exceções não serão tratadas no método atual, mas lançadas para o nível imediatamente superior do programa. Todas as exceções não tratadas em métodos que não sejam instâncias de RuntimeException devem ser declaradas usando throws.
try: define um bloco de instruções que tem tratamento de exceção. Se uma exceção é lançada dentro do bloco try, um bloco catch opcional pode tratar um tipo de exceção declarada. Também, um bloco opcional finally pode ser declarado, e será executado quando a execução sair do bloco try e das cláusulas catch existentes, havendo uma exceção ou não. Um bloco try deve ter pelo menos um catch ou finally associado.
Palavras reservadas não usadas
const: seu uso é proibido, no lugar é usado final static para constantes. Modificadores de acesso dizem o escopo da constante.
goto: seu uso é proibido por causar confusão no código. Linguagens antigas como Pascal, Basic e C implementam o desvio incondicional com goto. Nas linguagens modernas goto não é implementado.
Controle de pacotes
import: é usada no início do arquivo fonte para especificar classes ou entidades de pacotes Java que serão utilizados naquela classe.Desde a versão 5.0, import pode importar membros estáticos de uma classe usando static.
package: um grupo de tipos. Especifica qual pacote pertence o arquivo de código-fonte.
Variáveis de referência
this: é usada para representar uma instância de uma classe que ela aparece. this pode ser usado para acessar membros de classe e como uma referência para a instância atual. this também é usada para direcionar uma chamada de um construtor para outro construtor da mesma classe.
super: é usada para acessar membros de uma superclasse que a classe herda. Permite uma subclasse acessar métodos sobrescritos e membros ocultos da superclasse. super é também usada para direcionar uma chamada do construtor da classe para o construtor da superclasse. Também é usada para especificar o menor limite de um tipo de parâmetro em Generics.
Palavra-chave de retorno
void: é usada para declarar que um método não retorna nenhum valor.
Tipos primitivos
boolean: é usada para declarar um campo que armazena valores lógicos, true ou false.
byte: usada para declarar um campo inteiro de 1 byte; –128 to 127
char: é usada para declarar um campo que pode armazenar caracteres Unicode de 16 bits.
double: é usada para declarar um campo de ponto flutuante de dupla precisão, 8 bytes; approximately ±1.79769313486231570E+308 (15 significant decimal digits)
float: é usada para declarar um campo de ponto flutuante de simples precisão, 4 bytes; approximately ±3.40282347E+38F (6–7 significant decimal digits)
int: é usada para declarar um campo inteiro de 4 bytes; –2,147,483,648 to 2,147,483, 647 (just over 2 billion)
long: é usada para declarar um campo inteiro de 8 bytes; –9,223,372,036,854,775,808 to 9,223,372,036,854,775,807
short: é usada para declarar um campo inteiro de 2 bytes; –32,768 to 32,767
Valores literais
true: valor booleano que representa verdadeiro
false: valor booleano que representa falso
null: indica que o objeto não possui uma instância ou referência em memória.
Referência
VivaoLinux:
http://www.vivaolinux.com.br/artigo/Certificacao-Java-1-Java-Programming-Language-Keywords-%28Exam-Objective-4.4%29/
Wikipedia:
http://en.wikipedia.org/wiki/List_of_Java_keywords
Tags: certificacao, java, programação
