Mini Curso de Java – Parte 1 15


Java Logo

Olá pessoal. Estou começando hoje um mini curso de Java que terá 11 partes. Ele é voltado para iniciantes, porém é recomendado que ao estudá-lo, você já tenha pelo menos algum conhecimento em lógica de programação. Então, vamos lá!

Sintaxe da Linguagem Java

Introdução
A linguagem Java, desenvolvida pela Sun Microsystems em 1990, permite a codificação de aplicações complexas que podem ser executadas, sem modificações em diferentes plataformas, ou seja, as aplicações são portáveis. Mas antes de serem executados os programas precisam ser compilados.

Os programas fontes são armazenados em arquivos .JAVA, enquanto os programas compilados são armazenados com a extensão .CLASS e por sua vez são arquivos binários e não arquivos texto como os .JAVA.

Enunciados e comentários
Os enunciados podem ocupar uma ou mais linhas. Quando ocupam uma unica linha, são identificados pelos caracteres // que indicam que o conteudo dura até o final daquela linha. Já no caso de comentários em mais de uma linha, utiliza-se o par de caracteres /* (inicio) e */ (fim). O comentário por sua vez dura até os caracteres */ serem encontrados. A seguir exemplos de comentários.

// Calcula valores de coordenados x e y
// valores são inteiros
/* Calcula valores das coordenadas x e y
Valores são inteiros */

Os enunciados em um programa Java são sempre terminados por ponto e virgula e podem ser agrupados, através de chaves, se forem logicamente relacionados. Em uma mesma linha de código pode existir mais de um enunciado. A seguir, exemplos:

a = b + c; // um enunciado na linha
x = 2 * y; z = w+v; // dois enunciados na linha

Variáveis e constantes
As variáveis e constantes podem ser:
boolean (true ou false);
char (código caracter com 16bits);
byte (8 bits, de -128 a 127);
short (16bits, de -32768 a 32767);
int (32bits, de -2147483648 a 2147483647);
long (64bits, de -9223372036854775808L a 9223372036854775808L);
float (32bits, de +/-1.4e-45F a +/-3.4e38F);
double (64bits, de +/-4.9e-324 a +/-1.79e308);

A palavra-chave FINAL declara constantes e especifica seus valores. A seguir exemplos de enunciados que declaram variáveis e constantes.

final int FATOR = 10; // constante do tipo int
float a = 100.32; // variavel do tipo float inicializada
double saldo; // variavel do tipo double
long minimo, maximo; // variaveis do tipo long

As constantes devem ser inicializadas no momento de sua declaração. Já no caso de variáveis, a inicialização é opcional. Se a variável não for inicializada, esta assumirá, dependendo do tipo, um valor default.

Boolean false
char \u0000
int 0
double ou float +0.0d ou +0.0f

Os caracteres ocupam 16bits e não 8bits, como em outras linguagens. São representados segundo o padrão Unicode/ISO 10646, o qual define como devem ser representados em 16bits os caracteres usados em diferentes idiomas.

Em Java a declaração de variáveis segue o seguinte formato:
tipo nome = valor;

Onde tipo é a definição da variável, nome é o alias que será usado apatir de agora para se chamar essa variável, o símbolo = é chamado de operador de atribuição e o valor é o conteúdo que será armazenado na variável. O valor e o operador podem ser omitidos, mas uma variável não pode ser usada antes que receba um valor.

Operadores
Os operadores aritiméticos são:
++ (incremento)
(decremento)
* (mutiplicação)
/ (divisão)
% (modulo [resto da divisão])
+ (adição)
(subtração)

Nos exemplos a seguir, vários operadores são usados em expressões aritméticas.
a = b + c – d;
e = f / g * h;

Os operadores de incremento e decremento merecem explicação mais detalhada. Estes operadores podem ser pré ou pós-fixados. Um operador pré-fixado atua antes do valor a ser usado na expressão, enquanto que um operador pós-fixado atua depois do valor a ser usado na expressão. No exemplo a seguir, pode-se verificar o código equivalente ao operador de incremento pré ou pós-fixado.
a = b++ + c; equivale a: a = b + c; b = b +1;
a = ++b + c; equivale a: b = b + 1; a = b + c;

Existem mais alguns tipos de operadores lógicos, listados a seguir, que possibilitam comparações.
! Não
< Menor que
> Maior que
>= Maior ou igual que
<= Menor ou igual que
instanceof Instancia de
== Igual
!= Diferente de
&& E
|| OU

Exemplos:
If ((a > b) && (c < d)) // se a maior que b e c menor que d
If (x == y) // se x igual a y
If (z != w) // se z diferente de w

Existem operadores de atribuição simples e compostos. O operador de atribuição simples é representado pelo caracter = (igual) e os operadores de atribuição compostos são representados por: +=, -=, *=, /=, %=. A seguir, exemplo de expressões com operadores compostos e seus códigos equivalentes.
x += y; // x = x + y;
z -= w; // z = z – w;

Controle de fluxo
As atribuições para controle do fluxo de execução de um programa são: if-else, ?:, switch-case, break, continue e return.

If-else: o par de instruções if-else possibilitam a execução de condições de enunciados, fazendo com que os enunciados após a instituição if sejam executados desde que a condição testada seja verdadeira. A seguir, exemplo onde a soma das variáveis ocorrerá apenas se o valor da variável x for maior que o valor da variável y.
If (x > y)
x = x + y;
// executado se o teste for verdadeiro

A instrução else é opcional. Os enunciados após a instrução else são executados desde que a condição testada seja falsa. A seguir, exemplo onde as variáveis serão somadas se o teste for verdadeiro e serão subtraídas se o teste for falso.
If ( x > y )
x = x + y;
else
x = x – y;

Pode-se agrupar vários enunciados, através de chaves. No exemplo abaixo os dois
enunciados serão executados se o teste for verdadeiro.
If ( x == y ){
x = a + b;
y = c – d;
}

Testes mais complexos podem ser realizados usando-se várias instruções if-else, conforme o exemplo:
If ( x > y)
x = x + y;
else if ( x > z)
x = x + z;
else if ( x > w)
x = x + w;

Condicional ?: O operador condicional substitui as instruções if-else em situações que se deseja, em função de uma condição, selecionar o valor resultante de uma dentre suas expressões. O operador é colocado à direita de uma expressão condicional e à esquerda de duas expressões separadas por dois pontos (:).
nome = (expressao_condicional) ? expressao1 : expressão_2;

Se a condição testada for verdadeira, será armazenado o valor resultante da expressão_1 na variável à esquerda do operador de atribuição. Se for falsa, será armazenado o valor resultante da expressão_2 na variável à esquerda do operador de atribuição. O exemplo a seguir mostra o código equivalente usando-se as instruções if else.
If ( expressão_condicional){
nome = expressão_1;
}else{
nome = expressão_2;
}

No exemplo seguinte, se o valor da variável x for menor que o valor da variável y, será atribuído a z o valor resultante da soma. Caso contrario, será atribuído a z o valor resultante da subtração.

Switch-case: As instruções switch-case simplificam o código quando são necessários muitos testes. Em vez de serem utilizadas diversas instruções if-else, é usada uma única instrução switch com varias instruções case. Estas instruções possibilitam que, de acordo com o valor resultante de uma expressão, seja executado um determinado conjunto de enunciados.
switch (expressao){
case constante_1: enunciado…;
break;
case constante_n: enunciado…;
break
default: enunciado…;
break;
}

A cada instrução case há uma constante associada, que será comparada ao valor resultante da expressão na instrução switch. O exemplo seguinte mostra se o valor resultante da expressão é 10, 20 ou 30. Caso o valor da expressão não corresponda aos valores testados, a execução do programa continuara no enunciado seguinte ao bloco associado ao switch.
switch ( temperature + media ){
case 10: controlador.aumentarTemp(); break;
case 20: controlador.reduzirTemp(); break;
case 30: controlador.ativarAlarme(); break;
}

A instrução break faz com que o switch seja abandonado após a execução dos enunciados associados ao case cuja constante é igual ao valor da expressão testada.

A palavra-chave default é opcional e tem por objetivo especificar quais os enunciados que serão executados caso o valor da expressão não corresponda a nenhum dos valores associados às instruções case.

Controle de repetição
Pode se executar enunciados repetidamente sob controle das instruções while, dowhile e for.

While: A instrução while possibilita a execução repetida de um conjunto de enunciados enquanto uma condição for verdadeira. Antes da execução dos enunciados, a condição é avaliada. Se for verdadeira, os enunciados serão executados. Caso contrário, o fluxo será desviado para a instrução seguinte ao bloco associado ao while. Ao final de cada execução do bloco, a condição será novamente avaliada. Este processo continua até que a condição seja falsa. A seguir, exemplo onde os enunciados são executados enquanto x for maior do que y.
while ( x > y ){
x = x + w;
z = b + f;
}

Do-while: As instruções do-while possibilitam que os enunciados sejam executados enquanto uma condição for verdadeira. Qual é, então, a diferença entre as instruções do-while e while ? Enquanto o while testa a condição antes da execução dos enunciados, o do-while só testa a condição depois da execução. O do-while é menos genérico do que o while, sendo o seu uso interessante quando os enunciados precisam
ser executados pelo menos uma vez. Sua sintaxe é descrita abaixo.
do{
enunciado_1;
….
enunciado_2;
} while ( condicao );

For: Outra forma de controlar a execução repetida de enunciados é usando a instrução for. Esta instrução é particularmente interessante quando se deseja que os enunciados sejam executados uma quantidade específica de vezes. A instrução contem três expressões separadas por ponto-e-vírgula : a primeira inicializa uma variável para controle da repetição; a segunda é um teste que determina se a repetição continuará ou não; e a ultima é usada para alterar o valor da variável para controle de repetição.
for (n = 0; N < 10; n++ ){
x = y + z;
b = c – d;
}

As expressões na instrução for podem ser omitidas, desde que sejam mantidos os caracteres ponto-e-vírgula (;), Por exemplo, se o bloco de enunciados deve ser sempre executado, usa-se o seguinte código:
for ( ; ; ){
enunciado_1;
enunciado_2;
}

O código anterior é útil, por exemplo em programas servidores, onde varias atividades são realizadas pelos enunciados controlados pelo for, tais como:
· Aguardar solicitação de serviço;
· Executar serviço;
· Enviar resposta para quem solicitou; e
· Voltar a aguardar uma nova solicitação de serviço;

Semana que vem estarei de volta com a parte 2 do Mini Curso de Java: Classes, Construtores e Objetos. Até lá! 😉

Últimos 5 artigos de Tiago Souza

Sobre Tiago Souza

De Campinas-SP, bacharel em Ciência da Computação pela Anhanguera Educacional. Técnico em Processamento de Dados pelo Cotuca é desenvolvedor Web e trabalhou dois anos com desenvolvimento PHP e Java. Atualmente trabalha como desenvolvedor .Net (C#). Utilizando metodologia SCRUM, Também desenvolve aplicativos para Android por prazer.

Deixe uma resposta

15 pensamentos em “Mini Curso de Java – Parte 1