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!