/* CODIFICANDO */

Passeando pelos links que o feed do DZone me entrega diariamente, acabei de encontrar esse post. Ele fala um pouco sobre a proposta da JSR 308, especificação que visa possibilitar a associação de annotations a atributos de métodos, parâmetros de tipo utilizados nas declarações com generics, entre outras aberrações. Assim, você poderia escrever código como:

List<@NotNull String> lista = new ArrayList<@NotNull String>();

ou ainda

public @UmaAnotacao String umMetodo(@OutraAnotacao String atributo) { //... }

Bizarro não?

A idéia aqui é fazer com que o compilador seja responsável por análisar alguns aspectos do nosso código e prevenir erros. Assim, alguns casos onde a ocorrência de um NullPointerException for possível, por exemplo, poderiam ser automaticamente indicados pelo compilador.
Minha pergunta é: Se o cara não sabe o que está fazendo então a responsabilidade é sempre do compilador? E o preço para isso, uma sintaxe excessivamente verbosa, complexa e insuportável de se escrever é um preço justo?
Java trouxe algumas facilidades para o programador, como garbage collection, que livra o programador de tentar se lembra (porque frequentemente se esquece) de liberar recursos alocados dinamicamente pelo programa. Isso foi algo útil (mas hoje em dia implementado por várias outras linguagens), pois aumentou a agilidade com que as aplicações poderiam ser escritas. Agora, sinceramente… Essa especificação visa fabricar macacos de código que sejam muito bons em digitação e não necessariamente muito bons em raciocínio.
Por isso que eu estou cada vez mais inclinado a usar Ruby, Python, Javascript e tudo o mais para qualquer projeto novo que começo hoje em dia… Quero me concentrar na solução dos problemas, não ficar digitando e deixando que o compilador seja minha babá.

Escrevi um pequeno artigo demonstrando uma possível integração entre o framework web Mentawai e o framework para Ajax DWR.
Este artigo está no site do Mentawai e pode ser acessado por aqui e o código fonte pode ser baixado aqui.

Quaisquer dúvidas, entrem em contato :-)

Estava eu aqui feliz da vida programando quando precisei criar uma cópia idêntica de um objeto. Pensei: “Ah, existe aquele método bacana, clone(). Nunca usei, mas deve ser simples!”.

Resultado: Me ferrei. Realmente nem tudo é o que parece ser. O que eu imaginei é que esse método de alguma forma serializasse o objeto em memória, alocasse n bytes em outro endereço e fizesse flush dos bytes serializados dentro da área recém-alocada. Voilá, tenho uma cópia e um referência para a mesma! Ah, se tudo fosse tão bonito…

Veja abaixo um exemplo de porque clone() não funciona como qualquer desavisado imaginaria: (atencão puristas OO, isso é apenas um exemplo!):

public class CloneDaProblema{
   public static void main(String[] args){
      int[][] matrizOriginal = new int[2][2];

      for(int i = 0; i < 2; i++)
         for(int j = 0; j < 2; j++)
            matrizOriginal[i][j] = i + j;

      int[][] matrizClonada = matrizOriginal.clone();

      System.out.println("Conteudo da matriz original:");
      imprime(matrizOriginal);
      System.out.println("Conteudo da matriz clonada:");
      imprime(matrizClonada);

      System.out.println("nAlterando valor do elemento [0][0]...");
      matrizClonada[0][0] = 3;      

      System.out.println("nConteudo da matriz original:");
      imprime(matrizOriginal);
      System.out.println("Conteudo da matriz clonada:");
      imprime(matrizClonada);
   }

   public static void imprime(int[][] m){
      for(int i = 0; i < m.length; i++){
         for(int j = 0; j < m[0].length; j++)
            System.out.print(m[i][j] + " ");
         System.out.println();
      }
   }
}

A saída deste programinha é:

Conteudo da matriz original:
0 1
1 2
Conteudo da matriz clonada:
0 1
1 2

Alterando valor do elemento [0][0]...

Conteudo da matriz original:
3 1
1 2
Conteudo da matriz clonada:
3 1
1 2

Perceberam que eu alterei somente o elemento [0][0] da matriz clonada, mas quando imprimi as duas, ambas estavam com este elemento igual a 3? Pois é… O que acontece é que o clone() não cria uma nova instância dos objetos que são atributos do objeto que você está clonando. Ele copia somente tipos primitivos. Os não primitivos apenas ganham uma nova referência apontando para eles. Se alguém souber porque isso foi implementado desta forma, por favor me avise!
Como uma matriz na verdade é um array de arrays, e em Java cada um destes arrays é um objeto, as linhas da matriz não sao clonadas. As referências para estas linhas, tanto na matriz original quanto na matriz clonada apontam para o mesmo lugar!

A solucao é implementar a interface Cloneable, que tem o método clone() (!!). Ali você explica como deve ser feita a clonagem. Crie novas instâncias de TUDO que não for tipo primitivo e defina seus respectivos estados como achar melhor.
E eu que perdi um dia inteiro sem entender porque meu programa estava doido…