Continuando nossa série, neste artigo abordaremos os identificadores válidos e as convenções. Analisaremos o relacionamento entre classes e como uma classe pode ter acesso a um membro de outra classe. A nível de organização dividimos este artigo da série em duas partes.

Identificadores e Convenções

Identificadores são nomes dados a variáveis, métodos e classes. Existem regras para criação dos identificadores.

Identificadores

Os identificadores devem iniciar com uma letra, um underscore(_) ou um cifrão($). Não é permitido que os identificadores comecem com um número. Não se pode utilizar uma palavra-chave como identificador. A tabela 1 lista as palavras-chave Java, inclusive “enum”, uma novidade do Java 5.

abstract    continue        for            new            switch
assert        default             goto            package        synchronized
boolean    do             if            private             this
break        double            implements         protected        throw
byte        else            import            public            throws
case        enum            instanceof        return             transient
catch         extends         int            short            try
char         final             interface        static            void
class        finally            long            strictfp            volatile
const        float            native            super            while

Tabela 1 - Palavras-chave Java


Padrão JavaBeans

A especificação JavaBeans foi desenvolvida para ser um padrão de desenvolvimento de componentes que, facilmente, possam ser utilizados por desenvolvedores em diferentes IDEs.
É primordial levarmos em conta que programar usando um conjunto de padrões auxilia a diminuir o esforço envolvido em fazer a manutenção, testar e aprimorar qualquer código.
Por esse motivo, a Sun fez um conjunto de padrões de programação em Java, e publicou esses padrões num documento denominado “Convenções de Código Java”.

Métodos: a primeira letra em minúsculo. Nas palavras compostas, a primeira letra sempre em caixa baixa, as demais palavras seguintes iniciam por caixa alta.
Variáveis: devem seguir a mesma lógica que os métodos. Começam com letra minúscula. Em palavras compostas, a primeira letra sempre em maiúscula, o restante das palavras seguintes iniciam por letra com caixa alta.
Classes e interfaces: a letra inicial deve ser maiúscula. Em situações onde os nomes sejam palavras compostas, a primeira letra de cada palavra deve ser maiúscula. Nas classes o nome deve ser sempre substantivo. Nas interfaces o nome deve ser um adjetivo.
Constantes: As constantes em Java são criadas marcando as variáveis com os modificadores final e static, ou através de enums. Elas devem ter seus nomes utilizando letras maiúsculas com caracteres underscore (_) como separadores.

Regras de Declaração para Arquivos-Fonte

Vamos primeiro mostrar um arquivo-fonte completo. Na continuação, trataremos dos vários componentes e da ordem em que eles devem estar no arquivo.

package biblioteca;
import java.util.regex.*;
import java.awt.*;
public class Arquivo{
    String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
class ClasseA{}
class ClasseB{}

I. Só é possível existir uma declaração package por arquivo-fonte. Caso a classe faça parte de um pacote, a declaração package deve aparecer na primeira linha do arquivo-fonte, antes de quaisquer declarações import que possam existir.
II. Se tiver declarações import, elas devem estar entre a declaração package, caso exista, e a declaração da classe. Caso não haja uma declaração package, então as declarações import devem aparecer nas primeiras linhas do arquivo-fonte.
III. Só é possível a existência de uma classe public por cada arquivo-fonte. Entretanto, podem existir várias classes, com modificadores diferentes de public. Note, novamente, o exemplo acima.
IV. Os comentários podem estar em qualquer linha do arquivo-fonte; eles são independentes de quaisquer regras de posicionamento.
V. Vamos supor que um arquivo-fonte tenha apenas classes não-public. Nesta hipótese, ele pode ter um nome diferente de quaisquer dessas classes. Partindo-se da premissa de que o arquivo-fonte possua somente a declaração: class ClasseJava { }, ele pode ser compilado com um nome qualquer, finalizado com a extensão .java.
VI. Se existir uma classe public num arquivo, o nome do arquivo, obrigatoriamente, deve ser o mesmo da classe public.

Controle de acesso a classes

Quando se fala que uma classe A tem acesso a uma classe B, isso quer dizer que a classe A pode fazer 3 coisas: criar uma instância da classe B e/ou estender a classe B e/ou acessar determinados métodos, dependendo do controle de acesso desses métodos e atributos.
Se a classe A não poder ver a classe B, o nível de acesso dos métodos e atributos na classe B não fará diferença; a classe A não terá acesso a esses atributos e métodos. Acesso quer dizer visibilidade.

Acesso Padrão

Perceba no exemplo a seguir, em que A e B pertencem ao mesmo pacote. Neste exemplo, o pacote é o pacote-default, uma vez que não existe instrução package no arquivo-fonte.

class A{
    int x;
}
class B extends A{        //Estender a classe
    A objeto = new A();    //Instanciar um objeto
    int y = x;        //Acessar um atributo
}

Observe com muita atenção: ao encontrar uma questão que possua uma lógica complexa, preste atenção nos modificadores de acesso primeiramente. Dessa maneira, ao descobrir uma tentativa de violação de acesso, por exemplo, classe do pacote X tentando acessar uma classe default do pacote Y, você deverá saber que o código não irá compilar, então não precisará entender a lógica do programa.

Modificador/Acesso (public)

Existem apenas 3 modificadores de acesso para 4 níveis de acesso. Os modificadores de acesso são: public, private e protected, os níveis de acesso possuem os 3 modificadores, acrescentando-se o nível de acesso de pacote(default).

Modificadores não-referentes a acesso

Pode-se alterar uma declaração de classe utilizando as palavras-chave final, abstract ou strictfp. Esses modificadores existem em adição a qualquer controle de acesso que há na classe, então é possível declarar uma classe como public e final ao mesmo tempo. Porém, não é em todas as situações que os modificadores não-referentes a acesso podem ser combinados.

Modificador final para classes

Quando utilizada na declaração de classe, a palavra-chave final quer dizer que a classe em questão não pode ser estendida. Ou seja, ela não pode conter subtipos (filhos); não permite a herança.
Várias classes da API são final. Como exemplo temos a classe String que não pode ser estendida. Tente supor a confusão que aconteceria se não existisse garantia no modo como um objeto String funcionaria em qualquer sistema que usasse sua aplicação.
No dia-a-dia, quase nunca iremos criar classes final. As classes final barram um dos benefícios fundamentais da orientação a objetos: a extensibilidade. Dessa maneira, a não ser que se tenha uma grande preocupação com a segurança, admita que algum outro programador poderá estender sua classe.

Classe abstract

A classe abstract tem comportamento completamente oposto ao da classe final. Uma classe abstract não pode ser instanciada diretamente em nenhuma hipótese. A palavra-chave abstract está implicitamente relacionada aos conceitos de herança e de reaproveitamento de código.
Perceba, entretanto, que uma classe abstract pode ser compilada e executada, logicamente, se nenhuma instância dela for criada (diretamente).
Métodos abstratos possuem ponto-e-vírgula(;) na sua terminação em vez de chaves.
Se o método abstract estiver em uma classe e não em uma interface, tanto o método como a classe devem estar marcados com o modificador abstract.
O uso de classes abstract e interfaces permite que se tire vantagens do polimorfismo proporcionando um alto grau de flexibilidade e extensibilidade. Em outras palavras, não existe a possibilidade de marcar uma classe como abstract e final simultaneamente.

Interfaces

Na criação de uma interface, será definido um contrato com o que a classe deve fazer, sem nenhuma menção sobre como a classe que implementa a interface fará.
Qualquer classe pode implementar uma interface, de qualquer árvore de herança. Isso permitirá o uso de classes extremamente diferentes e o fornecimento a elas de uma característica em comum.
Devemos ver uma interface como uma classe 100% abstract. Assim como a classe abstract, a interface define métodos abstract de acordo com o exemplo abaixo:

package devmedia;

interface Negociavel{
    void negociar();
    void planejar();
    void discutir();
}
interface Compravel{
    void comprar();
}

Entretanto, enquanto uma classe abstract pode definir métodos abstract e não-abstract(concretos), uma interface possui apenas métodos abstract.
Os métodos de interface são implicitamente public e abstract.
Já as variáveis declaradas em uma interface devem ser public, final e static - ou seja, as interfaces só podem declarar constantes. Veja o exemplo abaixo e suas possíveis variações.

interface Negociavel{
    String a = “Texto”;
    public int b = 30;
    public static double c = 40.05;
    static public String x = “Exemplo”;
    final boolean y = true;
    static public final char z = ‘Z’;
}

Podemos perceber também que os métodos de interface não podem ser static. Já que os métodos da interface são abstract, não podem ser declarados como final, native, synchronized ou strictfp. É possível uma interface estender uma ou várias interfaces.
A partir de agora é absolutamente indispensável que se aceite essa sintaxe. Uma interface “extends” outra interface.

package devmedia;
interface Flutuavel{}
interface Carregavel{}
interface Unificavel extends Flutuavel, Carregavel{}

Não é possivel modificar o valor de uma constante. Uma vez que o valor for atribuído, nunca poderá ser mudado. A atribuição ocorrerá na própria interface onde a constante estiver declarada, então a classe que implementar a interface pode acessar e usar a constante, mas somente como leitura.
A declaração da interface pode possuir o modificador public ou não. Sendo assim, seus níveis de acesso podem ser default ou public. Caso seja default, só pode ser estendida por interfaces do mesmo pacote, ou implementada por classes do mesmo pacote. Enfatizando mais uma vez: um método de interface é sempre abstract e public e uma constante de interface é sempre public static final.

Leia todos artigos da série