O geek que sabia Java Parte II

No capítulo anterior de nosso curso de Java (veja a edição 36 da Revista do Linux, página 34), apresentamos um pequeno histórico da linguagem Java e uma introdução aos seus principais conceitos. Nesta edição, começamos a lidar com a linguagem em si, abordando tipos de dados, operadores, escopo de variáveis, expressões e controle de fluxo. Mostramos também os ajustes que devem ser feitos para começar a usar as principais ferramentas de desenvolvimento: o compilador javac e o interpretador java. Mãos à obra!

Programando em Java

Para utilizar a linguagem Java, é preciso ter acesso ao compilador e à máquina virtual, que podem ser obtidos no site oficial da linguagem, www.javasoft.com. Uma vez instalado o pacote J2SDK (Java 2 Standard Development Kit), devemos configurar algumas variáveis de ambiente para poder usar as ferramentas:

CLASSPATH

Abaixo, um exemplo de como configurar a variável de ambiente CLASSPATH no Windows e Unix:

Windows:

set CLASSPATH=%CLASSPATH%;c:\jdk1.3\src.jar;
c:\j dk1.3\lib\tools.jar;c:\jdk1.3\lib\dt.jar;.;

Unix (usando Bash):

export CLASSPATH=$CLASSPATH:/usr/jdk1.3/src.jar:
/usr/jdk1.3/lib/tools.jar:/usr/jdk1.3/lib/dt.jar:.:
PATH

Windows:

set PATH=%PATH%;c:\jdk1.3\bin;

Unix (usando Bash):

export PATH=$PATH:/usr/jdk1.3/bin

Usando o comando JAVAC

O javac é o compilador da linguagem Java. Executando esse comando sobre um arquivo que contém código nessa linguagem, é gerado um segundo arquivo contendo código-binário. Esse arquivo de código-binário é utilizado para a execução do programa. O comando básico para compilar seu código é: javac NomeDoArquivo.java. Um arquivo contendo um programa na linguagem Java deve ter a extensão .java. No exemplo de compilação apresentado acima, o nome do arquivo que contém o código-fonte em Java chama-se NomeDoArquivo.java.

Usando o comando JAVA

O executável java é a Máquina Virtual Java, ou seja, é o programa responsável pela execução do código compilado pelo javac. Para executar um programa, o comando é: java NomeDoArquivo. Com isso, você está instruindo o interpretador java a executar o código contido no arquivo NomeDoArquivo.class. Note que a extensão .class deve ser omitida.

Tipos de dados

Veja na tabela 3.1 os tipos de dados primitivos da linguagem Java.

Tabela 3.1

Inteiros
Tipo	Tamanho/Formato	Descrição
byte	8 bits	Inteiro do comprimento de um byte
short	16 bits	Inteiro curto
int	32 bits	Inteiro
long	64 bits	Inteiro longo
Reais
Tipo	Tamanho/Formato	Descrição
float	32 bits IEEE 754	Ponto flutuante de precisão simples
double	64 bits IEEE 754	Ponto flutuante de precisão dupla
Outros
Tipo	Tamanho/Formato	Descrição
char	16 bits (Unicode)	Um caractere
boolean	true ou false	Valor booleano (verdadeiro ou falso)
Tabela 3.1 - Qualificadores nas linguagens Java e C++

Escopo

O escopo define onde uma variável é acessível durante a execução de um sistema e quando a variável é criada e destruída. A localização de uma variável dentro do programa estabelece seu escopo. Existem quatro categorias de escopo de variáveis na linguagem Java, são elas:

1. Variável membro.

2. Variável local.

3. Parâmetro de métodos.

4. Parâmetro do manipulador de exceções.

Tabela 3.2

Operador	Uso	Descrição
+	op1 + op2	Soma op1 e op2
-	op1 - op2	Subtrai op2 de op1
*	op1 * op2	Multiplica op1 por op2
/	op1 / op2	Divide op1 por op2
%	op1 % op2	Módulo (resto da divisão) de op1 por op2
Tabela 3.2 - Tabela de operadores binários na linguagem Java

Escopo.java

public class Escopo extends Object
{
    private int atributo_classe = 10;
    public Escopo()
    {
        int variavel_metodo = 9;
        System.out.println(~SA variável da classe fica acessível na execução do objeto~T);
        System.out.println(atributo_classe);
        System.out.println(~S\nA variável de método morre após a execução do método~T);
        System.out.println(variavel_metodo);
    }
    public void escopo1()
    {
        System.out.println(~SNão foi declarada a variável x portanto não posso acessá-la~T);
        int x = 67;
        System.out.println(~SAgora a variável x fica ativa até o final do método => ~S+x);
    }
    public void escopo2()
    {
        // mesmo nome do atributo de classe
        int atributo_classe = 4;
        System.out.println(~SSe quiser acessar o atributo de classe deve-se utilizar~T);
        System.out.println(~S this.atributo_classe => ~S+this.atributo_classe);
        System.out.println(~SSem usar this acesso a variável deste método~T);
        System.out.println(atributo_classe);
    }
    public static void main(String args[])
    {
        Escopo e = new Escopo();
        e.escopo1();
        e.escopo2();
    }
}

A tabela 3.3 apresenta os operadores unários da linguagem Java. Esses operadores atuam sempre sobre um único operando, tal como a adição de uma unidade sobre um operando.

Tabela 3.3

Operador	Uso	Descrição
++	op++	Incremente op em 1; utiliza o valor de op antes de realizar o incremento
++	++op	Incrementa op em 1; utiliza o valor de op após realizar o incremento
--	op--	Decrementa op em 1; utiliza o valor de op antes de fazer o decremento
--	--op	Decrementa op em 1; utiliza o valor de op após realizar o decremento
Tabela 3.3 - Tabela de operadores unários na linguagem Java

A tabela 3.4 apresenta os operadores relacionais e condicionais da linguagem Java. Esses operadores podem ser utilizados em estruturas condicionais tal como ~Sse a > b então execute algo~T.

Tabela 3.4

Operador	Uso	Retorna verdadeiro se...
>	op1 > op2	op1 é maior que op2
>=	op1 >= op2	op1 é maior ou igual a op2
<	op1 < op2	op1 é menor que op2
<=	op1 <= op2	op1 é menor ou igual a op2
==	op1 == op2	op1 e op2 são iguais
!=	op1 != op2	op1 e op2 não são iguais
Tabela 3.4 - Tabela de operadores condicionais e relacionais na linguagem Java

A tabela 3.5 apresenta os operadores binários condicionais da linguagem Java. Esses operadores são utilizados em estruturas condicionais onde se deve verificar se um ou mais operandos são verdadeiros ou falsos.

Tabela 3.5

Operador	Uso	Retorna verdadeiro se...
&&	op1 && op2	op1 e op2 são verdadeiros, avalia condicionalmente op2
||	op1 || op2	op1 ou op2 é verdadeiro, avalia condicionalmente op2
!	!op	op é falso
&	op1 & op2	op1 e op2 são ambos verdadeiros, sempre avalia op1 e op2
|	op1 | op2	op1 ou op2 é verdadeiro, sempre avalia op1 e op2.
Tabela 3.5 - Tabela de operadores binários condicionais na linguagem Java

A tabela 3.6 apresenta os operadores de bits da linguagem Java. Esses operadores atuam sobre o conteúdo binário dos operandos.

Tabela 3.6

Operador	Uso	Operação
>>	op1 >> op2	Gira os bits de op1 para a direita na distância de op2
<<	op1 << op2	Gira os bits de op1 para a esquerda na distância de op2
>>>	op1 >>> op2	Gira os bits de op1 para a direita na distância de op2 (unsigned - sem sinal)
&	op1 & op2	Operação lógica AND
|	op1 | op2	Operação lógica OR
^	op1 ^ op2	Operação lógica XOR
~	~op2	Complemento dos bits
Tabela 3.6 - Tabela de operadores sobre bits na linguagem Java

A tabela 3.7 apresenta os operadores de equivalência da linguagem Java. Esses operadores podem ser utilizados como recurso opcional da linguagem.

Tabela 3.7

Operador	Uso	Equivalente a...
+=	op1 += op2	op1 = op1 + op2
-=	op1 -= op2	op1 = op1 - op2
*=	op1 *= op2	op1 = op1 * op2
/=	op1 /= op2	op1 = op1 / op2
%=	op1 %= op2	op1 = op1 % op2
&=	op1 &= op2	op1 = op1 & op2
|=	op1 |= op2	op1 = op1 | op2
^=	op1 ^= op2	op1 = op1 ^ op2
<<=	op1 <<= op2	op1 = op1 << op2
>>=	op1 >>= op2	op1 = op1 >> op2
>>>=	op1 >>>= op2	op1 = op1 >>> op2
Tabela 3.7 - Tabela de operadores de equivalência na linguagem Java

Operacoes.java

public class Operacoes extends Object
{
    public void calculos()
    {
        int x = 10;
        int y = 9;

        double resultado = ((((x + y) * y) / x) - y) % 3;
        System.out.println(~SResultado => ~S+resultado);
    }
    public void operadoresUnarios()
    {
        int x = 1;
        int y = 1;
        int k = 10;
        int z = 10;

        for (int m = 0; m < 5; m++)
    }
    public void operadoresRelacionais()
    {
        int x = 10;
        int y = 9;

        if (x > y)
        {
            System.out.println(~SX maior que Y~T);
        }

        if (x != y)
        {
            System.out.println(~SX diferente de Y~T);
        }
        // outra forma de if
        // se x > y então k recebe 3 senão k recebe 7
        float k = x > y ? 3 : 7;

        System.out.println(«Valor de K => «+k);

        if (4 == 4)
        {
            System.out.println(~S4 igual a 4~T);
        }
    }

    public void operacoesAtribuicao()
    {
        int x = 10;

        System.out.println(~SValor original => ~S+x);
        x += 10;
        System.out.println(~SValor após soma com atribuição => ~S+x);
        x -= 5;
        System.out.println(~SValor após subtração com atribuição => ~S+x);
        x *= 5;
        System.out.println(~SValor após multiplicação com atribuição => ~S+x);
        x /= 5;
        System.out.println(~SValor após divisão com atribuição => ~S+x);
    }

    public static void main (String args[])
    {
        Operacoes o = new Operacoes();
        o.calculos();
        o.operadoresUnarios();
        o.operadoresRelacionais();
        o.operacoesAtribuicao();
    }
}


Fluxo.java
public class Fluxo extends Object
{
    public static void main(String args[])
    {
        int x = 5;
        int k = 0;

        if (x > 10)
        {
            x = 50;
        }
        else
        {
            x = 40;
        }

        switch (x)
        {
        case 10: {
                     System.out.println(~SDEZ~T);
                     break;
                 }
        case 40: {
                     System.out.println(~SQUARENTA~T);
                     break;
                 }
        case 50: {
                     System.out.println(~SCINQÜENTA~T);
                     break;
                 }
    }

    for (k = 0; k < 10; k++)
    {
        if (k > 5)
        {
            // volta para o for
            continue;
        }
        System.out.println(~Svalor => ~S+k);
    }
    while (k > 0)
    {
        System.out.println(~Svalor do while => ~S+k);
        k~W;
    }

    do {
           System.out.println(~Svalor no do-while => ~S+k);
           k++;
       } while (k < 5);

    // tratamento de exceções tenta executar o código se não funcionar trata o erro
    // com (catch) ou executa um finally (executa no final do trecho de código)
    try {
            System.out.println(~Sdentro do try~T);
        }
    catch(Exception e)
    {

        System.out.println(~SSe não funcionar por algum motivo entra aqui!~T);
    }
}

Tabela 3.8

Operadores pós-fixados	[] . (params) expr++ expr-
Operadores unários	++expr -expr +expr -expr ~ !
Cast ou criação	new (type)expr
Multiplicação	* / %
Adição	+ -
Rotação	<< >> >>>
Relacional	< > <= >= instanceof
Igualdade	= = !=
Operador de bits	AND &
Operador de bits	OR exclusivo ^
Operador de bits	OR inclusivo |
AND lógico	&&
OR lógico	||
Condicional	?::
Atribuição	= += -= *= /= %= &= ^= |= <<= >>= >>>=
Tabela 3.8 - Tabela de expressões na linguagem Java

Tabela 3.9

Tipo do Fluxo	Palavra-chave
Tomada de decisão	if-else, switch-case
Laços (loops)	for, while, do-while
Tratamento de exceções	try-catch-finally, throw
Outros	break, continue, label:, return
Tabela 3.9 - Tabela de fluxo de execução na linguagem Java