Breve Introdução à linguagem Java

• Compilação e execução de um programa em Java
• Tipos de dados em Java
• Operadores Aritméticos e Relacionais
• Instruções de controle de fluxo
• Objectos e Classes
• Acesso às variáveis e métodos de classes

Compilação e execução de um programa em Java

// Java Hello World
class Hello {
    public static void main(String[] args) {
        System.out.println("Hello World !");
    }
}

• Como compilar o programa? $ javac Hello.java
• Como executar o programa? $ java Hello
• O nome do ficheiro contendo código tem de ter o nome da classe executável mais a extensão .java
• A compilação da classe dá origem a um ficheiro com o mesmo nome, mas com a extensão .class
• Para executar, chama-se o nome da classe e não o nome do ficheiro (ex: java Hello e não java Hello.class)

Tipos de dados em Java 

Os tipos primitivos (ou "simples") em Java são (todos os outros tipos são objectos):

Tipo	Descrição	Formato
Inteiros
byte	Byte-length integer	8-bit two's complement [-27, 27-1]
short	Short integer	16-bit two's complement [-215, 215-1]
int	Integer	32-bit two's complement [-231, 231-1]
long	Long integer	64-bit two's complement [-263, 263-1]
Reais
float	Single-precision floating point	32-bit IEEE 754
double	Double-precision floating point	64-bit IEEE 754
Outros tipos
char	A single character	16-bit Unicode character
boolean	A boolean value (true or false)	true or false

As variáveis são declaradas de um modo semelhante ao C (no entanto deve notar-se que, à semelhança do C++, podem ser declaradas variáveis a meio do código). Tal como no C, as variáveis têm um âmbito limitado:

class MinhaClasse {
    // variáveis globais - válidas em todos os métodos da classe
    ...
    public void metodoA( argumentos ) {
       // variáveis locais - validas dentro do método onde estão definidas
       for ( ... ) {
            // variáveis temporárias - validas apenas no código dentro do ciclo
        }
        ...
    }
    ...
}

Exemplo demonstrando alguns dos limites dos tipos básicos do Java:

public class MaxVariablesDemo {
    public static void main(String args[]) {

        // integers
        byte largestByte = Byte.MAX_VALUE;
        short largestShort = Short.MAX_VALUE;
        int largestInteger = Integer.MAX_VALUE;
        long largestLong = Long.MAX_VALUE;

        // real numbers
        float largestFloat = Float.MAX_VALUE;
        double largestDouble = Double.MAX_VALUE;

        // other primitive types
        char aChar = 'S';
        boolean aBoolean = true;

        // display them all
        System.out.println("The largest byte value is " + largestByte);
        System.out.println("The largest short value is " + largestShort);
        System.out.println("The largest integer value is " + largestInteger);
        System.out.println("The largest long value is " + largestLong);

        System.out.println("The largest float value is " + largestFloat);
        System.out.println("The largest double value is " + largestDouble);

        if (Character.isUpperCase(aChar)) {
            System.out.println("The character " + aChar + " is upper case.");
        } else {
            System.out.println("The character " + aChar + " is lower case.");
        }
        System.out.println("The value of aBoolean is " + aBoolean);
    }
}

Resultado da execução:
The largest byte value is 127
The largest short value is 32767
The largest integer value is 2147483647
The largest long value is 9223372036854775807
The largest float value is 3.40282e+38
The largest double value is 1.79769e+308
The character S is upper case.
The value of aBoolean is true

Em Java as constantes são variáveis declaradas com a palavra-chave final.

final int a = 10;
int b = 15;

// a = 11; -> iria dar um erro
b = 11; // atribuição válida

Em Java a conversão de dados entre variáveis é automática quando:

• As variáveis são de tipo compatível
• A variável de destino tem um tipo que é "maior" do que a de origem

Quando isso não acontece, temos de usar uma conversão explícita, denominada cast:

• var = (tipo-var-destino) var2

Exemplos:

long a = 1;
int b = 2;

a = b; // Conversão válida
//b = a   Conversão inválida
b = (int) a; // Conversão válida

Em Java os arrays são objectos, mas o acesso aos seus valores é idêntico ao C.

int nr_dias_mes[] = new int[12];
int matriz[][] = new int[100][10];
char vogais[]={'a','e','i','o','u'};

// Exemplo de alteração de valores
nr_dias_mes[0]=31;
nr_dias_mes[1]=28;

Tal como os arrays, em Java as strings são objectos, e têm uma série de métodos já definidos.

String s = "Hello World";

s = s + " !";
System.out.println(s);
System.out.println("Posicao 4 = " + s.charAt(4));
System.out.println("Tamanho = " + s.length());

Operadores Aritméticos e Relacionais 

São usados operadores semelhantes ao C:

Operador	Explicação
Operadores matemáticos
+	Soma
-	Subtracção
*	Multiplicação
/	Divisão
%	Módulo (resto da divisão inteira)
Operadores unários
-	Complemento binário
&	AND binário
|	OR binário
^	XOR binário
<<, >>	shift binário
Operadores relacionais
==	... igual a ...
!=	... diferente de ...
<	... menor que ...
<=	... menor ou igual a ...
>	... maior que ...
>=	... maior ou igual a ...
Operadores lógicos
!	Negação (NOT)
&	Conjunção (AND)
|	Disjunção (OR)
&&, ||	AND e OR antecipados (expressão lógica é avaliada antes de terminar)

Tal como no C, são válidas construções como ++var, var++ ou var1+=var2
 

Instruções de controle de fluxo 

As instruções são em tudo semelhantes ao C:

Expressão	Tipo	Sintaxe	Exemplo
while	ciclo	while (expressão-de-teste) {   código };	int i = 5; while (i>0) { i--; }
do while	ciclo	do {   código } while (expressão-de-teste);	int i = 5; do { i--; } while (i>0);
for	ciclo	for (código-inicial;expr-de-teste;código-entre-iterações) {   código };	for (i=0; i<5; i++) { System.out.println(i); }
if	decisão	if (expressao-de-teste) {   código };	if (a>max) { max=a }
?	decisão	expressão-de-teste ? valor-verdadeira : valor-falsa	max = a>b ? a : b
switch	decisão	switch (variável) {   case c1: /* Bloco variável==c1 */         código         break;   (...)   default: /* Bloco por defeito */         código         break; }	switch (i) { case 1: System.out.println("um"); break; case 2: System.out.println("dois"); break; default: System.out.println("outro numero"); break; }
break	salto	break [nome-label] ;	/* supondo que v1 e v2 estão ordenados, verificar se algum número de v1 está em v2*/ boolean numberInArray(int v1[], int v2[]) { int i, j; ciclo1: for (i=0; i<v1.length; i++) { if (i>1 && (v1[i]==v1[i-1])) continue; for (j=0; j<v2.length; j++) if (v1[i] == v2[j]) break ciclo1; else if (v1[i] > v2[j]) break; } return (i<v1.length); }
continue	salto	continue [nome-label] ;
label	salto	nome-label:
return	salto	return valor;

nota: [ expr ] significa que expr é opcional

Objectos e Classes 

Uma classe é definida usando a palavra reservada class com a seguinte sintaxe:

class NomeDaClasse {
    declaração-de-variáveis;
    declaração-de-métodos;
}

Segue o exemplo de uma classe muito simples, contendo apenas dois métodos.
A classe Interruptor pretende modelar um vulgar comutador que tenha duas posições: "ligado" e "desligado":

class Interruptor {
    boolean ligado;

    void actuar(boolean estado) {
        ligado=estado;
    }

    void mostrarEstado() {
        if (ligado) {
            System.out.println("O interruptor está LIGADO");
        } else {
            System.out.println("O interruptor está DESLIGADO");
        }
    }
}

Veja-se também um exemplo de uso dessa classe:

Interruptor i = new Interruptor();
i.Actuar(true);
i.MostrarEstado();

Acesso às variáveis e métodos de classes 

Em Java, podem estar os seguintes qualificadores antes de um método ou variável de uma classe:
 

Accessível em:	public	protected	default	private
mesma classe	Sim	Sim	Sim	Sim
classe do mesmo package	Sim	Sim	Sim	Não
sub-classe num package diferente	Sim	Sim	Não	Não
não sub-classe em package diferente	Sim	Não	Não	Não

Baseado em material didático de Pedro Ribeiro (DCC-FCUP)