Certificação SCJP – Declarações e Controle de Acesso

Dando continuidade ao post anterior (Certificação SCJP – Sun Certified Programmer), irei abordar aqui a primeira parte do estudo sobre a certificação. Espero que tirem proveitos e só para constar: não apresentarei detalhes, esta seqüencia de posts apresenta somente os pontos-chave para que possa nortear os estudos e revisões.

Objetivos abordados:

1.1 Desenvolver código que declare classes (incluindo abstract e todas as formas de aninhar classes), interfaces, e enums, e incluir apropriadamente uso de pacotes e imports (incluindo imports estáticos);

1.2 Desenvolver código que declare interfaces. Que implemente ou estenda uma ou mais interfaces. Que declare uma classe abstrata e desenvolver código que estenda classes abstratas;

1.3 Desenvolver código que declare, inicialize, e use primitivos, arrays, enuns, e objetos como static, instancia e variáveis locais. Também, usar identificadores válidos para nomes de variáveis;

1.4 Desenvolver código que declare métodos ambos estáticos e não estáticos, e – se apropriado – usar nomes de métodos que aderem ao padrão JavaBeans. Também desenvolver código que declare e use uma variable-length argument list (var-args).

Objetivos 1.3 e 1.4

A Sun e a comunidade de programadores Java define algumas convenções e regras para nomeação e criação de Identificadores. Identificadores são nomes dados a classes, variáveis e métodos. Convenções não são regras e sim orientações.

Declaração

Identificadores: Podem começar com $ ou _, não podendo começar com números.

Não pode usar Palavras-chaves como nomes, dentre elas: abstract, assert, boolean, break, byte, case, catch, char, class, const, continue, default, do, double, else, enum, extends, final, finally, float, for, goto, if, implements, import, instanceof, int, interface, long, native, new, package, private, protected, public, return, short, static, strictfp, super, switch, synchronized, this, throw, throws, transient, try, void, volatile, while.

Classes e Interfaces: primeira letra maiúscula e o restante minúscula. Em caso de nomes compostos a primeira letra de cada palavra é maiúscula – isso chama-se camelCase. Classes são Substantivos e interfaces Adjetivos.

Métodos: primeira letra minúscula e em caso de palavras compostas segue a mesma regra anterior. Geralmente primeira palavra um verbo e a seguinte um Substantivo.

Variáveis: mesma regra dos métodos. Não se usa verbo para nomear.

Constantes: usa-se letras maiúscula e em caso de palavras compostas são separadas por _.

Padrão de desenvolvimento JavaBeans:

para variáveis usa-se modificadores privados e a única forma de recuperação e modificação é através de métodos públicos (Encapsulamento – setters e getters).

para listeners (Objetos que recebem informações de eventos) utiliza-se no inicio do método add ou remove sempre com argumentos com o tipo do listener.

Objetivo 1.1

Regras para arquivos-fonte, as classes devem conter:

1. Uma declaração package na primeira linha. Caso não exista a classe pertence ao pacote padrão;
2. Import’s encontram-se entre o package e a declaração da classe;
3. Apenas uma classe deve ser public, as demais devem ser default;
4. Comentários são independentes de qualquer regra;
5. O nome do arquivo fonte deve ser igual ao nome da classe com modificador public. Caso não exista nenhuma classe com modificador public o arquivo fonte pode conter qualquer nome.

Classes

Controle de acesso:

Acesso default: acesso apenas por classes do mesmo pacote;
Acesso public: acesso sem restrições de pacotes;
Acesso private: não se usa a classes;
Acesso protected: não se usa a classes.

Modificadores não referentes a acesso:

Final: significa que a classe não pode ser estendida (classes, variáveis e métodos);
Abstract: não pode ser instanciada nunca, apenas pode ser estendida. Não é possível combinar Abstract e final. Classes abstracts que implementam interfaces não são obrigadas a implementar os métodos da interface. Logo uma classe A comum que estende uma classe abstrata B (que implementa uma interface C) é obrigada a implementar os métodos da interface C. Ou seja, mesmo que A não implemente C elá é obrigada a implementar os métodos de C pois ela estende B. Se aplica somente a classes e métodos

Objetivos 1.1 e 1.2

Interface

1. Implementa métodos abstracts ou seja, a interface é uma classe totalmente abstract.
2. Todos os seus métodos devem ser implementados e não deve possuir implementações na própria interface como também não podem ser static, final, native, strictfp ou synchronized.
3. Todas variáveis são publicas, estáticas e final ou seja só pode declarar constantes.
4. Interface pode estender varias Interfaces e somente interfaces.
5. Interface não pode implementar interface ou classe.

Objetivos 1.3 e 1.4

Métodos e Atributos

Modificadores de Acesso a membros:

Public: membro com esse modificador pode ser acessado por qualquer classe independente de qualquer pacote. Existem 3 formas de acesso: Invocação na mesma classe, invocar por meio de referência e invocar o método herdado.
Default: acesso a nível de pacotes.
Protected: Idêntico ao default porém pode ser acessado através de herança por outro pacote e no mesmo pacote pode ser acessado tanto com herança como instanciado;
Uma observação “chave”: quando uma classe A no pacote1 com um membro protected é herdada no pacote2 por uma classe B esse membro se torna private para todas as classes do pacote2. Interessante não?
private: Invisível para qualquer código fora da mesma classe. Obs.: variáveis locais não podem ter modificadores de acesso.

Modificadores não referentes a acesso

Métodos final: impede que um método possa ser sobrescrito.
Argumentos final: impede que um argumento possa ser modificado dentro de um método.
Métodos abstract: a classe que possuir um método abstract deve obrigatoriamente ser abstract. São métodos que não possui implementação, porém quando a classe que o possui for herdada ela deve implementar o método. Uma classe abstract que estender uma classe abstract não é obrigada a implementar os métodos. Apenas classes concretas são obrigadas. Isso ocorre muito parecido com classes abstratas que implementam interface, como foi dito antes. Não pode vir junto com final nem private. Isso é logico não?
Métodos synchronized: indica que ele só pode ser acessado por uma thread. Pode ser aplicado somente a métodos.
Métodos native: uma palavra chave reservada que indica que o método é implementado de forma dependente da plataforma. Não é necessário para o exame saber sobre este modificador.
Métodos strictfp: força os pontos flutuantes e qualquer operação com o mesmo aderir ao padrão IEEE754. Para o exame não é necessário aprofundar os conhecimentos sobre este assunto. Modifica declaração de uma classe e de um método.

Métodos com Listas de argumentos variáveis: Muito conhecido como var-args consiste em um parâmetro em forma de lista com uma quantidade variável de argumentos. Para declarar um var-arg você deve seguir a regra: <TIPO>… <NOME> . Deve sempre ser o ultimo parâmetro do método e o único var-arg do método. ex.: int… lista

Declaração de construtores

1. Não deve ter tipo de retorno;
2. Pode possuir os 3 tipos de modificadores de acesso;
3. Pode usar argumentos;
4. Devem ter o mesmo nome da classe;
5. Não podem ser marcados como static, final ou abstract (pois podem ser modificados, reescritos e implementados na própria classe ou fora dela).

Declaração de Variáveis

Variáveis primitivas: char, boolean, byte, short, int, long, float, ou double. Podem ser declaradas como variáveis de classes, atributos, parâmetros de métodos ou variáveis locais.

Tipos inteiros (menor para maior capacidade):byte, short, int e long.

Doubles são maiores que floats.

Variáveis de referencia: usadas para referenciar objetos. podem ser declaradas como static, atributos, parâmetros de métodos e variáveis locais;

Atributos ou variáveis de instância: podem usar qualquer um dos níveis de acesso e podem ser marcados como final, transient, static e volatile. Não podem ser abstract, synchronized, strictfp, native.

Locais:São variáveis declaradas em métodos e obrigatoriamente inicializada dentro do mesmo. Esse tipo de variável só vive dentro do escopo do método e ficam sempre na memória stack. É importante saber que enquanto essa variável está no stack e for uma referencia a um objeto, o objeto será criado na memória heap. Podem ser marcadas como final e podem possuir o mesmo nome que um atributo.

Arrays:Objetos que armazenam multiplas variáveis do mesmo tipo. Será sempre um objeto no heap mesmo se for declarado por armazenar primitivos. São declarados informando o tipo de elementos que irá conter no array e seguido por colchetes. Esses colchetes podem ser antes ou depois do nome do array – (String [] nomes / String nomes []), (String [][] nomes / String [] nomes []) – Não é válido incluir tamanho do array na sua declaração. Somente pode ser feito isso após uma instancia do array ter sido criada.

Finais: Essa declaração impossibilita a reutilização dessa variável depois de ter sido inicializada com um valor explicito. (Classes, métodos, atributos e variáveis locais)

Transient: Quando ocorre essa declaração quer dizer que a JVM irá ignorar essa variável no processo de serialização do objeto que o contém. A serialização quer dizer  que o valor de seus atributos serão escritos em um tipo especial de stream de I/O. É importante saber que essa funcionalidade foi adicionada ao exame na versão Java 5. Será tratada com mais detalhes nos próximos tópicos.

Volatile: O que você precisa saber para o exame sobre esse modificador é que o mesmo só pode ser usado para atributos. Geralmente, em vez de se usar este tipo de modificador usa-se a sincronização.

Variáveis e Métodos static’s: Quando você informa uma variável ou método como static você está querendo dizer que independente de a classe ter sido criada ou não este método ou variável irá existir. É importante saber que todas as instâncias da classe compartilharão o mesmo valor pra qualquer variável static. Aplicado a Atributos, Métodos e Classes aninhadas dentro de outra classe. Não podem ser statics construtores, classes não aninhadas, interfaces, classes declaradas localmente, métodos de classes internas e variáveis locais.

Enums

Enum é um tipo de dado que quando usado lhe permite restringir uma variável a possuir alguns valores pré-definidos. Podemos dizer também que um enum é um tipo especial de classe.
Ex.: enum Categoria {JAVA, SCJP, TECNOLOGIA};
Para obter uma categoria faz-se da seguinte forma: Categoria c = Cateogira.JAVA. Como as variáveis dentro de um enum são constantes elas devem, segundo a convenção de código da Sun, ser escritas em maiúsculas. Porém isso não quer dizer que você é obrigado a seguir essa convenção. Podem ser declarados como as suas próprias classes separadas ou como membros de classes, mas não podem ser declarados dentro de métodos.
É possível declarar dentro de um enum um controlador porem esse controlador nunca pode ser invocado. Esse construtor é invocado automaticamente pelas constantes. É importante saber também que as constantes não possui um tipo definido, pode-se dizer que o tipo das constantes são o próprio enum.
Podemos definir um construtor, um método e uma variável para os enums:

Baixe aqui (Código Comentado) e você saberá como utilizar.

Concluindo

Declaração e Controle de Acesso finalizado, agora só depende de você buscar questões e exemplos de cada ponto-chave abordado aqui. Espero que tenham gostado e espero críticas e sugestões!

Até o proximo post

~ por Flavio Ribeiro em setembro 7, 2009.