E ai galera do Java, tranquilo?

Hoje vamos tratar de algo que é super simples, mas de extrema importância no mundo java…. Os tão famosos javadoc.

O que são javadoc?

Javadoc é aquela documentação que utilizamos em cima de classes, métodos e atributos e servem para identificar sua funcionalidade. Para ficar mais claro, vamos ver um exemplo de código:

package javaapplication1;

public class Calcular {
    private Double valor1;
    private Double valor2;

    public Double somar(Double valor1, Double valor2){
        Double calculo = 0.0;
        calculo = valor1 + valor2;
        return calculo;

    }
    public Double subtrair(Double valor1, Double valor2){
        Double calculo = 0.0;
        calculo = valor1 - valor2;
        return calculo;

    }
    public Double multiplicar(Double valor1, Double valor2){
        Double calculo = 0.0;
        calculo = valor1 * valor2;
        return calculo;

    }
    public Double dividir(Double valor1, Double valor2){
        Double calculo = 0.0;
        if (valor2 != 0){
            calculo = valor1 / valor2;
        }
        else {
            System.out.println("ERRO! Divisão por 0!");
        }


        return calculo;
    }

    public Double calcularComplexo(Double valor1, Double valor2){
      Double calculo = 0.0;  
        // faz calculos que apenas de pensar dai a nossa cabeça
        return calculo;
    }

    public Double getValor1() {
        return valor1;
    }

    public void setValor1(Double valor1) {
        this.valor1 = valor1;
    }

    public Double getValor2() {
        return valor2;
    }

    public void setValor2(Double valor2) {
        this.valor2 = valor2;
    }    
}

Ok, o exemplo de código é bem simples e parece não precisar de nenhum tipo de explicação, certo? Temos ai o nossas variáveis de classe, seus gets e sets e alguns métodos, todos simples fazendo a soma, subtração, divisão, multiplicação e ….. calcularComplexo? O que esse método faz? Quais são esses números? O que ele retorna? Se você for o programador do método irá saber o que ele faz, mas se você for o utilizador do método e não tiver acesso ao código fonte? Ou pior, tem acesso ao código, mas não consegue entender o que ele faz? Para ter uma ideia do que cada método faz terá que ir testando eles como abaixo.

package javaapplication1;

public class JavaApplication1 {

    public static void main(String[] args) {
     Calcular calc = new Calcular();

        System.out.println("Divisão: " + calc.dividir(5.0, 12.0));
        System.out.println("Multiplicação: " + calc.multiplicar(23.0, 2.0));
        System.out.println("Subtração: " + calc.subtrair(2.0, 3.0));
        System.out.println("adição: " + calc.somar(7.0, 6.0));
        System.out.println("Calculo complexos: " + calc.calcularComplexo(1.0, 6.0));

    }

}

Vamos ser sinceros, é inaceitável ter que criar um novo projeto para entender os métodos.

Bom, esse código é uma brincadeira, mas é uma realidade do mercado do desenvolvimento onde muitos programadores não documentam o código devido a pressão dos prazos ou por pura preguiça. Hoje o mercado de desenvolvimento possui diversas ferramentas para avaliar a qualidade de código e entre as análises está a cobertura de documentação no código o que significa que documentar o código (inserir javadocs) é uma boa prática de desenvolvimento.

Agora vamos ver o código documentado com os javadoc.

package javaapplication1;

/**
 *Classe especialista na realização de calculos de matemática.
 * @author aricesar
 */
public class Calcular {


    private Double valor1;
    private Double valor2;

    /**
     * Método que executa a soma de dois valores sejam eles positivos ou negativos.
     * 
     * @param valor1 - > valor Double
     * @param valor2 - > valor Double
     * @return valor calculado (tipo Double)
     */
    public Double somar(Double valor1, Double valor2){
        Double calculo = 0.0;
        calculo = valor1 + valor2;
        return calculo;
    }


    /**
     * Método que executa a subtração de dois valores sejam eles positivos ou negativos.
     * @param valor1 - > valor Double
     * @param valor2 - > valor Double
     * @return valor calculado (tipo Double)
     */
    public Double subtrair(Double valor1, Double valor2){
        Double calculo = 0.0;
        calculo = valor1 - valor2;
        return calculo;
    }

    /**
     * Método que executa a multiplicação de dois valores sejam eles positivos ou negativos.
     * @param valor1 - > valor Double
     * @param valor2 - > valor Double
     * @return valor calculado (tipo Double)
     */
    public Double multiplicar(Double valor1, Double valor2){
        Double calculo = 0.0;
        calculo = valor1 * valor2;
        return calculo;

    }

    /**
     * Método que executa a divisão de dois valores sejam eles positivos ou negativos. 
     * Impede o erro de divisão por zero.
     * @param valor1 - > valor Double
     * @param valor2 - > valor Double ( não pode ser zero)
     * @return valor calculado (tipo Double)
     */
    public Double dividir(Double valor1, Double valor2){
        Double calculo = 0.0;
        if (valor2 != 0){
            calculo = valor1 / valor2;
        }
        else {
            System.out.println("ERRO! Divisão por 0!");
        }


        return calculo;
    }

    /**
     * Executa calculos complexos subtraindo, dividindo, multiplicando e somando os valores passados por parametro. Pode retornar qualquer valor.
     * 
     * @param valor1 - > valor Double
     * @param valor2 - > valor Double
     * @return valor calculado (tipo Double)
     */
    public Double calcularComplexo(Double valor1, Double valor2){
      Double calculo = 0.0;  
      // faz calculos que apenas de pensar dai a nossa cabeça
        return calculo;
    }

    /**
     * Getter do valor 1
     * @return valor 1
     */
    public Double getValor1() {
        return valor1;
    }

    /**
     * Setter do valor 1
     * @param valor1 
     */
    public void setValor1(Double valor1) {
        this.valor1 = valor1;
    }

    /**
     * Getter do valor 2
     * @return valor 2
     */
    public Double getValor2() {
        return valor2;
    }

    /**
     * Setter do valor 2
     * @param valor2
     */
    public void setValor2(Double valor2) {
        this.valor2 = valor2;
    }

}

Melhorou? Agora quando alguém for utilizar o código da classe Calcular os comentários serão apresentados e o programador saberá o que faz cada um dos métodos.

Quer ver funcionando? Crie um projeto, crie uma classe chamada Calcular e copie esse último código que possui os comentários. Depois crie uma nova classe e copie o código abaixo para dentro dela.

    public static void main(String[] args) {
     Calcular calc = new Calcular();

    }

Depois disso, faça o import necessário para funcionar a classe Calcula e escreva calc. (se precisar use CTRL+ para ativar o autocomplete). Escolha algum dos métodos da classe Calcular e verá o javadoc que criamos para ele.

Uma ultima observação de qualidade de código: Um bom método é auto-explicativo o que significa que o nome do método e seu javadoc devem ser mais do que suficientes para explicar o que ele é e o que faz. Nunca, em hipótese alguma, um programador deve necessitar acessar o código do método para entender para que ele serve, Esse tipo de coisa caracteriza um método mal documentando ou com problema de nomenclatura.

Se quer um bom exemplo de documentação de uma olhada nós códigos nativos do java. Você verá que cada classe e método possuiu seu javadoc.

Bem, é isso, até a próxima.

FEA-JV8-001 – Novidades Java 8: porque tanta expectativas?

Publicado: 04/03/2014 por Guilherme Weizenmann em Básico, java
Tags:,

Olá Pessoal.

Estive olhando as novidades do Java 8 e resolvi reportar um pequeno resumo. Desde o Java 5, uma nova versão do Java nã era tão aguardada. No Java 5 foram aicionados Annotations e Generics. O Java 8 irá estreiar Lambdas e Streams.

Gordan Freeman, at Black Mesa, Lambda Core

Lambdas são um rescurso genérico, derivado de conceitos funcionais, e muito similar a Scala (outra lingagem que roda na JVM). A descrição do recurso é a seguinte:

Expressões Lambda são uma nova e importante funcionalidade no Java SE 8. Elas provêm uma forma clara e concisa de representar 1 método de uma interface usando uma expressão. Expressões Lambda também melhoram as bibliotecas Collection fazendo com que seja fácil iterar sobre, filtrar e extrair dados de uma Collection. Adicionalmtente, novas funcionalidades de concorrência melhoram a performance em ambientes multiprocessados.
Java SE 8: Lambda Quick Start em 04/03/2014 em inglês. Tradução do autor.

A idéia básica é facilitar o desenvolvimento, principalmente de códigos que iteram sobre collections, baseado em interfaces, que também trazem novidades, devido aos Lambdas. A parte da concorrência é implementada por “debaixo dos panos”, pra você não ter que se preocupar com isso.

Olhando através do espelho

As interfaces, até o Java 7, serviam para criar assinaturas de métodos, sem implementação padrão. Mas com o surgimento dos Lambdas, e a necessidade de manutenção de código legado temos o seguinte problema:

Se alterarmos uma interface em um projeto já existente, e adicionarmos um método a ela, obrigaremos todas as classes que implementam essa interface a implementar esse novo método, quebrando assim o código existente.

Visando resolver esse problema, no Java 8 foram introduzidos os “métodos padrões” (Default Methods, também chamados “virtual extension methods” ou “defender methods”). São métodos com implementação padrão em Interfaces. Esses métodos com implementação padrão não precisam ser implementados pelas subclasses, mas podem ser sobrescritos se preciso. Assim é possível alterar um interface sem quebrar compatibilidade. Como as interfaces dos Collection foram modificadas com o adventos dos Lambda, foi preciso a criação dos métodos padrões para evitar a quebra de código ou o mega trabalho para ajustar tudo.

Mas lembre-se, as interfaces não guardam estados e não são, portanto, substitutas das classes abstratas. Classes abstratas e interfaces ainda são diferentes e tem funções diferentes.

Outra coisa importante: múltiplas heranças. Com os métodos padrões surge um problema. Dadas duas interfaces com métodos de mesmas assinatura, com implementação padrão, qual deverá ser escolhido? O problema, no Java, é resolvido em tempo de compilação. A classe deverá implementar (sobrescrever o método em questão, mesmo que seja chamando a implementação default de uma das interfaces implementadas) ou o compilador irá gerar uma mensagem de erro e não compilará a classe.

Seguindo o fluxo do rio

Aleḿ das alterações em interfaces e surgimento dos Lambdas, surgem também os Streams. Mas o que são?

Wrappers sobre coleções que suportam várias operações convenientes e de alta performance expressadas sucintamente com Lambdas.
Java 8 Tutorial: Lambda Expressions, Streams, and More – Java 8 Streams Part 1 em 04/03/2014 em inglês. Tradução do autor.

Streams não guardam dados, mas possuem uma entrada de dados baseada, por exemplo, em um ArrayList. Recuperando o stream dessa lista, pode-se facilmente aplicar operações em cada elemento (forEach), como aplicar filtros (filter), entre outras. O importante de lembrar é que esses métodos foram feitos para se trabalhar com Lambdas.

Pequenos detalhes

Além dessas grandes mudanças, outras pequenas serão adicionadas. Citarei apenas algumas:

  • Nashorn JavaScript Engine: suporte a javascript embarcado e disponível para qualquer aplicação
  • Repeating Annotations: atualmente cada anotação somente pode ser usada uma vez (na classe, método, prorpiedade). O Java 8 terá suporte a repetição de anotaçãoes!
  • Java Time API: nova api para trabalhar com datas e horas, substituindo o velho e proplemático java.util.Date

E se eu encontrar outra que vale a pena postar, eu atualizo o post…..

Going back home

Pra terminar, fazendo um resumo do resumo, Lambdas são a grande novidade, trazendo mudanças em várias outras estruturas do Java. Com isso, será mais rápido desenvolver, sem perder compatibilidade com o que já existe, e mais rápido operar sobre collections.

Até mais e obrigado pelos peixes!

ENV-006 – Introdução ao JDK

Publicado: 14/02/2014 por Ari Cesar em Básico, java
Tags:, , , , ,

Olá povo!

Nesse post iremos fazer uma breve introdução ao JDK apresentando seu conceito e dando de barbado alguns links de consulta.

O que é o JDK?

JDK é a abreviação para Java Development Kit ou em outras palavras é o nosso Kit de desenvolvimento de aplicativos java. Esse Kit de desenvolvimento é composto pela Java Virtual Machine (JVM), compilador da linguagem e uma série de códigos (bibliotecas) que nos auxiliam no desenvolvimento de aplicações.

A JDK vive em constante evolução e por isso que de tempos em tempos ( em torno de 2 anos) aparece uma nova versão. A versão atual é 7 e em março deve sair a 8 ( previsto para 18/3/2014).

É sempre aconselhável utilizar as ultimas versões do java, devido a ajustes finos feitos em sua JVM. De acordo com especialistas, códigos escritos em versões mais antigas da JVM são melhor executados em JVMs mais recentes, o que significa ganho de performance em seu sistema sem precisar refatorar o código.

Agora que já fizemos um overview, vamos entrar nos detalhes da JDK.

Compilador

Toda a linguagem tem o seu compilador e java não poderia ser diferente. Esse é o responsável por realizar a transformação do teu código .java em .class o que permite que seu código rode na JVM. Normalmente as IDEs fazem o trabalho de compilar os códigos desenvolvidos, mas caso você seja um amante do Rambo e queira colocar a sua faixa vermelha na cabeça, faca nos dentes e entrar selva a dentro, você pode realizar a compilação manual de sua classe ou pacote. Para isso precisa ir no promt do windows ou terminal do linux e digitar o tão famoso javac .

Java Virtual Machine (JVM)

Esse é o cara da antiga SUN, sem ele o Java não existiria (e isso não é exagero) . Ele é o responsável pela a interoperabilidade do seu código java em diversos sistemas operacionais. Como assim? Simples. Escreva uma vez o código, compile para bytecode e executar em qualquer Sistema Operacional que tenha JVM instalado. Lembrando que isso incluir dispositivos móveis e outros sistemas embarcados como por exemplo o painel de controle de seu carro ou do avião que você vai pegar para viajar.
Maravilho certo? Agora voltando ao nosso JDK. A JVM vai ser o responsável por executar o teu código em sua maquina. Quando se trata da JVM nunca podemos nos esquecer dos seguintes detalhes:

  • A JVM simula um sistema operacional por isso que os byteCode rodam sem problema em qualquer lugar do universo (continua não sendo exagero porque tem robo da NASA em marte rodando Java).
  • A JVM não roda apenas java, ela também roda Grovy, JavaScript e outras linguagens.

Estamos planejando fazer um post específico sobre a JVM, então aguardem que será bem interessante

Bibliotecas (API)

Você ja programou em Java alguma vez? Caso a resposta seja sim, com certeza você já utilizou alguma biblioteca do Java. Como assim? Java tem uma penca de códigos internos, oque chamamos de API do Java. Essas APIs são divididas para Java SE , Java ME e Java EE e tem suas questões específicas. Se algum dia você digitou System.out.println("Olá mundo") para escrever no console Olá Mundo, te informo que já teve contato com a API do Java.

Te digo mais, é impossível programar em java sem utilizar a API deles. Sendo assim te aconselho a dar uma estuda na API do JAVA. É costume de muitos programadores ficar criando códigos que já existem na API, ou até pior, não estudar a API por não entendê-la.

Bom, era isso. Espero que esse post tenha ajudado a entender melhor o java.

Abraços a todos e até a próxima.

Organização dos POST

Publicado: 22/01/2014 por Guilherme Weizenmann em Organização dos POST

Depois de uma pequena faxina e uma pensadinha em como montar as coisas, decidimos o seguinte:

  • os posts terão prefixos e serão numerados por assunto, de forma a mostrar qual a ordem deles. Essa ordem não necessariamente seja cronológica, mas sim a nível de conteúdo. Sendo assim, se você leu o post 2 de uma série, o próximo conteúdo desse tema é o 3, e o 1 seria o pré-requisito.
  • os post poderão ter sufixos. Caso não haja sufixo (após o número do post) não ha uma variação do tema. Caso haja, poderá haver um post com o mesmo tema sendo tratado em linux e windows, por exemplo. Os sufixos utilizados serão catalogados aqui:
    • L: linux
    • W: windows

Temas abordados por prefixo

ENV – Temas relacionados à ambiente necessário para trabalhar com Java

ENV-001 – Variáveis de ambiente

Publicado: 21/01/2014 por Guilherme Weizenmann em Básico, java
Tags:, , ,

Olá pessoal. Eu sei que esse, na ordem de temas vem antes do post ENV-001L, mas eu escrevi aquele primeiro…..

Este é apenas a respostas para as seguintes peeguntas:

  • O que são variáveis de ambiente?
  • Pra que servem variáveis de ambiente?

Vamos lá…..

O que são variáveis de ambiente

São variáveis fora dos programas e aplicações que são acessíveis pelos programas e aplicativos e guardam informações sobre o ambiente em que eles se encontram.

Pra que servem variáveis de ambiente

As variáveis de ambiente guardam informações sobre o ambiente atual, tanto pode ser do console/terminal em uso, como do usuário ou do sistema. Olhe os exemplos:

COMPUTER
MINHA_MAQUINA
USER
devjava
AMBIENTE
PRODUCAO
PATH
C:\windows;C:\windows\system (windows)
/bin:/usr/bin (Linux, Unix)

Traduzindo em miúdos, as variveis de ambiente são placas em uma cidade grande, dizendo aos programas e aplicativos alguns dados básicos para que possam se localizar.

Como configurá-las

Isso depende do sistema operacional. Veja os posts ENV-001L e ENV-001W.

Isso é tudo pessoal!

ENV-002 – Instalação e configuração da JVM e JDK

Publicado: 21/01/2014 por Guilherme Weizenmann em Básico, java
Tags:, , ,

Olá pessoal. Hoje falarei da instalação do Java. O Java vem em dois sabores:

JRE
Java Runtime Environment (Ambiente de tempo de execução Java – tradução meia boca 😛 )
JDK
Java Development Kit (Kit de desenvolvimento Java – tradução boa 😀 )

Então, se você for desenvolver uma aplicação em Java precisará do JDK. Se for usar ou distribuir uma aplicação para o usuário final, precisará do JRE, que por “coincidência”, faz parte do JDK.

Além desses dois sabores do Java, ele também tem 2 fornecedores. Se você pensava que Java era só da Oracle (antigamente Sun), se enganou. Na época em que a Sun não tinha sido comprada pela Oracle, a própria Sun começou um projeto junto à comunidade Java para a disponibilização de um Java 100% open source. Então, se você pensava também que o Java era 100% open source, se enganou. O Java da oracle possui algumas partes fechadas, mas que estão em processo de abertura de código. Então, existem 2 fornecedores do Java: a Oracle e ………… (suspense) ……………. o projeto OpenJDK.

As principais diferenças entre o Java da Oracle e o OpenJDK são:

  • o OpenJDK é 100% open source
  • o OpenJDK, atualmete, roda somente em linux, mas se você joga Minecraft em linux, deveria usá-lo, pois é otimizado para linux.

Onde eu consigo o Java

O Java da oracle, você baixa do site da Oracle para qualquer sistema operacional.

Se você usa linux, principalmente derivados do Debian, terá ainda a opção de acesso via repositório oficial ao OpenJDK e ao Java da Sun (5 e 6 antes da venda da Sun), e via repositório PPA (https://launchpad.net/~webupd8team/+archive/java) ao Java da Oracle (Java 6,7 e 8).

O processo de instalação específico para cada S.O. será abordado nos POST ENV-002L e ENV-002W

Eu instalei, e aí……

Depois de instalado, 3 variáveis de ambiente são necessárias:

  • PATH – já existe, mas precisa estar adequada
  • JAVA_HOME
  • CLASPATH

JAVA_HOME e CLASSPATH são abordadas no post ENV-003(L/W).

Quanto PATH, deve ser adicionado o caminha para os executáveis da Java para que o sistema saiba onde procurar os comandos java, javac, javaws, …, sem que você precise colocar o caminho completo.

Bem pessoal, por hoje é só, mas em breve traremos os procedimentos de instalação do Java em cada plataforma.

Vida longa e próspera!

ENV-002W – Instalando o JDK no Windows

Publicado: 17/01/2014 por Ari Cesar em Básico, java
Tags:, , ,

Olá pessoal, tudo bem?

Hoje irei escrever sobre a a instalação do JDK no Window$. Caso você não saiba o que é o JDK te convido a ler o post ENV-006 – Conheçendo a JDK.

JDK

Para fazer a instalação do JDK é necessário realizar o download no site da Oracle. Aconselho que sempre seja feito o download da ultima versão do JDK, pois assim terá as novidades da linguagem e correções/melhorias realizadas em cima da JVM. Como não precisamos de uma Magnum para matar uma mosca, iremos baixar o JSE ( nesse caso a nossa Magnum é conhecida como JEE e em outro post falaremos de suas diferenças). Para facilitar, segue o link para download .

Feito as devidas chatices tratativas para baixar o JDK iremos agora fazer a instalação dele.

Instalando o JDK

Bem, agora vamos para o que interessa:

  • Vá até a pasta onde foi realizado o download do JDK e de dois cliques sobre dele. O teu Window$ vai te fazer uma pergunta inteligentíssima querendo saber se você realmente quer executar esse aplicativo. Clique no botão sim (yes) e vamos adiante.
  • Agora que você ajudou o Window$ e fez o favor de confirmar que deseja realmente executar o programa, verá a uma tela igual ou muito semelhante a de abaixo. Clique em next e vamos continuar com a brincadeira.
Tela principal para instalação do JDK.

Tela principal para instalação do JDK.

  1. Feito isso teremos uma tela igual ou muito semelhante a de baixo. Essa tela é interessante pois nos possibilita escolher se queremos instalar o JDK com o código fonte e javadoc (Source code), se queremos instalar a JRE da versão do instalador ( Public JRE) ou se queremos alterar o local da instalação do JDK (change). Nessa tela aconselho a ir direto para o next e não se preocupar com esses detalhes.
Configurações de instalação do java

Configurações de instalação do java

Algo bem importante: Como pode ter observado não comentamos sobre Development tools. Isso foi de propósito pois não temos como remover ele já que ele é JDK.

Algo importante: JRE significa Java Runtime Environment e é utilizado para rodar aplicações java em seu computador como por exemplo aquelas de sites de banco.

Algo um pouco menos importante: Não se preocupe caso você não saiba o que é um javadoc, source code. Você pode ler o nosso post ENV-007 – JavaDocs para que servem e saber mais sobre esses dois itens mencionados.

  1. Clicando em next você verá o JDK ser instalado em seu computador. Se tudo der certo aparecerá uma tela igual ou parecida com a de baixo.
Tela confirmando que a nstalação foi realizada com sucesso.

Tela confirmando que a nstalação foi realizada com sucesso.

Feito isso você tem a JDK em sua maquina e pode iniciar o desenvolvimento de seus aplicativos.

Para fazer a compilação via prompt aconselho dar uma passada no post ENV-001W – Variáveis de ambiente em Windows .

Até a próxima!