Introdução ao JAVA II

Na primeira parte deste artigo, fiz uma pequena introdução ao JAVA e mostrei um pequeno exemplo de código. Nesta segunda parte, vamos começar por analisar alguns pormenores desse código.

    package programa;

    public class programa {
        public static void main(String [] args) {
            System.out.println("Olá Mundo!");
        }
    }

Declaração “public“:

Esta declaração indica que estamos perante algo “público”, isto é, visível por outras classes. Na linha 3, declarámos a nossa classe “programa” como pública e, em geral, é normal fazê-lo pois pretendemos que as nossas classes sejam visíveis por outras classes. De outra forma, não as poderíamos usar. Contudo, há casos específicos em que se declaram classes como privadas ou protegidas mas, para já, não irei abordar esses casos.

O procedimento “main” também está declarado como público. Simplificando, sempre que queremos que um método, função, variável, etc, seja visível por outra classe, temos que usar a declaração “public“. Neste caso particular, o método “main” terá que ser mesmo público para que o JRE o veja e o possa evocar para executar o programa!

Declaração “static“:

Esta declaração indica que estamos perante um membro de uma classe que é “estático”. Isto quer dizer que, para usarmos este membro, não precisamos de instanciar um objecto do tipo da classe que o contem. Existem várias classes que têm este tipo de membros. Em alguns casos o “static” é usado para definir um conjunto de constantes (variáveis cujo valor não pode ser alterado), como iremos ver em alguns casos em artigos futuros.

Neste caso, queremos o “main” como estático, pois o JRE não vai querer instanciar um objecto do tipo “Programa” para executar o código. Assim, o método é visível através de “Programa.main”. Este conceito irá sendo abordado em exemplos futuros.

Ainda temos a declaração “void” para o “main“. Esta declaração é como se indicássemos que “main” é uma “função” que não retorna nenhum valor (o retorno é “vazio”). Por outras palavras, indica que “main” é um procedimento e não uma função. Executa um conjunto de código mas não retorna nenhum resultado. Este tipo de declaração é igual ao que temos no C/C++.

Apesar de não estarmos a usar parâmetros de entrada, através da linha de comandos, o procedimento “main” deverá aceitar, como argumento, um “array” do tipo “String“. Falarei sobre arrays no próximo artigo.

Bibliotecas do JAVA

Antes de concluirmos a nossa análise, vou falar sobre as bibliotecas de classes do JAVA. Estas bibliotecas definem uma série de “packages” com classes que, sem as quais, pouco ou nada faríamos num programa.

Um dos packages relevantes é o “java.lang” e que contem uma série de classes básicas como tipos de dados (onde se incluem as “String” – cadeias de caracteres) e de utilização genérica. Iremos ver que, para usarmos classes, temos que as importar. Mas as classes contidas em “java.lang“, estão sempre disponíveis, pelo que não as temos que importar, o que dá para entender a importância deste pacote.

Agora, voltando ao nosso código, a classe “System“, que pertence ao package “java.lang“, é uma classe que não é instanciável e contem apenas membros estáticos. Essencialmente, esta classe disponibiliza um conjunto de funcionalidades para acessos de “entrada/saída” standard, variáveis de ambiente, carregamento de bibliotecas, entre outras. Para já, interessa-nos o acesso de entrada standard (in) e o acesso de saída standard (out).

Acesso de entrada standard: “in“

Aqui estamos a falar, de forma geral, do teclado. O campo “in” mantém uma ligação constante ao teclado para que possamos ler o que está a ser introduzido neste. Do tipo “InputStream“, do package “java.io“, este campo permite obter os dados através de outras classes, como iremos ver noutro exemplo mais abaixo.

Acesso de saída standard: “out“

Aqui estamos a falar, de forma geral, do ecrã ou consola de terminal. O campo “out” mantém uma ligação constante de saída que nos permite escrever informação no ecrã. É o que usámos no nosso exemplo acima, através do método “println“, que envia dados para o ecrã e, neste caso específico, a terminação “ln” indica que estamos a escrever uma “linha” de texto e, no fim, é adicionado o código respectivo de “mudança de linha”. Também existe o método “print” mas, neste caso, o cursor mantém-se na mesma linha, depois do que foi escrito. Ao voltar a usar um “print” o texto continua na mesma linha. Este campo é do tipo “OutputStream“, também do package “java.io“.

Existem dezenas, senão centenas, de packages nas bibliotecas do JAVA (JRE) pelo que se torna praticamente impossível decorar todas as classes que estão disponíveis. Estas bibliotecas compõem também o que chamamos da API (Application Programming Interface) do JAVA.

Saber procurar uma determinada classe e compreender como usá-la é crucial para programarmos em JAVA. Daí a importância de…

A “Bíblia Sagrada” do JAVA

O que chamo de “Bíblia Sagrada” do JAVA é precisamente a documentação da API, ou seja, das bibliotecas e dos packages disponíveis. Esta documentação é gerada para um tipo de um “javadoc” (JAVA DOCument) e que é extremamente útil. Através de comentários, escritos de uma forma específica no nosso código, podemos também gerar um “javadoc” das nossas classes, como iremos ver num próximo artigo sobre classes.

Esta documentação está disponível para as várias versões do JAVA. Por exemplo:

• Versão 7: http://docs.oracle.com/javase/7/docs/api/
• Versão 8: http://docs.oracle.com/javase/8/docs/api/

Para outras versões, consulte o link: http://www.oracle.com/technetwork/java/javase/documentation/api-jsp-136079.html

Esta documentação, formatada em HTML, mostra 3 painéis. Do lado esquerdo, temos um painel em cima com a lista dos packages e, em baixo, a lista das classes e outros membros que existem no package que seleccionarmos em cima. Do lado direito temos um painel com toda a informação e descrição da classe seleccionada. Nesta informação, saliento a lista de métodos e campos. Quando um destes faz referência a outra classe, temos um link para consultarmos a documentação dessa classe!

Para saber mais sobre a classe “System“, seleccione o package “java.lang” e a classe “System“.

Tipos de dados nativos ou primitivos do JAVA

Como noutras linguagens de programação, o JAVA contem uma série de tipos de dados nativos ou primitivos, em todo semelhantes ao C/C++, que podem ser usados nos nossos programas. Estes tipos não são classes!

Tipo de dados	Tamanho (bits)	Valores possíveis
byte	8 (com sinal)	-128 a 127
short	16 (com sinal)	-32768 a 32767
int	32 (com sinal)	-231 a 231 - 1
long	64 (com sinal)	-263 a 263 - 1
float	32 (com sinal e vírgula flutuante)	3,4 e-38 a 3,4 e+38
double	64 (com sinal e vírgula flutuante)	1,7 e-308 a 1,7 e+308
boolean	-	true / false
char	16	Qualquer caracter (letra) "unicode"

Nota: O intervalo de valores que indiquei para os tipos “float” e “double” são valores que aprendi faz já uns anos, pelo que são meramente indicativos.

Existem linguagens onde também existe o tipo primitivo “string“, que representa um conjunto (em cadeia) de caracteres. Nem o JAVA, nem o C/C++, possuem este tipo de forma nativa, sendo necessário usar um “array” do tipo “char“. Porém, existe, em ambas as linguagens, uma classe para este efeito. No JAVA a classe chama-se String e pertence, mais uma vez, ao package “java.lang“, como já referi atrás.

Segundo exemplo de código

Neste segundo exemplo, vamos solicitar ao utilizador que introduza o seu nome e a sua idade.

package com.out4mind;

import java.util.Scanner;

public class Intro2 {

    public static void main(String[] args) {
        
        String nome;
        short idade;
        Scanner sc = new Scanner(System.in);
        
        System.out.print("Introduza o seu nome: ");
        nome = sc.nextLine();
        System.out.print("Introduza a sua idade: ");
        idade = sc.nextShort();
        System.out.println("Seja bem-vindo(a) " + nome + ". Você tem " + idade + " anos.");

    }

}

Para testar este exemplo, poderá criar um novo projecto no Eclipse ou alterar o código no projecto anterior. Note que, na linha 1, usei “com.out4mind” para o nome do pacote, pelo que deverá ajustar o nome conforme o que criar.

Neste exemplo, vamos precisar de algumas variáveis para guardar a informação do nome e da idade. Assim, declaramos o nome como uma “String” (linha 9) e a idade do tipo “short” (linha 10). Podíamos ter usado o tipo “int“, por ser mais perceptível que estamos a declarar um inteiro. Mas ter um utilizador a usar este código com mais de 127 anos, parece-me ser pouco provável…

Como vamos usar o “System.in” para ler o teclado, teremos que usar uma classe que permita obter os dados introduzidos. Existem classes que agem como buffers. Neste exemplo usei uma classe simples e fácil de usar, a classe “Scanner” do package “java.util” e declarei uma variável “objecto” deste tipo, que chamei de “sc” (linha 11). Consulte a documentação para mais informações sobre esta classe. Repare que, como esta classe não está no package “java.lang“, foi necessário importá-la para a podermos usar (linha 3). Para usarmos esta classe, temos que a instanciar e, para o efeito, usamos a instrução “new” e o construtor da classe, que irei explicar num próximo artigo.

Na linha 14, para ler o nome numa “String“, podemos usar o método “nextLine()”. Este método lê toda a informação introduzida até encontrar uma “mudança de linha”, gerada pela tecla “Enter“. Já para a idade, na linha 16, usamos o método “nextShort()” que, automaticamente, lê o valor introduzido e converte-o para um número do tipo “short“. Repare na documentação que também temos um “nextInt()”, “nextLong()”, “nextFloat()”, …

Por fim, na linha 17, repare como estamos a juntar a informação para exibir no ecrã. Normalmente, o símbolo “+” está associado à operação da adição. Mas, aqui, é usado para a operação de “concatenação”, que junta o conteúdo de várias “strings“. Repare que, os textos entre aspas, são vistos como strings. Mas temos um aspecto curioso que é a variável “idade”. Sendo uma variável numérica, podíamos pensar que estaríamos a somar uma string a um inteiro, o que não é válido. Contudo, o JAVA observa o contexto das operações e, como temos a variável “idade” entre strings, esta vai ser, automaticamente, convertida para uma string e concatenada às restantes.

No próximo artigo, irei abordar a criação de métodos e funções.

Mantenha-se em ligação connosco através das redes sociais para ter novidades do nosso blogue multi-temático “Out4Mind”!

Este artigo foi escrito de acordo com a antiga grafia.