quinta-feira, 22 de dezembro de 2016

[JAVA] Anotação @Override


Fala galera que acompanha o blog...

Resolvi criar esse post especificamente sobre a Annotation @Override, pois é uma anotação muito comum quando estamos trabalhando com Orientação a Objetos e muita gente usa sem saber o porque de estar usando. Normalmente depois de uma refatoração o sistema para de funcionar, as vezes com umas mensagens estranhas. Então vamos entender o que acontece "por baixo dos panos".



Para início de conversa, a anotação @Override é uma forma de garantir que você está sobre escrevendo um método na super classe, e não criando um novo método.

Vamos ter como exemplo essa "Super" classe: 

public class SuperClasse {
    public void showMe() {
      System.out.println("Estou aqui SuperClasse");
    }
}

Certo, temos a nossa classe SuperClasse, que possui o método showMe(), que escreve uma mensagem no console.

Criamos uma nova classe (NovaClasse) no nosso projeto que estende a classe SuperClasse, e você gostaria de sobrescrever o método showMe(), pois é necessário que seja apresentado uma outra mensagem.  Então temos a seguinte classe:

public class NovaClasse extends SuperClasse {
       public void showMe() {
           System.out.println("Eu sou a NovaClasse");
       }
}

Perfeito! Acabamos de sobrescrever o método showMe(), da nossa SuperClasse e em momento algum usamos a anotação @Override e esse código funciona perfeitamente. Mas,  um amigo no projeto que você trabalha resolveu mudar o nome do método da sua classe SuperClasse de showMe() para showMessage().

E ai, percebeu o problema?

Nesse momento o seu projeto possui 2 métodos distintos:
SuperClasse possui o método showMessage();
NovaClasse possui o método showMe();

Se seu amigo, ou até mesmo você em uma fatoração, que seja, não se lembrar da sua classe NovaClasse que estendeu SuperClasse, que sobrescrevia um método dela... você terá um método que não está sobrescrevendo coisa nenhuma!

Mas, e se você tivesse usado a anotação @Override?

public class SuperClasse {
    public void showMe() {
       System.out.println("Estou aqui SuperClasse");
    }
}

public class NovaClasse extends SuperClasse {

  @Override
  public void showMe() {
     System.out.println("Eu sou a NovaClasse");
  }

}


Até aqui tudo certo. Mas, quando seu amigo, ou você, resolver mudar o seu método de showMe() para showMessage(), o seu código não irá compilar, pois o @Override vai perceber que não está sobrescrevendo coisa nenhuma, por não vai existir um método showMe() na classe SuperClasse() e vai te mostrar uma mensagem com de erro:

NovaClasse() must override or implement a supertype method


Dessa forma deverá ser alterar o nome do método da classe NovaClasse() também para showMessage(), para que o código volte a funcionar perfeitamente. Assim, o @Override acaba servindo como um lembrete.

Bom pessoal, um post básico, mas muito importante pra quem trabalha com Orientação a Objetos, esse exemplo foi para a linguagem JAVA, mas vários outras linguagens OO possuem a sua forma de anotação de sobrescrita, especificamente o JAVA, optou por @Override.

Até a próxima.

segunda-feira, 12 de dezembro de 2016

[Debug] Reordenar um elemento dentro do Array com AngularJS


Fala galera que acompanha o blog... 

Esse post mesmo sendo voltado para AngularJS, adaptado pode ser utilizado para várias outras linguagens. 



O problema era o seguinte, ao implementar um chat, tenha em mente o WhatsApp, ao receber uma nova mensagem a sua lista de conversas são reordenadas, com esse contato que te mandou uma nova mensagem ficando no topo da lista de conversas. 

Quando estou trabalhando com AngularJS costumo utilizar a biblioteca Lodash, que facilita bastante o trabalho. 

Bom a solução para o problema mencionado foi o seguinte: 

$scope.setGroup = function(group) {

        moveElementArray($scope.chatList, _.indexOf($scope.chatList, group), 0);

 }; 


function moveElementArray(arrRef, fromIndex, toIndex) {

        var element = arrRef[fromIndex];

        arrRef.splice(fromIndex, 1);

        arrRef.splice(toIndex, 0, element);

 }

Onde: 
  • setGroup() é o método que eu chamo da minha página enviando group como parâmetro; 
  • group é o parâmetro (um Objeto) que representa uma conversa dentro da minha lista de conversas; 
moveElementArray() é uma função que recebe 3 parâmetros: 

  • lista de conversas; 
  • O index do meu objeto atualmente dentro da lista de conversas; 
  • 0 que é a primeira posição de um array. 

Dessa forma eu recupero o meu objeto dentro o array e reposiciono ele na primeira posição. Importante deixar claro que o trecho _.indexOf($scope.chatList, group), é a biblioteca Lodash me auxiliando, se você olhar a documentação vai ver que é possível realizar busca binária adicionando mais um parâmetro nessa função.  

Eu tentei deixar mais genérica possível a função moveElementArray para que eu possa utilizar diversas vezes de qualquer parte do meu código e resolvi compartilhar essa função simples, pois trabalhar com array é bastante comum e vai acabar me servindo de "cola" para outros projetos em que estiver trabalhando rs 

É isso ai pessoal, até a próxima!

sexta-feira, 9 de dezembro de 2016

[Debug] Remover acentos utilizando Normalize


Fala galera que acompanha o blog...

Estava criando uma classe de utilitários, que logo pretendo disponibilizar aqui no blog, e acabei encontrando uma forma muito elegante de remover acentos de uma string utilizando o Normalize.




Se você pesquisar algo como "como remover acentos de uma string", vai perceber que existem diversas formas de faze-lo, usando arrays, mapa de caracteres, usando a biblioteca Apache Commons Lang, replaceAll com regex, indexOf() e várias outras formas. No entanto a classe Normalize, foi a que me chamou mais atenção, veja o código abaixo:

package com.devic.main;
import java.text.Normalizer;
public class Main {

 public static void main(String[] args) {
 String entrada = "çÇáéíóúýÁÉÍÓÚÝàèìòùÀÈÌÒÙãõñäëïöüÿÄËÏÖÜÃÕÑâêîôûÂÊÎÔÛ";
 System.out.println(Normalizer.normalize(entrada, Normalizer.Form.NFKD).replaceAll("\\p{InCombiningDiacriticalMarks}+", ""));
 }
}

Saida:

cCaeiouyAEIOUYaeiouAEIOUaonaeiouyAEIOUAONaeiouAEIOU

Bonito, não?

Esse trecho de código possui duas etapas:

  • Normalizar a nossa string seguindo o tipo de normalização enviado como parâmetro;
  • Realizar o replace de todos os caracteres normalizados para a sua forma normal.
Vamos ver outro código para entender melhor o que está acontecendo:

String entrada = "aáeéiíoóöőuúüű AÁEÉIÍOÓÖŐUÚÜŰ";
for (int i = 0; i < entrada.length(); i++) {
 
  // nos iremos escrever cada caracter separado, para visualizar melhor como ele funciona
  String texto = original.substring(i, i + 1);
 
  // realizando a normalização
  String decomposto = Normalizer.normalize(texto, Form.NFD);
  // removing diacritics
  String removido = decomposto.replaceAll("\\p{InCombiningDiacriticalMarks}+", "");

 System.out.println(texto + " (" + asHex(texto) + ") -> "
 + decomposto + " (" + asHex(decomposto) + ") -> "
 + removido + " (" + asHex(removido) + ")");
}


E a saída, ficará assim:

a (0061     ) -> a (0061     ) -> a (0061     )

á (00e1     ) -> á (0061 0301) -> a (0061     )

e (0065     ) -> e (0065     ) -> e (0065     )

é (00e9     ) -> é (0065 0301) -> e (0065     )

i (0069     ) -> i (0069     ) -> i (0069     )

í (00ed     ) -> í (0069 0301) -> i (0069     )

o (006f     ) -> o (006f     ) -> o (006f     )

ó (00f3     ) -> ó (006f 0301) -> o (006f     )

ö (00f6     ) -> ö (006f 0308) -> o (006f     )

ő (0151     ) -> ő (006f 030b) -> o (006f     )

u (0075     ) -> u (0075     ) -> u (0075     )

ú (00fa     ) -> ú (0075 0301) -> u (0075     )

ü (00fc     ) -> ü (0075 0308) -> u (0075     )

ű (0171     ) -> ű (0075 030b) -> u (0075     )

  (0020     ) ->   (0020     ) ->   (0020     )

A (0041     ) -> A (0041     ) -> A (0041     )

Á (00c1     ) -> Á (0041 0301) -> A (0041     )

E (0045     ) -> E (0045     ) -> E (0045     )

É (00c9     ) -> É (0045 0301) -> E (0045     )

I (0049     ) -> I (0049     ) -> I (0049     )

Í (00cd     ) -> Í (0049 0301) -> I (0049     )

O (004f     ) -> O (004f     ) -> O (004f     )

Ó (00d3     ) -> Ó (004f 0301) -> O (004f     )

Ö (00d6     ) -> Ö (004f 0308) -> O (004f     )

Ő (0150     ) -> Ő (004f 030b) -> O (004f     )

U (0055     ) -> U (0055     ) -> U (0055     )

Ú (00da     ) -> Ú (0055 0301) -> U (0055     )

Ü (00dc     ) -> Ü (0055 0308) -> U (0055     )

Ű (0170     ) -> Ű (0055 030b) -> U (0055     )


É isso ai pessoal, espero que tenham gostado e que seja bastante útil ai no projeto de vocês.

Até a próxima!