SCJP_01.txt

Os identificadores podem começar com uma letra, um underscore, ou um caracter monetário.

Depois do primeiro caracter, os identificadores podem incluir também dígitos.

Os identificadores podem ter qualquer extensão.

Os métodos JavaBeans devem ser nomeados usando-se camelCase e, dependendo do propósito do método devem começar com set, get, is, add ou remove.

Um arquivo de código-fonte só pode ter uma classe pública.

Se o arquivo de código-fonte tiver uma classe pública, seu nome terá que coincidir com o dessa classe.

O arquivo só pode ter uma instrução package, porém, várias de import.

A instrução de package (se houver) deve ficar na primeira linha (fora os comentários) do arquivo de código-fonte.

A instrução import (se houver) deve vir depois de package e antes da declaração class.

Se não houver instrução package, as instruções import terão que ser as primeirs (fora os comentários) do arquivo de código-fonte.

As instruções package e import são aplicadas a todas as classes do arquivo.

O arquivo pode ter mais de uma classe não publica.

Os arquivos que não tiverem classes public não apresentarão restrições de nomeação.

Há três modificadores de acesso: public, protected e private.

Há quatro níveis de acesso: public, protected default e private.

As classe só podem ter acesso public ou default.

Uma classe com acesso default pode ser visualizada somente por outra classe no mesmo pacote.

Uma classe com acesso public pode ser visualizada por todas as classes a partir de todos os pacotes.

A visibilidade das classes gira em torno de se o código de uma classe pode: (1) criar uma instância de outra classe, (2) Estender (ou criar subclasses) outra classe e (3) Acessar métodos e variáveis de outra classe.

As classes também podem ser alteradas com final, abstract ou strictfp.

Uma classe não pode ser final e abstract.

Uma classe final não pode ter subclasses.

Uma classe abstract não pode ser instanciada.

Uma classe com somente um método abstract significa que a classe inteira deve ser abstract.

Uma classe abstract pode ter métodos abstract ou não.

A primeira classe concreta a estender uma classe abstract terá que implentats.

As interfaces são contratos que definem o que a classe pode fazer, mas não dizem nada sobre a maneira pela qual ela deverá fazê-lo.

As interfaces podem ser implentadas por qualquer classe, de qualquer árvore de herança.

A interface é como uma classe 100% abstract, e será implicitamente abstract caso você digite ou não o modificador abstract na declaração.

Uma interface só pode criar métodos abstract, nenhum método concreto é permitido.

Os métodos das interfaces são, por padrão, public e abstract - a declaração explícita desses modificadores é opcional.

As interfaces podem ter constantes, que são sempre implicitamente public, static e final.

As declarações da constante de interface com public, static e final são opcionais em qualquer combinação.

Uma classe de implentação não-abstract fornecerá implentações concretas dos métodos da interface.

Uma classe de implentação não-abstract deve seguir todas as regras de sobrecarga válidas para os métodos que implementa.

Uma classe de implentação não-abstract não deve declarar nenhuma exceção nova do método implentado.

Uma classe de implentação não-abstract não deve declara nenhuma exceção que seja mais abrangente do que as declaradas no método da interface.

Uma classe de implentação não-abstract pode declarar exceções de tempo de execução em qualquer implentação de método da interface, independente do que constar na declaração da interface.

Uma classe de implentação não-abstract deve manter a assinatura (são permitidos retornos covariantes) e o tipo de retorno exatos dos métodos que implementa (mas não precisa declarar as exceções da interface).

Uma classe que estiver implementando uma interface pode ela própria ser abstract.

Uma classe de implentação abstract não precisa implementar os métodos da interface (mas a primeira subclasse concreta precisa).

A classe só pode estender uma classe (sem herança múltipla), porém, pode implentar várias interfaces.

As interfaces pode estender uma ou mais interfaces.

As interfaces não podem estender uma classe ou implementar uma classe ou interface.

Quando fizer o exame, verifique se as declarações de interface e classe são válidas antes de verificar outras lógicas do código.

Os métodos e as variáveis de instância (não locais) são conhecidos como "membros".

Os membros podem usar todos os quatros níveis de acesso: public, protected, default e private.

O acesso aos membros se dá de duas formas: (1) o código de uma classe pode acessar um membro de outra classe e (2) uma subclasse pode acessar um membro de sua superclasse.

Se uma classe não puder ser acessada, seus membros também não poderão.

A visibilidade da classe deve ser determinada antes da dos membros.

Os membros public podem ser acessados por todas as outras classes, mesmo de pacotes diferentes.

Se um membro da superclasse for public, a subclasse o herdará - independente do pacote.

Os membros acessados sem o operador ponto (.) têm que pertencer a mesma classe.

this sempre referenciará o objeto que estiver sendo executado no momento.

this.aMethod() é o mesmo que simplesmente chamar aMethod().

Os membros private só podem ser acessados por um código da mesma classe.

Os membros private não ficam visíveis para as subclasses, portanto, não podem ser herdados.

Os membros default e protected só diferem quando subclasses estão envolvidas.

Os membros default só podem ser acessados por outras classes do mesmo pacote.

Os membros protected podem ser acessados por outras classes do mesmo pacote, além de por subclasses, independente do pacote.

protected = pacote + filhos (subclasses)

Por subclasses externas ao pacote, o membro protected só pode ser acessado através da herança: uma subclasse externa ao pacote não pode acessar um membro protected usando a referência a uma instância da superclasse

Um membro protected herdado por uma subclasse de outro pacote não pode ser acessado por nenhuma outra classe do pacote da subclasse, exceto pelas próprias subclasses dessa.

As declarações de variáveis locais (de método, automáticas, de pilha) não podem ter modificadores de acesso.

final é o único modificador disponível para variáveis locais.

As variáveis locais não recebem valores padrão, portanto, devem ser inicializadas antes do uso.

Os métodos final não podem ser substituídos em uma subclasse.

Os métodos abstract são declarados, com uma assinatura, um tipo de retorno e uma cláusula throws opcional, mas não são implementados.

Os métodos abstract terminam com um ponto-e-vírgula, e não chaves.

Há três maneiras de identificar um métodos não abstrato: (1) não é marcado como abstract, (2) possui chaves e (3) possui código entre as chaves.

A primeira classe não-abstrata (concreta) a estender uma classe abstrata deve implementar todos os métodos abstratos dessa.

Os modificadores synchronized só é aplicado a métodos e a blocos de código.

Os métodos synchronized podem ter qualquer controle de acesso e também serem marcados como final.

Os métodos abstract devem ser implementados por uma subclasse, portanto, têm de ser herdados. Por essa razão: (1) os métodos abstract não podem ser private e (2) os métodos abstract não podem ser final.

O modificador native só é aplicado a métodos.

O modificador strictfp só é aplicado a métodos.

A partir de Java 5 os métodos podem declarar um parâmetro que aceita de zero a muitos argumentos, é o chamado var-arg.

• Um parâmetro var-arg é declarado com a sintaxe tipo... nome; por exemplo:
• doStuff(int... x){}

Um método var-arg só pode ter um parâmetro var-arg.

EM métodos com parâmetros normais e uma var-arg, o var-arg deve vir por último.

As variáveis de instância podem: (1) ter qualquer tipo de controle de acesso e (2) serem marcadas como final ou transient.

As variáveis de instância não podem ser declaradas com abstract, synchronized, native ou strictfp.

É valido declarar uma variável local com o mesmo nome de uma variável de instância; isso é chamado de "sombreamento" (shadowing)

As variáveis final apresentam as seguintes propriedades: (1) não podem ser reinicializadas, uma vez que tiverem um valor atribuído, (2) as variáveis de referência final não podem referenciar um objeto diferente se já tiverem um objeto atribuído a elas e (3) as variáveis de referência final devem ser inicializadas antes que a execução do construtor seja concluída.

Não existem objetos final. Uma referência a objeto marcada como final não significa que o objeto propriamente dito seja inalterável.

O modificador transient só pode ser aplicado a variáveis de instância.

O modificador volatile só pode ser aplicado a variáveis de instância.

Arrays podem conter primitivas ou objetos, mas o array em si é sempre um objeto.

Ao declarar um array, os colchetes podem estar à esquerda ou à direita do nome da variável.

Nunca é valido incluir o tamanho do array em sua declaração.

Um array de objetos pode conter qualquer tipo que passe no teste de IS-A (ou instanceof) para o tipo declarado no array

NJão estão ligados a qualquer instância específica de uma classe.

Não é preciso qualquer instância para usar membros static de uma classe.

Existe apenas uma cópia de uma variável e/ou classe estática, que é compartilhada por todas as instâncias.

Métodos static não tem acesso direto a métodos não-estático.

Um enum especifica uma lista de valores constantes que podem ser atribuídos a um determinado tipo.

Um enum não é uma String nem um int; o tipo constante de um enum é o tipo do próprio enum.

Um enum pode ser declarado fora ou dentro de uma classe, mas não em um método.

Um enum declarado fora de uma classe não pode ser marcado com static, final, abstract, protected ou private.

Os enums podem conter construtores, métodos, variáveis e corpos de classes constantes.

As constantes enum podem enviar arguementos para o construtor enum.

Os construtores enums podem conter argumentos e podem ser sobrecarregados.

Os construtores enum nunca podem ser chamados diretamente no código. Eles são sempre chamados automaticametne quanto um enum é inicializado.

O ponto-e-vírgula ao final da declaração enum é opcional.

MyEnum.values() retorna um array dos valores de MyEnum.