Category Archives: Java

Modificadores Não Referentes a Acesso

Métodos Final

A palavra final impede que um método possa ser substituído em uma subclasse, e frequentemente é usada para forçar os recursos API de um método.

Exemplo:

class SuperClass {

public final void carro(){

        System.out.println(“Meu primeiro carro!”);

}

}

Você pode estender a SuperClass mais não pode substituir o método carro(), o exemplo abaixo vai gerar um erro de compilação:

Exemplo:

class SubClass extends SuperClass(){

public void carro(){

   System.out.println(“novo carro!”);

}

}

Argumento Final

public Carro getCarrro(int numeroPortas, final int numeroRodas){}

No exemplo acima, a variável numeroRodas é declarada como final, o que significa que ela não poderá ser modificada dentro do método, ou seja ela não poderá ter seu valor modificado dentro do método.

Métodos Abstratos

Um método abstrato é um método que foi declarado como abstract mais não implementado, ou seja, ele não possui corpo, ao seu final coloca-se ponto e virgula.

public abstract void carro();

É inválido ter um único método abstract que seja em uma classe que não seja declarado explicitamente como abstract. Três dicas diferentes lhe dizem que se não se trata de um método abstrato.

  • O método não está marcado como abstract;
  • A declaração de um método possui chaves;
  • O método possui código de implementação;

A primeira subclasse concreta de uma classe abstrata deve implementar todos os métodos abstratos da superclasse. Concreto significa apenas não – abstrato, então, se você tiver uma classe abstrata estendendo outra classe abstrata a subclasse abstrata não precisa formar implementações para os métodos abstract herdados.

Um método não pode nunca, jamais ser marcado como abstract e final ao mesmo tempo, nem como abstract e private ao mesmo tempo. Os métodos abstract precisam ser implementados, enquanto que métodos final e private não podem jamais serem substituídos por uma subclasse. Os modificadores abstract e final são praticamente opostos.

Advertisements

Declarando Membros de Classe

Os métodos e as variáveis de instância (não-locais) são conhecidos coletivamente como membros. Você pode modificar um membro que tenha tanto modificadores de acesso como modificadores que não se referem a aesso e você tem mais modificadores a declarar do que quando está declarando classes.

Modificadores de Acesso

Enquanto uma classe só pode usar dois modificadores de acesso, os membros podem usar todos os quatros (public, private, default e protected). Precisamos saber duas questões diferentes relativas ao acesso.

  • Se o código de um método em uma classe pode acessar um membro de outra classe.
  • Se uma subclasse pode herdar um membro de sua superclasse.

O primeiro tipo de acesso ocorre quando um método de uma classe tenta acessar um método ou variável de outra classe, usando o operador ponto(.) para invocar um método ou invocar uma variável.

Exemplo:

class Carro{
      public String corCarro(){
          return “Vermelho”;
      }
}

class Classic{
     public void meuClassi(){
        Carro c = new Carro();
       System.out.println(“Cor do Classic ” + c.corCarro());
    }
}

O segundo tipo de acesso refere-se a quais membros de uma superclasse pode invocar um método para uma instância da superclasse. Em vez disso, queremos saber se a subclasse pode herdar um membro da sua superclasse. Lembre-se que se uma subclasse herda um membro é exatamente como se a subclasse tivesse declarado o membro ela mesma. Em outras palavras, se uma subclasse herdar um membro, então ela possui esse membro.

Membros Public

Quando um método ou variável membro é declarada public, isso significa que todas as outras classes, independentemente do pacote ao qual pertençam podem acessar o membro em questão.

Três formas de acessar um método:

  • Invocando um método declarado na mesma classe;
  • Invocando um método usando referência da classe;
  • Invocando um método herdado.

Para uma subclasse, se um membro da sua superclasse for declarado public, a subclasse herda esse membro independentemente de ambas as classes estarem no mesmo pacote ou não.

Membros Private

Membros marcados como private não podem se acessados por código em nenhuma outra classe que não aquela na qual o membro private foi declarado. Quando um membro é marcado como private, nem mesmo uma subclasse poderá enxerga-lo. Caso uma subclasse declare um método com o mesmo nome do método substituto.

Membros Protected e Default

Os níveis de controle de acesso protected e default são quase que idênticos, mas com uma diferença fundamental. Um membro default só pode ser acessado se a classe que o estiver acessando pertencer ao mesmo pacote, enquanto que um membro protected poder ser acessado (através de herança) por uma suclasse mesmo se a subclasse estiver em um pacote diferente.

Depois que uma subclasse de fora do pacote herda o membro protected, ele (conforme herdado pela subclasse) torna-se private para qualquer código de fora da subclasse, com a execução das subclasses dessa subclasse.

Quando não colocamos um modificador de acesso na frente da variável ela se torna padrão.

 

Fonte: Guia de Estudo SCJP
Autor Kathy Sierra e Bert Bates

Um pouco sobre Interfaces

Quando você criar uma interface, estará definindo um contrato com o que a classe pode fazer, sem mencionar nada sobre como a classe o fará. Uma interface é um contrato. Você poderia escrever uma interface Carro. Qualquer tipo de classe que implementar essa interface precisa concordar em escrever o código dos métodos Correr() e setCorrerFabrica().

As interfaces podem ser implementadas por qualquer classe, de qualquer árvore de herança. Isso permitirá que você use classes radicalmente diferentes e forneça a elas uma caracterisitica em comum.

Uma interface equivale a uma classe 100% abstrata e como uma classe abstrata a interface define métodos abstratos como a forma abaixo:

abstract void Carro();

Nas classes abstratas, você tanto pode definir métodos abstratos como métodos não abstratos, contudo na interface todos os métodos serão abstratos. Outro ponto em que diferem as classes abstratas das interfaces é quanto a flexibilidade em como os métodos e variáveis definidos na interface são declarados. Abaixo a lista de regras:

  • Todos os métodos de interface são implicitamente public e abstract. Em outras palavras, você não precisa digitar realmente os modificadores public e abstract.
  • Todas as variáveis definidas em uma interface devem ser public, static e final.
  • Os métodos de interface não podem ser estáticos.
  • Já que os métodos de interface são abstract não podem ser marcados como final.
  • Uma interface pode estenter uma ou mais interfaces diferentes.
  • Uma interface não pode estender nada que não seja outra interface.
  • Uma interface não pode implementar outra interface ou classe.
  • Uma interface deve ser declarada com a palavra chave Interface.
  • Os tipos de interface podem ser usados polimoficamente.

Digitar o modificador abstract é redundante, as duas situações abaixos são idênticas.

public abstract interface Carro{}

public interface Carro{}

 

Fonte: Guia de Estudo SCJP
Autor Kathy Sierra e Bert Bates

Declarações e Modificadores de Classe

Os modificadores se dividem em duas categorias:
Modificadores de acesso: public, protected e private
Modificadores que não se referem a acesso: strictfp, final e abstract

Uma classe pode ser declarada apenas com os modificadores public ou default, os outros dois níveis de controle de acesso não se aplicam para classes.

Modificadores de Acesso

Quando você não coloca nenhum modificador precedendo o nome da classe esta classe fica com o acesso default(Padrão), com esse acesso uma classe A só pode ser acessada de dentro do seu pacote, caso uma classe B que esteja em outro pacote, esta não poderá instanciar a classe A e nem mesmo criar uma variável do tipo A.

Uma declaração de classe com a palavra-chave public dá a todas as classes, de todos os pacotes, acesso à classe pública. Em outras palavras, todas as classes do Universo Java têm acesso a uma classe pública. No entando, não se esqueça, de que, se uma classe pública que estiver tentando usar estiver em um pacote diferente do da classe que está escrevendo, você ainda precisará importar a classe pública.

Modificadores que não se referem a acesso

Você pode mudar um declaração de classe usando as palavras-chaves final, abstract ou strictfp.Você pode usar esses modificadores com qualquer modificador de controle de acesso, por exemplo public e final.

  • Classes Finais: Quando usada na declaração de uma classe, a palavra-chave final não permite que nenhuma outra classe possa estender (herdar de), ou seja ela não pode ser subclassificada. Você só deverá marcar uma classe como final se tiver absoluta certeza que nenhum dos seus métodos deverá substituído.
  • Classes Abstratas: Uma classe abstrata não pode ser instanciada nunca, seu único propósito é ser extentida. nas classes abastratas se apenas um único método for abstract, toda a classe deverá se declarada como abstract. Embora uma classe abstract possa ter métodos não abstracts, com isso você dá a todas as subclasses concretas implementações de métodos herdados. Não é possível marcar uma classe como abstract e final ao mesmo tempo, pois eles tem significados quase que opostos.
  • Strictfp: É uma palavra-chave que pode ser usada para modificar uma classe ou método, mais nunca uma variável. Marcar uma classe com strictfp significa que qualquer código ou método na classe se conformará as regras do padrão IEEE 754 para pontos flutuantes, sem esse padrão os valores de pontos flutuantes vão se comportar de forma variante conforme a plataforma.

 

Fonte: Guia de Estudo SCJP
Autor Kathy Sierra e Bert Bates

Acesso a Membros de Classes

Abaixo uma tabela que mostra todas as combinações de acesso e visibilidade.

Visibilidade Public Protected Default Private
A partir da mesma classe Sim Sim Sim Sim
A partir de qualquer classe do mesmo pacote Sim Sim Sim Não
A partir de uma subclasse do mesmo pacote Sim Sim Sim Não
A partir de uma subclasse de fora do mesmo pacote Sim Sim (herança) Não Não
A partir de qualquer classe que não seja uma subclasse e esteja fora do pacote Sim Não Não Não

SCJP ai vou eu!!!

Hoje começei meus estudos para tirar a  certificação Sun Certified Java Programmer (SCJP), fiz todo o planejamento de estudo, deverei estar fazendo a prova na segunda quinzena de Agosto. Alguns podem achar muito tempo, mais prefiro fazer um planejamento longo que dê certo do que um curto que acabe furando o prazo.

Como material de referência estou usando o livro da Kathy Sierra – Certificação Sun para Programadores Java 6 GUia de Estudo SCJP Exame 310-065.

scpjlivro

Esse livro é totalmente voltado para a prova de certificação, nele constam exercicios simulados, dicas e sugestões de como se preparar melhor para a prova.

A partir de amanhã espero estar sempre postando a evolução do meu estudo, e quem sabe ajudar aqueles que um dia quiserem fazer a certificação SCJP.

Java a Bola da Vez

Desde que comecei minha vida profissional, sempre trabalhei na plataforma .Net. Sempre achei legal a metodologia do framework que ela utiliza, torna as aplicações muito mais rápidas de serem desenvolvidas. Porém recentemente no trabalho recebemos a recomendação de migrar tudo para software livre, ou seja, vamos para Java. No começo fiquei meio receoso devido ao Java ser bem menos produtivo que o .Net, contudo para minha supresa fui apresentado ao framework JBoss Seam, este framework quebrou meus paradigmas em relação a desenvolver em Java.

O  JBoss Seam é um framework que está acima do framework (Java EE), que por sua vez está acima do framework (Java). A palavra framework tem amplo significado dependendo de como é usado e de quem a está usando. No caso do Seam, ele molda um conjunto de API’s e serviços em um ambiente que facilita escrever aplicações web Java EE. Em outras oportunidades falarei mais sobre o Seam.

Como conhecimento é poder, não pretendo abandonar a plataforma .Net, continuarei estando suas novidades e evoluções com toda a empolgação que sempre tive, porém agora também vou acompanhar o mundo Java (Seam).

Até mais a todos !!!