O que aprendemos até aqui

Vamos dar uma paradinha rápida no estudos para vermos o que aprendemos até aqui. Como já havia falado antes, estamos seguindo o conteúdo completo (não sei se vamos conseguir mostrar tudo, mas tentaremos) do programa de certificação para programador. Até aqui só vimos o objetivos da seção 1 (quero ver essas seções):
Section 1: Declarations, Initialization and Scoping
1.1 - Aprendemos a declarar classes concretas e abstratas. Ainda falta vermos enum.
1.2 - Aprendemos a declarar interfaces e implemtá-las, vimos que seus métodos são todos públicos e abstratos, e que todos as variáveis são constantes (public static final).
1.3 - Só vimos os identificadores válidos lembra (começa com $,_, ou letra, depois qualquer outro caractere unicode)
1.4 - nada visto ainda.
1.5 - nada visto ainda.
1.6 - nada visto ainda.

Já deu pra ver que falta muita coisa ainda né? Bom, alguns assuntos a gente vai ter que pular, mas só aquilo que a gente vir que dá pra você pegar de letra. Mas fique calmo, não vamos querer desistir por causa disso né? Uma dica para aqueles que não conseguem estudar (como eu :) ): marque a prova que você vai ser obrigado a estudar...rs é meio masoquismo, mas comigo funcionou.
Aguardem que vem mais post em breve. Até lá.

Declarando membros de classes - Parte 3

Vamos continuar o nosso estudo sobre os níveis de acesso aplicados aos membros de uma classe. Já falamos sobre três níveis: public, protected e default. Neste post vamos falar sobre o último nível de acesso: private. O nível de acesso privado é o mais restritivo dos níveis. Ele faz com que o membro que seja marcado como tal fiquei fechado dentro da classe que o criou, ou seja, SOMENTE é possível acessar um membro privado dentro da classe que o declarou. Sendo assim, os membros private NUNCA são herdados. Bom, já que não teremos muita coisa pra falar por aqui, então vamos para os exemplos:

Dog.java
public class Dog {
   private String raça = "viralata";
  
   private void latir(){
         System.out.println("au au");
   }
}

Dobberman.java
public class Dobbermar extends Dog {
   
    private void destruir(){
         System.out.println("rrrrr asdfhasdasd");
    }
}

Canil.java
public class Canil {
    private void exibirMe(){
         System.out.println("Eu posso ser acessado aqui");
    }
    public static void main(String args[]){
          Dog dog = new Dog();
          dog.latir(); // xiii
          Dobberman d = new Dobberman();
          d.raça = "Dobberman"; // piorou né?
          d.destruir(); // agora é que destruiu tudo
          exibirMe(); // blz. aqui tudo bem.
    }
  

Vamos fazer apenas mais uns poucos comentários para encerrar essa seção. Dog definiu dois membros privados, um método e uma variável de instância. Esses membros só podem ser acessados por algum código que esteja dentro do escopo (entre as chaves) da classe Dog, e por ninguém mais. Então eu nem preciso falar que a classe Dobberman não herdará os membros né? Vamos pular então pra classe Canil, ela instância um objeto Dog e um Dobberman, e em seguida tenta acessar seus membros privados, o que obviamente ocasionará em um erro de compilação, pois estes não são acessíveis a partir de outra classe. Se porém, contudo, todavia a classe Canil pudesse ser compilada, o método exibirMe poderia ser chamado sem problemas, pois apesar de ele ser privado, o acesso está sendo feito dentro da classe na qual ele foi declarado.

Então é isso. Sobre membros privados não há mais o que dizer, pelo menos não por enquanto (calma, depois falaremos sobre inner classe e você verá que é possível acessar membros privados a partir de outra classe... mas esqueça isso por enquanto).
Então se liga aí que é hora da revisão:

public -> acessível a partir de qualquer classe em qualquer pacote.
protected -> acessível a partir de qualquer classe no mesmo pacote e por outras classes em outros pacotes através de herança.
default -> acessível a partir de qualquer classe no mesmo pacote.
private -> acessível somente a partir da classe que o declarou.

Até o próximo post.

Declarando membros de classes - Parte 2

No post anterior nós estudamos sobre membros públicos. Vimos que eles são acessíveis a partir de qualquer classe. Neste post iremos estudar sobre os níveis protected e default. Isso porque eles são muito parecidos. E você vai notar rapidamente a diferença entre eles.

O nível default pode ser entendido como um nível de acesso de pacotes. Isso quer dizer que se você declarar um membro como default (na verdade você não vai colocar o modificador, lembra?) somente as classes que estiverem dentro do mesmo pacote que a sua terão acesso ao membro. Vamos pegar o exemplo anterior e retirar o modificador das variáveis de instância:

Animal.java
//Classe public diz que todos vão enxergá-la
public class Animal {
 //Membro (variável) default
 //somente classes do mesmo pacote
 //poderão acessar o membro.
 String nome;
}

Gato.java

public class Gato extends Animal {
String raça;

public void mostrarNome(){
     System.out.println(nome); //pode?
}

}

package javeiro;
Exercicio1.java
public class Exercicio1 {

public static void main(String arg[]){
    Gato g = new Gato();
    g.nome = "Garfield"; //e aqui?
    g.raça = "preguiçoso"; //aqui também né?
}
}

O método mostrarNome numa primeira olhada parece fazer uma operação ilegal tentando exibir a variável nome, que é de Animal e está marcada como default. Porém não há problemas, pois as classes Animal e Gato estão no mesmo pacotes, isso significa que além de herdar os membros públicos, gato também herda os membros default, nós veremos mais adiante que é possível fazer uma classe herdar os membros default de uma classe que está em outro pacote. Já a classe Exercicio1 não será compilada com sucesso. O compilador irá dizer que não conhece a propriedade nome e muito menos raça do objeto gato. Por que isso acontence? Exatamente isso que você pensou, Exercicio1 está em um pacote diferente da classe Gato, e isso faz com ela possa acessar somente os membros públicos dela.

Membros protegidos (protected)

O nível protected é muito parecido com o nível default. A diferença básica é que os membros protegidos podem ser acessados por classes de pacotes diferentes, desde que estas sejam subclasses da sua classe. As outras regras são iguais, ou seja, os membros protegidos só podem ser acessados por classes que estão dentro do mesmo pacote (com a exceção que falamos antes). O exemplo que faremos irá elucidar as dúvidas que possam ter resistidos:

Animal.java
package javeiro.pacote1;
//Classe public diz que todos vão enxergá-la
public class Animal {
 //Membro (variável) protected
 //somente classes do mesmo pacote
 //e subclasses poderão acessar o membro.
 protected String nome;
}

Gato.java
package javeiro.pacote2;
import javeiro.pacote1.Animal;

public class Gato extends Animal {
protected String raça;

public void mostrarNome(){
     System.out.println(nome); //herdou nome
}

}

package javeiro;
Exercicio1.java
public class Exercicio1 {

public static void main(String arg[]){
    Gato g = new Gato();
    g.nome = "Garfield"; //não pode
    g.raça = "preguiçoso"; //não pode
}
}

Temos aqui algo muito parecido com a versão anterior onde tínhamos os membros default. A diferença pode ser nota na classe Gato, que faz um acesso ao membro nome mesmo este sendo protected (deveria ser acessado por classes do mesmo pacote), porém membros protected são acessíveis por classes de outros pacotes através de herança. Já a classe Exercicio1 não compilará, pois está tentando fazer acesso a duas variáveis protegidas de classes de outros pacotes (Animal e Gato).
Então não esqueça:

• DEFAULT -> Permite acesso aos seus membros SOMENTE às classes do mesmo pacote.
• PROTECTED -> Permite acesso aos seus membros às classes do mesmo pacote e às classes de outros pacotes através de HERANÇA.

Até o nosso próxim post!

Declarando membros de classes - Parte 1

Olá javeiros de plantão! Vamos continuar o nosso estudo sobre a certificação SCJP da sun. Continuaremos estudando o objetivo 1 (Declaração, inicialização e escopo), ah por falar nisso, você pode clicar aqui para ver os objetivos da prova de SCJP 5.0. Agora iremos estudar os objetivos 1.3 e 1.4 que está relacionado com a criação de membros de classes. Vamos fazer uma rápida revisão de POO. Sabemos que uma classe é composta por um nome, atributos (propriedades) e métodos. As propriedades e métodos forma o que nós chamamos de membros de uma classe, é sobre como declarar esses membros que nós vamos aprender neste e em mais alguns posts daqui pra frente. Pronto, a revisão acabou por aqui! Eu falei pra você que era rápida né!?

Você lembra quando nós falamos sobre os modificadores de acesso a classes e sobre os níveis de acesso? (Eu não lembro) Membros também possuem níveis de acesso assim as classes. Porém, eles possuem os quatro níveis, diferente das classes que só usam dois. Os níveis são mostrados abaixo na ordem do mais restritivo para o menos restritivo:

private -> default -> protected -> public

Antes de explicarmos cada um deles, você precisa saber que a visibilidade desses membros vai depender inicialmente da visibilidade das classes (do nível de acesso das classes). Ou seja, se uma classe não consegue enxergar a outra, não importa que nível de acesso tenha seus membros, a classe não consiguirá acessar nenhum deles (ainda que sejam públicos). Isso pode dar um boa pegadinha na prova, então fique bem atento. Vamos estudar os membros o contrário do que está apresentado acima, ou seja, do public para o private. Vamos nessa então.

Membros Públicos (public)

Quando você define uma classe como public, qualquer outra classe do mundo vai enxergá-la. Quando você define um membro como public, qualquer classe que consiga acessar a sua classe vai enxergar o seu membro (pegou mal essa frase :) . Só tenho que te dizer mais uma coisa com relação aos membros públicos, é que eles sempre são herdados pelas classes que estenderem a sua. Já podemos então partir para um exemplo:

Animal.java
//Classe public diz que todos vão enxergá-la
public class Animal {
 //Membro (variável) public,
 //quem tiver uma instância de Animal
 //ou estendê-la, poderá acessá-lo
 public String nome;
}

Gato.java
// Esta classe ganhou por herança todos
// os membros public de Animal
public class Gato extends Animal {
   public String raça;
}

package javeiro;
Exercicio1.java
public class Exercicio1 {

   public static void main(String arg[]){
         Gato g = new Gato();
         //posso acessar o membro public herdado
         g.nome = "Garfield";
         //posso acessar o membro public de Gato
         g.raça = "preguiçoso";
   }
}

Muito fácil não é mesmo? A classe Exercicio1 está em um pacote de diferente de Animal e Gato, porém por estas serem públicas permite o acesso de qualquer lugar. Vimos também que temos livre acesso à variável nome, que foi herdada de Animal, e também à raça, que é um membro público de Gato. A gente vai ver depois que isso não é muito legal de fazer na vida real, mas para aprendizado serviu como uma luva.
Por enquanto é isso, no próximo post falaremos sobre membros protegidos (protected).
Até o próximo post então.

Declarando Interfaces

Saudações java a todos! Vamos continuar o nosso estudo para a certificação de programador java, agora com um assunto mais interessante: interfaces. Você já deve ter ouvido falar muito em interfaces né verdade? Provavelmente o termo: interface com o usuário. Bom, mas a interface que falaremos aqui é um pouco diferente, esta outra está relacionada normalmente com uma tela gráfica ou página web, a nossa tem a ver com herança e polimorfirsmo (vamos manter a sanidade).

Uma interface nada mais é que um contrato. Isso mesmo, não dá pra complicar, é simples mesmo. Um contrato possui clásulas que devem ser cumpridas por aqueles o assinaram. A diferença é que diferente dos contratos da vida real, os contratos das interfaces jamais poderão ser quebrados. Usando POO, uma interface define um comportamento que você deseja que determinadas classes tenham, por exemplo: Você possui um sistema de biblioteca, e você possui Objetos dos tipos Livro, Revistas, Cds, Dvds etc, mas estes objetos devem compartilhar uma característica como: poderem ser alugados. Como fazer isso usando o que há de melhor na POO? A resposta é: criando uma interface comum a todos esses objetos. Poderíamos ter uma interface nomeada como Alugavel, que deveria ser implementada por qualquer objeto da biblioteca que puder ser alugado. Aguente as pontas que em breve traremos um exemplo mais claro nesta seção.

As interfaces são simples porém poderosas. Quando bem utilizadas tornam o seu sistema muito mais claro e fácil de ser expandido. As interfaces, juntamente com as classes abstratas, permitem o uso do Polimorfismo, deixando o seu código claro e flexível.
Vimos que uma classe abstrata não pode ser instanciada e que todos os seus métodos abstratos deveriam ser implementados pela primeira classe concreta que a estendesse. Pois bem, uma interface é muito parecida com uma classe abstrata, com a diferença que a interface é totalmente abstrata, isso significa que você não poderá definir métodos concretos lá como numa classe abstrata. E não é só isso! Os contratos das interfaces são bem rígidos, vejamos algumas cláusulas deste contrato:

1. TODOS os métodos de uma interface SÃO públicos e abstratos. Eles já nascem assim. E não há nada que você possa fazer para mudar isso. Mesmo que você não coloque os modificadores public e abstract, para o compilador java é como se eles estivessem lá. Então os dois métodos abaixo são perfeitamente válidos em uma interface e fazem o mesmo efeito:
   
   • public abstract void executar();
   • void executar();
   
   
2. TODAS as variáveis de uma interface DEVEM ser públicas, estáticas e finais. Isso significa que uma interface só pode declarar constantes (e elas são bastante utilizadas para este fim).
3. Você NÃO pode declarar método final em uma interface, pois eles são abstratos por padrão (ponto 1). Um método de interface também NÃO pode ser: static, native, strictfp e nem syncchronized.
4. Interfaces PODEM fazer herança múltipla. Yes, man they can. Uma interface pode herdar de quantas outras interfaces ela quiser.
5. Uma interface NÃO pode implementar outra interface e nem pode estender de nada que não seja interface.
6. Você pode ou não utilizar o modificador abstract na declaração da interface. Já a palavra interface é obrigatória.
   

Esses cinco pontos são o que você precisa saber sobre interfaces. A seguir traremos alguns exemplos de uso das mesmas para fixarmos o conteúdo.

// abstract é opcional aqui
public abstract interface Alugavel {
//aqui é implicitamente public static final
int TEMPO_MAXIMO_ALUGUEL = 7; //É comum definirmos como constantes

 //aqui é implicitamente public abstract
 void alugar(); // não tem '{'
}

//utiliza a palavra implements para implementar a interface
public class Livro implements Alugavel {
 //precisa ser implementado e publico
 public void alugar() {
      //regras de negócio aqui
 }
}

Em uma outra oportunidade falaremos um pouco sobre o Polimorfismo. Por enquanto isso é tudo o que você precisa saber sobre interface para se dar bem na prova.

Até o próximo post.

Identificadores e Palavras Reservadas

Este tópico é bastante simples porém é fruto de muitas pegadinhas na hora da prova. E pode apostar que a prova vai estar cheia delas. Então para evitarmos perder questões bobas vamos aprender neste post como declarar identificadores, que nada mais são que os nomes de nossas variáveis, métodos e classes.
As regras de nomenclatura dos identificadores em java são muito parecidas com as de outras linguagens como delphi, c, c++ etc. Antes de listarmos as regras é preciso saber que o java utiliza a codificação Unicode para os arquivos de código fonte. As regras são as seguintes:

• Os identificadores DEVEM começar com uma letra, um cifrão ($) ou com um underscore (_).
• Após o primeiro caractere pode ser usado qualquer outro caractere do conjunto Unicode.
• NÃO se pode usar uma palavra reservada (vamos já saber o que é isso) como identificador.
• Em java, os identificadores são case sensitive. Então você pode definir gato e Gato como duas coisas diferentes;

Para fixar os conceitos, abaixo está uma lista contendo identificadores válidos:

• int _var;
• double ist0_é_válido; //não recomendo, mas é válido
  
• float R$100; //legal né? :)
• int ________________Legal;
  

Palavras reservadas da linguagem Java:

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

*		Não utilizada
**		Adicionada em 1.2
***		Adicionada 1.4
****		Adicionada 5.0

Ao todo são 50 palavras reservadas. A má notícia é que você terá que saber todas elas, então utilize a sua técnica de memorização preferida e boa sorte... Mas você verá que não é tão difícil assim quanto parece. Especialmente se você já trabalha com java ou está sendo obrigado a fazer isso (faculdade por exemplo). Para ajudar você a memorizar vamos fazer uma pequena divisão:
De quebra já devemos saber os tipos primitivos, são 8:

• boolean, byte, char, double, float, int, long, short.

Utilizadas em definição de classes e métodos, são 15:

• abstract, class, enum, final, interface, native, private, protected, public, static, strictfp, synchronized, transient, void, volatile.

Utilizadas em laços e retornos de métodos, são 9:

• break, case, continue, default, do, for, return, switch, while.

Utilizadas em tratamentos de exceção, são 5:

• catch, finally, throw, throws, try.

Estruturas condicionais e verificações, são 3:

• if, else, instanceof.

Usadas em herança, são 2:

• extends, super.

Importação e definição de pacote, são 2:

• import, package.
  

NÃO SÃO UTILIZADAS, são 2:

• goto, const.

Adicionadas recentemente, são 2:

• assert, enum;

Criação de objetos e acesso à classe executando, são 2:

• new, this.

Não fiquei muito preocupado pois você verá essas palavras tantas vezes que talvez nunca mais consiga esquecê-las.
Até o nosso próximo post.

Declarar Classes - Parte 3

No post anterior vimos que uma classe pode ter dois níveis de acesso: publico e padrão. Para dar à classe acesso publico, utilizamos o modificador public, para o padrão basta não colocar nada. Além dos modificadores de acesso à classe, o java possui outros modificadores que também podem ser aplicados a classes, mas que não estão relacionados ao acesso a estas. Os modificadores são:

• strictfp
• final
• abstract

O modificador strictfp pode ser utilizado tanto em classes quanto em métodos. Você não precisa saber muita coisa sobre ele, mas se quiser saber um pouquinho mais é só clicar aqui. Na realidade o que você precisa saber mesmo é que ele pode ser usado na declaração de um método ou de uma classe, seja ela final ou abstract.

Bem, já que tocamos no assunto, o modificador final pode ser utilizado para declara um método, propriedade (variável) ou uma classe. O modificador final quando usado em uma classe faz com esta não possa mais ser extendida, ou seja, a sua hierarquia chegou ao final (essa foi podre). Mas será que alguém pode querer que uma classe não possa ser extendida? Claro que sim. Inclusive a Sun pensa assim. A classe String é uma classe final, ou seja, você não pode herdar jamais de String. Isso pode ser escolhido também por uma questão de segurança ou qualquer coisa que o valha.

Para finalizar temos o modificador abstract. Ele pode ser utilizado em classes e em métodos. Vale lembrar que se uma classe tiver pelo menos um misero método abstrato esta classe deverá ser abstrata, porém uma classe pode ser abstrata e não ter nenhum método abstrato... Agora embolou tudo né?. Bem, primeiro precisamos saber o que é uma classe abstrata. Uma classe abstrata (abstract) é uma classe que não pode ser instanciada, ou seja, se você quiser usar uma algum dia desses, a única forma de fazê-lo será estendendo-a.

Quando você herdar de uma classe abstrata você terá a obrigação de implementar todos os métodos abstratos da mesma, a menos, é claro, que a sua classe também seja abstrata. O fato é que um dia alguém vai fazer uma classe concreta e ela vai ter que definir todos, eu disse, todos os métodos abstratos não implementados de toda a árvore de herança... eu não faria isso se fosse você! E se os meus métodos forem todos concretos? Aí você ganhará um monte de método por herança, legal né?

Você pode combinar os modificadores a vontado... quer dizer, quase né. Os modificadores final e abstract nunca poderão ser combinados, pois isso causará uma crise de existência no compilador java. Uma classe final não pode ser nunca extendida e uma classe abstract deve ser obrigatoriamente extendida... entendeu por que não dá pra combinar né? Ah, o strictfp pode ser usado tanto em classes finais como em abstratas.
Agora para fixar os conceitos vamos trazer alguns exemplos do que vimos até aqui.

Animal.java
//posso combinar strictfp e abstract
//Essa classe deverá ser herdada por alguém
public strictfp abstract class Animal {
 
 //Esse método precisa ser implementado 
 //em alguma subclasse concreta
 public abstract void emitirSom();
 
 //Esse método será herdado por todas as subclasses
 public strictfp void contarAteDez() {
  for (int i = 0; i < 10; i++) {
   System.out.println(i);
  }
 }
}

Dog.java
// Esta classe não poderá ser herdada por ninguém mais
public final strictfp class Dog extends Animal {

 //Implementou o método abstrato, ou sobrescreveu.
 @Override
 public void emitirSom() {
  System.out.println("Auf auf"); 
  contarAteDez(); //posso chamar o método herdado aqui também
 } 

}

ViraLata.java
//ViraLata não pode herdar de Dog
//pois Dog é uma classe final
public class ViraLata extends Dog {

}

A classe Animal é uma classe abstrata e faz uso também do modificador strictfp. Essa classe possui um método abstrato que deverá obrigatoriamente ser implementado por uma subclasse concreta e possui um método concreto que será herdado por todas as subclasses. A classe Dog estende a classe Animal e implementa o seu método abstrato emitirSom, podemos ver que ela chama o método contarAteDez que foi herdado de Animal, ou seja, o nosso cachorro herdou a capacidade de contar até dez do animal. E por fim a classe ViraLata tenta sem sucesso estender a classe Dog que é uma classe final e não pode ser estendida nem sob a mira de uma arma.

No próximo post vamos aprender a nomear nossas classes e vamos trazer também a lista de palavras reservadas da linguagem java. Até lá.

Declarar Classes - Parte 2

Continuando nosso estudo, iremos agora trazer a segunda parte do objetivo 1.1 que são os modificadores de acesso a classe do java.

O java possui quatro níveis de acesso, porém somente três modificadores de acesso.Parece esquisito mas é isso mesmo. Os modificadores são:

• public
• protected
• private

A vida de um programador java é escrever classes. Mas acontece que essas classe precisam interagir com outras classes (de outros programadores, inclusive os da sun :)). E para que haja essa interação é necessário que a classe que você escreveu tenha 'acesso' às classes dos outros seres. E são os modificadores de acesso que vão definir quem pode acessar sua classe. Acredito que não exista nada mais óbvio do que isso, mas vamos continuar. O java possui dois níveis de acesso à classes: default e public. Peraí, mas você não disse que o java tinha quatro níveis de acesso? É verdade, mas falando em acesso a classe, só podemos utilizar dois deles. Nas próximas seções falaremos sobre os outros modificadores. Então a coisa fica assim:

• Se você escreveu uma classe public, qualquer classe do mundo terá acesso a ela. E quando eu falo de acesso, é no sentido de poder criar uma instância ou um objeto da mesma.
• Se você escreveu uma classe e NÃO colocou o modificador public nela, então, somente as classes que estivem dentro do mesmo pacote que ela poderão acessá-la. Ou seja, qualquer classe fora do seu pacote nem mesmo saberá que a sua classe existe.

Vamos colocar um pequeno exemplos para firmar o objetivo melhor:

Animal.java
package javeiro;

class Animal {

}

Cat.java
package zoo;

import javeiro.Animal;

class Cat extends Animal{

}

Temos um problema aí. A classe Animal está definida como default e está dentro do pacote javeiro. Isso torna a classe invisívei para qualquer classe fora do pacote javeiro. Assim, a classe Cat terá uma bela surpresa quando tentar herdar da classe animal, o compilador java vai dizer pra ela: Ei Cat, eu não sei que Animal é esse... bem na verdade isso foi uma transliteração do erro: zoo\Cat.java:4: cannot find symbol, mas dá no mesmo. O ponto aqui é que Cat não enxerga Animal, pois o acesso default garante que só as classes dentro de javeiro poderão enxergar Animal.

Não vou colocar o exemplo da classe public porque é óbvio demais. Se você escreveu uma classe e definiu o acesso dela como public, então não adianta chorar, todo mundo vai enxergar sua classe, não importa onde ela ou eles estejam.

Até o próximo post.

Declarar Classes - Parte 1

Vamos dar início ao estudos dos objetivos da prova de programador a partir deste post. O nosso foco será a prova de programador SCJP 5.0, o código é 310-055, mas sempre que for possível falaremos um pouco da prova 6.0, cujo o código é 310-065. Quem quiser outra fonte de estudos, aconselho o livro mundialmente recomendado da Kathy Sierra e há também uma série de guias da Revista Mundo Java que ajudam bastante, especialmente para momentos antes da prova.

Bom mas vamos deixar de lenga lenga e começar a estudar de verdade.

Um bom programador java precisa saber escrever corretamente uma classe. Existem algumas regrinhas básicas que precisamos saber antes de começarmos a programar feito loucos, e elas são:

• Em um arquivo .java só pode haver uma classe pública (public class).


• Comentários podem ser colocados em qualquer linha


• o nome do arquivo deve ser o mesmo da classe pública dele, se não tiver nenhuma, então pode ser qualquer nome :)


• Se a classe estiver em um pacote (package), a declaração do mesmo deve ser a primeria do arquivo (comentário não conta viu)


• os imports, se existirem claro, devem vir logo após a declaração de pacote, e se não houver uma, deve vir em primeiro lugar no arquivo.

Abaixo temos um exemplo do que falamos acima, o arquivo foi nomeado como MyClass.java:

//aqui pode ter comentário sem problema
package javeiro; //declaração de pacote em primeiro lugar
import java.util.Date; // declaração de import

public class MyClass {

  public static void main(String args[]) {
       Date d = new Date();
       System.out.println(d);
  }
}

// posso ter zilhões de classe não públicas em um arquivo
class MyOtherClass {

}

class MyAnotherClass {

}

Algumas informações sobre a prova

Antes de começarmos a estudar os objetivos da prova de certificação, vou trazer algumas informações sobre a prova, para que não sejamos surpreendidos no dia do teste. Pra começar, a sun disponibiliza atualmente a opção de 3 provas de SCJP, e claro, seus respectivos updgrades para aqueles que já fizeram a prova e desejam apenas se atualizar. As opções são:

• SCJP 1.4 e Upgrade


• SCJP 5.0 e Upgrade


• SCJP 6.0 e Upgrade

A primeira, 1.4, é composta de 61 questões e você disporá de 120 minutos para respondê-las e terá que acertar no mínimo 32 questões (52% da prova), se nos fizermos um cálculo do tempo/questão você tem em média 1m:58s para responder cada questão, parece pouco né, mas reza a lenda que dá tempo de sobra.

A segunda é composta de 72 questões e o tempo agora é de 175 minutos e você precisa acertar 43 questões (59% da prova). Agora você tem 2m:25s para cada questão. A sun engrossou o caldo no número de acertos mas em compensação o tempo para cada questão agora é maior.

A última, na verdade a mais atual, é a bola da vez, é o que há de mais moderno e logicamente nosso conselho é que você faça ela, a menos claro, que você já tenha comprado o voucher e marcado a prova :( eu \o/. E se você achou que sun foi cruel ao aumentar o percentual de acertos da prova 5.0, então sente-se pois a coisa ficou ainda pior. A prova do Mustang (esse o nome do java 6.0, vc não sabia?) é composta também de 72 questões só que agora você terá que acertar 47 questões, isso equivale a 65% da prova. Peraí, mas a sun não tão é cruel como você está pensando, olha só que mamada ela deu: você tem agora 210 minutos para terminar sua provinha, o que dá mais ou menos 2m:55s por questão. Bom, não quero ser estraga prazeres mas dizem as más línguas que a prova ficou mais difícil agora... mas com a ajuda do javeiro você poderá chegar lá.

Já ia me esquecendo do detalhe polêmico: A língua da prova. Polêmico porque a prova é disponibilizada para nós ocidentais em inglês, alemão, espanhol e português. Mas acontece que todo mundo manda você fazer a prova em inglês, por questões que não nos cabe discutir neste momento. Mas fique a vontande para 'arriscar' escolher outra língua.

Se o que nós falamos neste post não foi suficiente para você, visite esse site para obter mais informações sobre as provas.

No mais eu só posso desejar bons estudos e boa sorte para todos nós.

Até o nosso próximo post.

Estamos de volta

Após um período de inatividade, em virtude do nascimente do meu filho Mateus, retornamos agora com a bola toda. Irei trazer a partir de agora posts sobre Java, mais especificamente sobre o conteúdo da prova de certificação de programador (SCJP). Então segura aí que logo logo estarei postando os primeiros artigos. Então até o próximo post!