Afinal, o porquê das mudanças no Java 8 ?

Olá Pessoal,

    O Java 8 acabou de sair e já está causando uma revolução na maneira java de programar, com algumas mudanças focadas no estilo das linguagens funcionais, ele promete acelerar a produtividade, no estilo “escreva pouco e faça muito”. Em função das novidades trazidas, resolvi escrever este post para anunciar uma série de outros posts que devo fazer em torno destas melhorias, sempre citando, é claro, outras referencias encontradas na internet ou o próprio site da Oracle.
    Antes de começar de fato a falar sobre o porque o Java 8 trouxe essas melhorias, é legal comentar um pouco sobre o estilo java de programar, pois bem, todos sabem que já fazia algum tempo que a linguagem java não passava por melhorias significativas em sua sintaxe, isso se deve é claro a decisões de projeto da própria Oracle, focadas principalmente nos seus clientes e na compatibilidade com código já existente. Acredito que as mudanças do Java 8 trazem  aquele mesmo espirito renovador que ocorreu na versão 5, na qual foram incluídas melhorias significativas, tais como: Generics, Wrappers, Enum e etc. 
   Um fato inegável na área da computação é a constante evolução das técnicas e ferramentas de programação, afinal, o que não evolui acaba ficando na gaveta do esquecimento, por exemplo, quantos programadores COBOL você conhece ? Aposto que são poucos não é mesmo ?
     Nos últimos anos vimos diversas tendencias nesse campo e uma delas foi o surgimento de inúmeras linguagens funcionais, tais como: Closure, Scala, Scheme e tantas outras. O que fazia com que programadores destas linguagens olhassem torto para o jeito java de programar, afinal, até antes do Java 8, a linguagem era predominantemente imperativa
        A grande diferença está na maneira de pensar e no código fonte gerado, uma coisa que fica nítido pra quem trabalha com linguagens funcionais, é que pensar em funções ao invés de métodos, traz vantagens significativas em termos de código fonte gerado. 
        Observe as diferenças entre um código fonte Java(Imperativo) pra um código fonte Clojure(Funcional) :
    // Isto é um código Java.
    public class PigLatin {

public static String pigLatin(String word) {
 
           char firstLetter = word.charAt(0);
 
           if ("aeiou".indexOf(firstLetter) != -1)
               return word + "ay";
           return word.substring(1) + firstLetter + "ay";
}

public static void main(String args[]) {
System.out.println(pigLatin("red"));
System.out.println(pigLatin("orange"));
}
}
         ———————————–
   
    ; Isto é o mesmo código, só que em Clojure.
    (def vowel? (set "aeiou"))

(defn pig-latin [word]
(let [first-letter (first word)]
(if (vowel? first-letter)
(str word "ay")
(str (subs word 1) first-letter "ay"))))

(println (pig-latin "red")) ;Utiliza a função pig-latin
(println (pig-latin "orange")) ; --//--
        Observe no segundo código, o uso da palavra defn  para definição da função pig-latin e o uso da mesma no fim do código, primeiramente passando “red” e depois “orange”,  podemos notar que somando todas linhas, o código fonte Clojure é bem menor, apesar de mais complexo, será ?
            Estou preparando uma série de posts envolvendo as novidades do Java 8, mas de um ponto de vista prático, em breve eu volto para falar sobre :
             
            – Expressões Lambdas;
            – Métodos Default;
            – Operações Agregadas;
            – Nova API de Data(Date-Time);
            – Tipos de anotações;

Abrcs,
Natanael Fonseca

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s