JAVA - Engenheiro de Computação · ao nome que aparece após a palavra class na primeira linha do...

2

Indice Introdução ..................................................................................................................................................... 3

Digitando o programa ................................................................................................................................... 3

Compilando o código fonte ........................................................................................................................... 3

Executando o código ..................................................................................................................................... 4

Entendendo a estrutura do programa .......................................................................................................... 4

Mais exemplos .......................................................................................................................................... 5

Usando variáveis ........................................................................................................................................... 6

Introduzindo comentários no código ............................................................................................................ 7

Tipo Boolean ................................................................................................................................................. 8

Tipos de dados inteiros ................................................................................................................................. 9

Operações com inteiros .............................................................................................................................. 10

Tipo caracter ............................................................................................................................................... 11

Tipos de ponto flutuante ............................................................................................................................ 11

Vetor ........................................................................................................................................................... 12

Classes ......................................................................................................................................................... 14

Objetos ........................................................................................................................................................ 15

Chamando métodos .................................................................................................................................... 16

Declarando métodos ................................................................................................................................... 16

Moderadores de Acesso ............................................................................................................................. 17

Modificador do Método .............................................................................................................................. 18

Tipo de Valor de Retorno: ........................................................................................................................... 18

Conversão entre tipos de dados ................................................................................................................. 19

Execução Condicional ................................................................................................................................. 21

Execução Seletiva de Múltiplos Comandos ................................................................................................ 24

Execução Seletiva por Valores .................................................................................................................... 24

Laço de iteração enquanto/faça ................................................................................................................. 25

Laço de iteração faça/enquanto ................................................................................................................. 26

Laço de iteração com contagem ................................................................................................................. 27

Break e continue ......................................................................................................................................... 28

Bibliografia .................................................................................................................................................. 29

3

Introdução

Já se tornou clássica a idéia de que para aprender uma nova linguagem de programação não se

deve ir direto à descrição sua formal. Ao invés disso, é melhor examinar cuidadosamente um

pequeno programa escrito nessa linguagem, o mais simples possível, mas que permita "quebrar o

gelo". Isso faz sentido pois, por exemplo, quando vamos aprender Inglês, ou outro idioma

qualquer, não iniciamos com a leitura compenetrada de um livro de gramática, mas aprendemos

algumas estruturas simples e procuramos exercitá-las, adiando o estudo rigoroso para quando

estivermos suficientemente maduros. Ao compreender as diversas partes componentes do

exemplo, já teremos dado um grande passo para podermos escrever qualquer programa.

Seguindo essa linha, apresentamos nosso primeiro programa, o clássico "Alô pessoal!". O

objetivo deste programa é simplesmente escrever na tela a frase "Alô pessoal!". Vejamos como é

o código fonte:

public class AloPessoal {

public static void main(String args[]) {

System.out.println("Alo pessoal!");

}

}

Digitando o programa

Que tal colocarmos a mão na massa e digitarmos esse programinha? Para isso, é recomendável

utilizar um editor de texto simples como o Notepad ou Bloco de Notas do Windows. Se estiver

no Unix, use preferencialmente o TextEdit ou o vi. O nome do arquivo deve ser exatamente igual

ao nome que aparece após a palavra class na primeira linha do programa e dever ter .java como

sufixo. Assim sendo, o nome deverá ser "AloPessoal.java". Cuidado para digitar corretamente as

maiúsculas e minúsculas, pois a linguagem Java é sensível ao tipo de caixa das letras.

Compilando o código fonte

Para criar o código binário, chamamos o compilador Java através da linha de comando, do

seguinte modo:

javac AloPessoal.java

Com isso, será criado um arquivo binário (desde que tudo corra bem) com mesmo nome do

arquivo original, mas com sufixo .class no lugar de .java. No nosso caso, teríamos um arquivo

AloPessoal.class. Entre as (muitas) coisas que poderiam dar errado nesse momento, o código

fonte pode conter erros. Esse não deverá ser o caso, se tiver digitado o programa exatamente

como aparece acima. Se, porém, o compilador emitir mensagens de erro, será preciso identificar

as linhas que estão incorretas, corrigí-las no editor, e chamar o compilador novamente. As linhas

que contém algum tipo de incorreção são listadas pelo compilador juntamente com seu número,

facilitando sua localização no editor.

4

Executando o código

Para podermos executar o programa é necessário chamar o interpretador Java, pois, como vimos,

os bytecodes foram feitos para rodar em uma Java Virtual Machine. Podemos fazê-lo do

seguinte modo:

java [nome da classe]

onde [nome da classe] é o nome do arquivo sem o sufixo .class. Em nosso caso, este será

AloPessoal. Ao executar o programa, ele deverá exibir na tela a frase:

Alo pessoal!

Se isto não ocorrer, volte atrás e verifique se o programa foi digitado exatamente como aparece

na listagem acima.

Este é um programa muito simples. Porém, a boa compreensão das estruturas presentes nele

deverá permitir a programação fluente em Java em pouco tempo.

Entendendo a estrutura do programa

Todo programa Java, deve conter ao menos uma declaração da forma

public class [nome] {


...

}

}

Onde [nome] é o nome da classe e a parte "..." é o código Java válido, a ser executado no

programa. O nome de uma classe é um identificador, como qualquer outro presente no programa,

porisso não deve conter espaços ou outros caracteres gráficos, isto é, deve ser um nome

composto de uma seqüência de caracteres que seja válida para um identificador. Outros

exemplos de identificadores são nomes de variáveis, nomes de comandos, etc.

Vamos adiar um pouco a complicação sobre o que vem a ser uma classe, pois isso depende de

alguns conceitos da programação orientada a objetos. Por hora, vamos apenas aceitar que todo

programa Java deve conter ao menos uma classe, e que é dentro de uma classe que vão os dados

e os procedimentos. Notemos ainda que todo programa Java (mas não as applets) deve ter uma

classe dotada de um procedimento chamado main. Os procedimentos em Java são chamados

métodos. Os métodos encerram um conjunto de declarações de dados e de comandos que são

executados mediante a chamada do método por seu nome. Vamos estudar os métodos em detalhe

mais adiante. O método main é o ponto onde se dá o início da execução do programa, isto é, um

método chamado automaticamente pela JVM.

Voltando ao nosso programinha AloPessoal, o código a ser executado é

http://www.dm.ufscar.br/~waldeck/curso/java/part23.html

5

System.out.println("Alo pessoal!");

System.out.println é o nome de uma função que serve para escrever informações textuais na

tela. Os dados a serem escritos, devem estar delimitados entre os parênteses "(" e ")". "Alo

pessoal!" é uma frase. Em computação, uma palavra ou uma frase que tenha função literal é

denominada string. Em Java, a representação de uma string constante se dá colocando os

caracteres entre aspas, por exemplo: "Imagem", "Rio de Janeiro", "Brasília", etc, são strings

constantes.

Note que existe um ; (ponto e vírgula) no final da linha, logo após o ")". Em Java, é obrigatório

colocar um ponto e vírgula após cada comando. Isso porque um comando pode ser quebrado em

múltiplas linhas, sendo necessário sinalizar de algum modo onde é que o comando termina.

Java é sensível ao tipo de caixa, isto é, distingue caixa alta (maiúsculo) da caixa

baixa (minúsculo). Os programadores acostumados a linguagem C e C++ vão certamente sentir-

se em casa; porém os programadores acostumados à linguagem PASCAL devem ficar mais

atentos.

Mais exemplos

Podemos escrever "Alo pessoal!" escrevendo primeiro, "Alo " e depois, "pessoal!". Para isso, o

programa deve ser alterado da seguinte forma:

public class Alo {


System.out.print("Alo ");

System.out.println("pessoal!");

}

}

Para escrever dados genéricos na tela, existe o comando System.out.print que escreve o dado

e mantém o carro na mesma linha. Há também o System.out.println que escreve dados e

muda o carro para a próxima linha.

Podemos concatenar dois ou mais strings usando o operador "+". Por exemplo,

"Alo " + "pessoal!"

é o mesmo que "Alo pessoal!". Para escrever um número, basta escrever [string]+n onde

[string] é um string qualquer e n é um número. Por exemplo:

public class Numero {


System.out.println("O valor é " + 29);

}

}

Como o lado esquerdo da expressão é um string, 29 é convertido para string "29" e é

concatenado com "O valor é ". Compilando e executando esse exemplo como fizemos

anteriormente, devemos obter na tela:

6

O valor é 29

Observemos que os comandos System.out.print e System.out.println escrevem uma

informação de cada vez. Desta forma, precisamos usar "+" para unir "O valor e " com 29 para

formar uma única string. No exemplo acima, nada impede que os dados sejam escritos em duas

etapas: primeiro, "O valor e " e depois, 29. Neste caso, teríamos:



System.out.print("O valor e ");

System.out.println(29);

}

}

Entretanto, a primeira abordagem parece mais razoável pois torna a programação mais clara e

concisa, além de economizar comandos.

Usando variáveis

Uma variável é simplesmente um espaço vago, reservado e rotulado para armazenar dados. Toda

variável tem um nome que a identifica univocamente e um valor, que corresponde à informação

a ela atribuida. Por exemplo, int n; especifica que n é o nome de uma variável que pode

armazenar um número inteiro como valor. Em geral, num contexto onde aparece o nome de uma

variável ocorre a substituição por seu valor. O valor de uma variável pode mudar muitas vezes

durante a execução de um programa, por meio de atribuições de valor.

Há diversos tipos de variáveis em Java, correspondendo aos vários tipos de dados aceitos. A

discussão sobre esses tipos de dados será feita no próximo capítulo. Antes porém, vamos fazer

um pequeno programa que declara uma variável interira, atribui a ela uma constante, e imprime

seu valor na tela.



int n;

n = 17+21;

System.out.println("O valor numérico é " + n);

}

}

O local onde uma variável está declarada é extremamente importante. Uma variável é conhecida

apenas dentro de algum escopo. Por exemplo, uma variável declarada no escopo de uma classe

(fora de um método) é conhecida por qualquer método que esteja declarado dentro dessa mesma

classe, enquanto uma variável declarada no escopo de um procedimento é conhecida apenas por

esse procedimento. Há ainda outros tipos de escopo, como veremos mais adiante.

O sinal "=" é um operador, utilizado para atribuir um valor a uma variável. Por exemplo, n = 1;

faz com que o valor 1 seja armazenado na variável n. Há também os operadores usuais de adição,

subtração, multiplicação e divisão de números. Estes são representados pelos símbolos "+ ", "-",

"*" e "/", respectivamente.


7

Ao executar o programa acima (claro, depois de compilá-lo), ele escreve

O valor numerico é 38

Introduzindo comentários no código

Um comentário é uma porção de texto que não tem função para o compilador Java, mas é útil ao

leitor humano. Assim sendo, um comentário é identificado mas ignorado completamente pelo

compilador Java. A utilidade dos comentários é óbvia: deve conter explicações sobre um

particular desenvolvimento do código, permitindo ao leitor compreender claramente o que se

deseja realizar.

Os comentários são introduzidos no código Java de duas formas distintas:

Colocado em qualquer parte do programa e delimitado entre "/*" e "*/".

Escrevendo "//" antes do comentário, que se estenderá até o final da linha.

Por exemplo, o código:

//

// Este é um exemplo de como somar dois numeros

//


public static void main(String args[]) { /* Método principal */

double x,y; // estes sao numeros reais de dupla precisao

// System.out.print("x = 2.0"); /* inicializando o "x" */

x = 2;

y = 3.0; /* iniciando o y, e fazendo y = y+x; */ y = y + x;

// escrevendo a soma

System.out.println("x+y = " + (x+y));

}

} /* fim de Numero */

é equivalente ao código:



double x,y;

x = 2;

y = 3.0; y = y + x;

System.out.println("x+y = " + (x+y));

}

}

O trabalho com computadores, desde os mais simples como escrever mensagens na tela, até os

mais complexos como resolver equações ou desenhar imagens tridimensionais em animação,

consiste essencialmente em manipulação de dados. Os dados representados em um computador

podem ser números, caracteres ou simples valores.

8

A linguagem Java oferece diversos tipos tipos de dados com os quais podemos trabalhar. Este

capítulo cobrirá os tipos de dados mais importantes. Na verdade há basicamente duas categorias

em que se encaixam os tipos de dados: tipos primitivos e tipos de referências. Os tipos primitivos

correspondem a dados mais simples ou escalares e serão abordados em detalhe no que segue,

enquanto os tipos de referências consistem em arrays, classes e interfaces. Estes serão vistos em

capítulos subseqüêntes.

Eis uma visão geral dos tipos que serão abordados neste capítulo:

Tipo Descrição

boolean Pode assumir o valor true ou o valor false

char Caractere em notação Unicode de 16 bits. Serve para a armazenagem de dados

alfanuméricos. Também pode ser usado como um dado inteiro com valores na faixa

entre 0 e 65535.

byte Inteiro de 8 bits em notação de complemento de dois. Pode assumir valores entre -2

7=-

128 e 27-1=127.

short Inteiro de 16 bits em notação de complemento de dois. Os valores possívels cobrem a

faixa de -2-15

=-32.768 a 215

-1=32.767

int Inteiro de 32 bits em notação de complemento de dois. Pode assumir valores entre -

231

=2.147.483.648 e 231

-1=2.147.483.647.

long Inteiro de 64 bits em notação de complemento de dois. Pode assumir valores entre -2

63

e 263

-1.

float Representa números em notação de ponto flutuante normalizada em precisão simples

de 32 bits em conformidade com a norma IEEE 754-1985. O menor valor positivo

represntável por esse tipo é 1.40239846e-46 e o maior é 3.40282347e+38

double Representa números em notação de ponto flutuante normalizada em precisão dupla de

64 bits em conformidade com a norma IEEE 754-1985. O menor valor positivo

representável é 4.94065645841246544e-324 e o maior é 1.7976931348623157e+308

Ao contrário do que acontece com outras linguagens de programação, as características dos tipos

de dados listados acima idependem da plataforma em que o programa deverá ser executado.

Dessa forma, os tipos de dados primitivos são realmente únicos e garantem a capacidade de

intercâmbio de informações entre diversos tipos de computadores, aliviando o programador da

preocupação e da árdua tarefa de converter dados em formatos apropriados para a portagem.

Tipo Boolean

Este é o tipo de dado mais simples encontrado em Java. Uma variável booleana pode assumir

apenas um entre dois valores: true ou false. Algumas operações possíveis em Java como a<=b,

x>y, etc têm como resultado um valor booleano, que pode ser armazenado para uso futuro em

variáveis booleanas. Estas operações são chamadas operações lógicas. As variáveis booleanas

são tipicamente empregadas para sinalizar alguma condição ou a ocorrência de algum evento em

um programa Java. Por exemplo:

9

boolean fim_do_arquivo = false;

é a declaração de uma variável do tipo boolean, cujo nome é fim_do_arquivo. O valor false à

direita do sinal "=" indica que a variável recebe esse valor como valor inicial. Sem essa

especificação o valor de uma variável é impredicável, podendo ser qualquer um dos valores

possíveis para seu tipo (neste caso true ou false).

Aproveitando o ensejo, há nessa linha a essência da declaração de qualquer variável em Java:

1. Informar o tipo de dado que deseja declarar (boolean)

2. Informar o nome que será usado para batizar a variável (fim_do_arquivo)

3. Atribuir à variável um valor inicial (= false)

4. Terminar a declaração com um ponto-e-vírgula ";".

Tipos de dados inteiros

Os tipos de dados primitivos byte, int, char, short e long constituem tipos de dados inteiros.

Isso porque variáveis desses tipos podem conter um valor numérico inteiro dentro da faixa

estabelecida para cada tipo indiivdual. Por exemplo, um byte pode conter um inteiro entre -128

e 127, enquanto um short pode conter um valor entre -32.768 e 32.767. Já o tipo long é

suficiente para contar todos os mosquitos do Pantanal Matogrossense.

Há diversas razões para se utilizar um ou outro dos tipos inteiros em uma aplicação. Em geral,

não é sensato declarar todas as variáveis inteiras do programa como long. Raramente os

programas necessitam trabalhar com dados inteiros que permitam fazer uso da máxima

capacidade de armazenagem de um long. Além disso, variáveis grandes consomem mais

memória do que variáveis menores, como short.

Obs: Se alguma operação aritmética cria um resultado que excede um dos limites estabelecidos

para o tipo inteiro empregado, não há qualquer indicação de erro para avisar sobre essa

ocorrência. Ao invés disso, um complemento de dois do valor obtido será o resultado. Por

exemplo, se a variável for do tipo byte, ocorrem os seguintes resultados: 127+1 = -128,

127+9=-120 e 127+127=-2. Entretanto, uma excessão do tipo ArithmeticException é

levantada caso ocorra uma divisão por zero.

Vejamos o seguinte código:

public class Arith

{

public static void main(String args[])

{

byte a = 127;

short b = 32767;

int c = 2147483647;

long d = 9223372036854775807L;

int e = 0;

10

a += 1;

b += 1;

c += 1;

d += 1;

System.out.println("Valor de a = " + a);

System.out.println("Valor de b = " + b);

System.out.println("Valor de c = " + c);

System.out.println("Valor de d = " + d);

d /= e; // Vai dar erro porque e = 0

}

}

com seu respectivo resultado de execução:

Valor de a = -128

Valor de b = -32768

Valor de c = -2147483648

Valor de d = -9223372036854775808

java.lang.ArithmeticException: / by zero

at Arith.main(Arith.java:18)

Seguem abaixo alguns exemplos de declarações de variáveis de tipo inteiro:

byte Contador = 1;

int AnguloEmGraus = -45;

char Indice = 6;

A diferença entre essas declarações e a declaração de dados booleanos vista acima está no tipo de

dado especificado e no valor atribuído a cada variável.

Operações com inteiros

Podemos realizar uma série de operações com os dados do tipo inteiro. A tabela seguinte mostra

uma lista completa.

Operação Descrição

=, +=, -=, *=, /=,

%= Operadores de atribuição

==, != Operadores de igualdade e diferença

<, <=, >, >= Operadores de desigualdade

+, - Operadores unários

11

+, -, *, /, % Adição, subtração, multiplicação, divisão e módulo

+=, -=, *=, /=, %= Operadores de atribuição com adição, subtração, multiplicação, divisão e

módulo

++, -- Incremento e decremento

<<, >>, >>> Operadores de deslocamento de bits

<<=, >>=, >>>= Operadores de atribuição com deslocamento de bits

~ Operador lógico de negação

&, |, ^ Operadores lógicos E, OU e OU-exclusivo

&=, |=, ^= Operadores de atribuição com operação lógica E, OU e OU-exclusivo

Muitos das operações que aparecem na lista acima são familiares e praticamente não requerem

explicação. Há outros, porém, que pode ser um tanto quanto ambíguos. É o caso dos operadores

de atribuição aritméticos. Estes consistem de atalhos para atribuir um novo valor a uma variável

onde esse novo valor depende do valor anterior lá armazenado. Temos assim as seguintes

correspondências:

x += 5 x=x+5

x -= y x = x - y

x *= 2 x = x * 2

z /= 4 z = z / 4

Tipo caracter

Uma variável do tipo char armazena um caractere Unicode. Um caractere Unicode é um

caractere de 16 bits, sendo que de 0 a 225 correspondem aos caracteres do código ASCII (a

tabela ASCII é uma tabela padronizada internacionalmente de associações entre caractere e a sua

representação numérica no computador). Uma constante do tipo caractere é representada

colocando-se entre apóstrofos, ou pelo valor numérico correspondente na tabela Unicode (ou

ASCII), ou ainda, pela sequência '\x' onde x especifica o caractere a ser referido. Esta

especificação de sequência de escape obedece às mesmas convenções do C/C++. Por

exemplo: 'a', 'f', '\n', etc, são constantes do tipo char.

Tipos de ponto flutuante

Em Java, existem duas categorias de de variáveis de ponto flutuante: float armazena valores

numéricos em ponto flutuante de precisão simples e double de precisão dupla.

12

Muitas das operações realizáveis com inteiros (porém não todas) têm análogas para números de

ponto flutuante. Eis um resumo:

Operação Descrição

=, +=, -=, *=, /= Operadores de atribuição

==, != Operadores de igualdade e diferença

<, <=, >, >= Operadores de desigualdade

+, - Sinais unários

+, -, *, / Adição, subtração, multiplicação e divisão

+=, -=, *=, /= Operadores de atribuição com adição, subtração, multiplicação e divisão

++, -- Operadores unários de incremento e decremento

Vetor

Semelhante às liguagens C, C++ e Pascal, a linguagem Java também dá suporte a vetores e

matrizes (arrays) de diversas formas. Os vetores constituem uma forma muito conveniente de

organizar informações em fileira. Por exemplo, podemos formar um vetor com as notas de cinco

alunos de uma sala de aula do seguinte modo:

float nota[] = { 7.8, 8.4, 4.2, 1.8, 6.4 };

Neste caso nota[0] é a nota do primeiro aluno, isto é, 7.8, nota[1] é a nota do segundo, ou seja,

8.4, e assim por diante.

A utilização de vetores e matrizes em Java envolve três etapas:

1. Declarar o vetor ou matriz. Para isto, basta acrescentar um par de colchetes antes ou

depois do nome da variável. Por exemplo:

int ind[];

double A[][],T[][][];

int []nota;

2. Reservar espaço de memória e definir o tamanho. É preciso definir o tamanho do

vetor, isto é, a quantidade total de elementos que terá de armazenar. Em seguida é

necessário reservar espaço de memória para armazenar os elementos. Isto é feito de

maneira simples pelo operador new:

ind = new int[10];

nota = new int[70];

A = new double[10][20];

13

3. Armazenar elementos no vetor ou matriz. Para armazenar uma informação em um dos

elementos de um vetor ou matriz, é necessário fornecer um índice que indique a posição

desse elemento. Por exemplo, para armazenar um valor na quarta posição do vetor nota,

fazemos o seguinte:

nota[3] = 5.2;

Como podemos observar, os índices começam em zero e vão até o número de posições

reservadas, menos um. No vetor nota criado acima, os índices válidos vão de 0 até 69.

Caso haja a tentativa de atribuir um valor a um elemento cujo índice esteja fora desse

intervalo, ocorrerá um erro que impedirá a execução do programa. Por isso, é necessário

um certo cuidado ao manejar com esses índices, garantindo o perfeito funcionamento do

programa.

Existe, porém, um atalho para esses três passos quando desejamos criar um vetor com valores

atribuídos de modo estático. Foi o que fizemos no primeiro exemplo acima, declarando o vetor

nota com as notas de cinco alunos. Nesse caso, espaço suficiente para as notas de cinco alunos

foi reservado e as notas foram guardadas em respectivas posições do vetor.

Entretanto, nem sempre é tão fácil assim. Em geral, estaremos interessados em trabalhar com

vetores muito muito maiores, e cujos elementos sejam provenientes de outras fontes, que variam

com o tempo. Assim, seremos obrigados a seguir os passos acima.

Eis mais alguns exemplos de vetores e matrizes:

// 12 primeiros termos da seqüência de Fibonacci:

long Fibonacci[] = {1,1,2,3,5,8,13,34,55,89,144};

// Tabela de sen(n*pi/6), n=0,1,2,...5

float seno[] = {0.0000,0.5000,0.8660,1.0000,0.8660,0.5000};

// Tabela de log(1+n), n=0,2...99:

double tlog[] = new double[100];

for(int n=0; n<100; n++) tlog[i] = Math.log(1+n);

// Matriz dos coeficientes

double A[][] = { {1,2,3}, {0,1,3}, {0,0,-1} };

Em contraste com a estática dos dados, os métodos definem as ações a serem tomadas em

diversos momentos da execução de um programa. Como em outras linguagens, como C, C++,

Pascal, Fortran, etc, os métodos correspondem aos conceitos comuns de funções, procedimentos

ou subrotinas. Estes são apenas conjuntos ordenados de declarações de dados, comandos e

expressões. Em termos simples, são os métodos que realizam todas as tarefas para as quais o

programa foi escrito, por exemplo, realizar cálculos, resumir informações de um arquivo,

produzir um relatório, criar um gráfico, gerar um filme de animação, etc.

14

Classes

Os métodos, assim como os dados, têm um local de residência, as classes. Mais adiante, vamos

estudar as classes em detalhes. Por hora, precisamos apenas de alguns poucos conceitos para

poder entender os métodos. Pensemos uma classe como sendo um conjunto de dados (variáveis)

e métodos (funções) da forma:

class [nome] {

[dados e métodos]

}

onde [nome] é um identificador que define o nome da classe, e o par de chaves delimita uma

região para declaração de variáveis e métodos. A declaração de variáveis já foi vista

anteriormente no capítulo sobre tipos de dados. Uma classe pode ser privativa ou pública. Uma

classe privativa é declarada como no exemplo acima e é conhecida apenas no escopo delimitado

pelo arquivo que a contém. Como um programa Java pode ser quebrado em múltiplos arquivos

de código fonte distintos, pode ser necessário que as diversas partes integrantes do programa

interajam, trocando dados entre si e chamando métodos umas das outras. Isso torna-se possível

através das classes públicas, as quais são conhecidas por qualquer arquivo fonte que componha o

programa. Para tornar uma classe pública, basta preceder sua declaração pela palavra-chave

public como no seguinte exemplo:

public class [nome da classe] {

[dados e métodos]

}

Há uma convenção em Java que estabelece que deve haver exatamente uma classe pública para

cada arquivo-fonte de que consiste um programa Java, e seu nome deve ser precisamente o nome

do arquivo, sem o sufixo .java. Desse modo, existe uma correspondência biunívoca entre as

classes públicas e os arquivos-fonte que as contém.

Podemos declarar uma classe a partir do chão, com todos os seus dados e métodos, ou podemos

declarar uma classe derivando-a a partir de uma outra já existente. Este é um recurso muito útil,

pois permite aproveitar um esforço de elaboração anterior, aumentando significativamente a

produtividade da programação, e diminuindo o tamanho do código objeto. Suponhamos por

exemplo, que tenhamos declarado previamente a seguinte classe:

class Polígono {

int cx, cy; // Coordenadas do centro do polígono

}

Esta classe define em linhas gerais o que é um polígono, guardando uma única característica

comum a qualquer polígono, isto é, as coordenadas de seu centro. Agora, suponhamos que

desejamos criar uma classe para guardar informações sobre um quadrado. Neste caso, não

precisamos criar uma classe que dê as coordenadas do centro do quadrado assim como as suas

dimensões. Basta fazer simplesmente:

class Quadrado extends Polígono {

int lado; // Comprimento de um lado do quadrado


http://www.dm.ufscar.br/~waldeck/curso/java/part22.html#identificador


15

}

A classe quadrado declarada desse modo se diz uma classe derivada da classe Poligono, da qual

herda os dados (e os métodos) nela contidos. Esta declaração é equivalente a

class Quadrado {

int cx, cy; // Coordenadas do centro do polígono

int lado; // Comprimento de um lado do quadrado

}

Desejando fazer uma classe para representar um retângulo, bastaria fazer então

class Retângulo extends Polígono {

int base, alt; // Base e altura do retângulo

}

Objetos

Uma particular instância de uma classe é chamada objeto. Para entender a diferença entre classes

e objetos, fazemos alusão à metáfora da fábrica de torradeiras. A fábrica de torradeiras não é uma

torradeira, mas define o tipo de produto que sai dela, isto é, as torradeiras. Do mesmo modo a

torradeira não é a fábrica, mas o produto feito por ela. Comparamos as classes às fabricas e os

objetos aos produtos feitos por elas. Grosso modo, podemos dizer que as classes não ocupam

espaço na memória, por serem abstrações, equanto que, os objetos ocupam espaço de memória

por serem concretizações dessas abstrações.

Nas declarações acima, introduzimos algumas classes que permitem representar polígonos.

Porém, não instanciamos nenhuma das classes criando particulares objetos a partir dessas

classes. Por exemplo, a partir da classe quadrado, podemos fazer objetos representando

quadrados de diversos comprimentos laterais, ou retângulos de diferentes dimensões:

Quadrado A, B, C;

Retângulo D;

A.lado = 1; // O quadrado A terá os lados de comprimento 1

B.lado = 2; // O quadrado B terá os lados de comprimento 2

C.lado = 7; // O quadrado C terá os lados de comprimento 7

D.base = 3; // O retangulo D terá base 3 e ...

D.alt = 4; // altura 4, e centrado na origem

D.cx = 0;

D.cy = 0;

As declarações acima são semelhantes às que vimos no capítulo anterior, com excessão de que

no lugar do nome que identifica o tipo de dado estamos usando o nome de uma classe. Neste

exemplo, as classes Quadrado e Retângulo foram empregadas para declarar os objetos (ou

variáveis) A, B, C e D.

16

Em certo sentido as classes complementam os tipos de dados nativos da linguagem Java, com

tipos de dados complexos criados pelo programador. Esse fato, aliado à possibilidade de derivar

classes, tornam as linguagens orientadas a objetos extremamente producentes.

Chamando métodos

Um método entra em ação no momento em que é chamado. Isto pode ocorrer explicitamente ou

implicitamente. A chamada explícita se dá por ordem do programador através da execução de

um comando ou expressão contendo o nome do método. Em nosso programa AloPessoal fizemos

uma chamada explícita do método System.out.println para mostrar um texto na tela do

computador. As chamadas implícitas ocorrem quando o interpretador Java chama um método por

sua própria deliberação. A chamada do método main é um exemplo de chamada impícita. O

interpretador Java chama esse método para dar início à execução do programa.

Declarando métodos

A declaração mais simples que podemos fazer de um método (lembrando que isso deve ser feito

dentro de uma classe) é a seguinte:

void [nome do método] () {

[corpo do método]

}

onde o [nome do método] é um identificador que define o nome pelo qual o método é

conhecido, e [corpo do método] consiste de uma lista ordenada de eclaração de variáveis, de

expressões e de comandos. A primeira palavra-chave, void, define o valor retornado pelo

método, neste caso, nenhum. Podemos usar qualquer tipo de dado válido como valor de retorno

de um método. Nesse caso, ao terminar, o método seria obrigado a devolver um dado do tipo

especificado. Por exemplo,

class Numero {

double x = 1;

void print() {

System.out.println("O valor e " + x);

}

}

define uma classe chamada Numero, a qual contém uma variável x, inicializada com 1, e um

método sem valor de retorno, print, que apenas escreve um texto e o valor de x, através da

chamada do método System.out.println.


17

O par de parênteses adiante do nome do método introduz uma lista (vazia, neste caso) de

argumentos. A chamada de um método pode ser acrescida de parâmetros, os quais são associados

aos seus respectivos argumentos.

Um exemplo de métodos que retornam valores é o seguinte:

class Calculador {

int Soma(int a, int b) {

return a + b;

}

double Produto(double a, double b) {

return a * b;

}

}

Moderadores de Acesso

Os moderadores de acesso são empregados para restringir o acesso a um método. Entretanto,

independentemente do moderador escolhido, um método é sempre acessível, isto é, pode ser

chamado, a partir de qualquer outro método contido na mesma classe. Os moderadores de acesso

existentes em Java são os seguintes:

public: O método declarado com este moderador é público e pode ser chamado a partir

de métodos contidos em qualquer outra classe. Esta é a condição de menor restrição

possível.

protected: O método é protegido pode ser chamado por todas as classes que compõe um

conjunto maior chamado package. Veremos adiante que as packages são um modo

conveniente de organizar diversas classes que estão em estreito relacionamento.

private: O método é privativo da classe que o contém e seu uso é vedado a qualquer

outra classe.

Exemplo:

public class Principal {


numero num = new numero();

num.print1(); // correto

num.print2(); // ilegal

}

}

class numero {

double x = 1;

18

public void print1() {


}

void print2() {


}

}

Modificador do Método

O modificador do método permite especificar algumas propriedades de um método,

determinando como classes derivadas podem ou não redefinir ou alterar o método, e de que

forma esse método será visível.

static: o método é compartilhado por todos os objetos instanciados a partir da mesma

classe. Um método static não pode acessar qualquer variável declarada dentro de uma

classe (salvo se a variável estiver declarada também como static), pois não é capaz de

dicernir entre os diferentes objetos que compartilham esse método.

Tipo de Valor de Retorno:

O tipo de valor de retorno é especificado por uma palavra chave ou nome de classe na declaração

do método, estabelecendo o valor que ele pode devolver.

//Classe de números complexos

class Complexo {

double x, y; // parte real e complexo, respectivamnte

public double Re(double x) { // retorna a parte real

return x;

}

public double Im(double y) { //retorna a parte imaginaria

return y;

}

public void print1(double x, double y) {

System.out.println("(" + x + " + " + y + "x)");

}

}

public class Teste {


double z = 2;

double y = 2;

Complexo complexo = new Complexo();

System.out.print( "O valor de z é ");

complexo.print1(2.0,3.0);

System.out.println( "A parte real de z é = " + complexo.Re(2.0) );

System.out.println( "A parte imaginária de z é = "+

19

complexo.Im(3.2) );

}

}

Ao executar esse programa teríamos a resposta:

O valor de z é (2.0 + 3.0x)

A parte real de z é = 2.0

A parte imaginária de z é = 3.2

Um método que retorna valor, isto é, não declarado como void, deve conter a linha return

...; a qual especifica o valor a ser retornado. Por exemplo, return x; especifica que o valor da

variável x será retornado.

Conversão entre tipos de dados

Ao trabalhar com expressões, salvo quando todos os operando são do mesmo tipo, é inevitável

ter que considerar conversões entre um tipo de dado e outro. Há basicamente dois tipos de

conversões de dados. O primeiro se refere a conversão implicita na qual, os dados são

convertidos automaticamente, praticamente sem a preocupação do programador. Isto ocorre no

caso de conversão de dados de tipo interio para real e de números para strings. Por exemplo:

double x;

int i = 20;

x = i;

Neste caso o valor do inteiro i é convertido automaticamente para um double antes de ser

armazenado na variável x. As regras de conversão implícita empregadas pela linguagem Java são

as seguintes:

os operadores unários ++ e -- convertem um tipo byte e short são convertidos para um

int, e os demais tipos não são afetados

para os operadores binários, as regras são um pouco mais complicadas. Para operações

envolvendo apenas inteiros, se um dos operandos for long, o outro será convertido para

um long antes de realizar a operação, a qual resultará num long. Caso contrário, ambos

os operandos são convertidos para um int e o resultado será também um int, a menos

que o resultado da operação seja grande demais para caber num int. Nesse caso, o

resultado será convertido para um long. Para operações envolvendo números de ponto

flutuante, se um dos operadores for double, o outro será convertido para double antes de

realizar a operação e o resultado será um double. Do contrário, ambos os operando são

convertidos para float, e o resultado será um float.

Algumas vezes, porém, as conversões implícitas não são suficientes para garantir um resultado

esperado em uma expressão. Nesses cados, é importante podermos controlar precisamente a

ocorrência de uma conversão de tipo. Isto pode ser feito por meio de um operador unário de

conversão. Por exemplo:

20

float eventos = 25.7;

float dias = 7.2;

x = (int)(eventos / dias);

O resultado da expressão acima será precisamente 3, isto é a parte inteira de 25.7 dividido por

7.2. A diferença é que o operador de conversão de tipo (int) transformou o valor do quociente

25.7/7.2 em um inteiro, truncando as casas decimais. Note que o operador de conversão é um

operador unário de maior precedência, logo, tivemos de colocar a divisão entre parênteses para

garantir que o resultado dessa divisão formasse um único operando. A conversão entre quaisquer

inteiros e entre inteiros e números de ponto flutuante é permitida. Porém, não é permitido

converter dados do tipo boolean para nenhum outro tipo, enquanto a conversão entre objetos

somente é permitida para classes parentes.

Vejamos ainda um outro exemplo de utilização do operador de conversão de tipo:

int a = 3;

int b = 2;

double x;

x = a / b;

Neste exemplo, desejamos que a variável x tenha o valor do quociente entre a e b. Como x é um

dado de ponto flutuante, presume-se que o resultado desejado neste exemplo seja, digamos,

x=3/2=1.5. Como porém os operandos da divisão são ambos inteiros, o resultado será também

um inteiro, isto é, teremos x = 1.0. Para contornar essa situação, podemos converter

explicitamente um dos operandos para um dado em ponto flutuante, fazendo:

x = (double)a / b;

Observamos que a conversão entre inteiros de maior comprimento para inteiros de menor

comprimento pode causar perda de informação na representação dos valores. Caso o valor a ser

convertido ocupe mais bits do que o tipo da variável recebendo esse valor, então o valor é

truncado.

int l = 393;

byte b;

b = l;

System.out.println("O valor de b é " + b);

Neste exemplo teremos como resultado:

O Valor de b é -119

Por que isso aconteceu? Fica mais fácil de compreender isso se interpretarmos os números acima

na notação binária. O número 393 é representado em base dois pelo número 110001001, que tem

9 bits de comprimento (omitimos os zeros não significativos). Como a variável b é do tipo byte

e seu comprimento é de apenas 8 bits, teremos os 8 primeiros bits da direita para a esquerda

atribuídos a b, isto é, 10001001, que representa o número -119 em base dois, na notação de

complemento de dois.

21

Controle de fluxo é a habilidade de ajustar a maneira como um programa realiza suas tarefas. Por

meio de instruções especiais, chamadas comandos, essas tarefas podem ser executadas

seletivamente, repetidamente ou excepcionalmente. Não fosse o controle de fluxo, um programa

poderia executar apenas uma única seqüência de tarefas, perdendo completamente uma das

características mais interessantes da programação: a dinâmica.

Podemos classificar os comandos aceitos pela linguagem Java em basicamente quatro categorias:

Execução Condicional

A forma mais simples de controle de fluxo é o comando if-else. Ele é empregado para

executar seletivamente ou condicionalmente um outro comando mediante um critério de seleção.

Esse critério é dado por uma expressão, cujo valor resultante deve ser um dado do tipo booleano,

isto é, true ou false. Se esse valor for true, então o outro comando é executado; se for false,

a excecussão do programa segue adiante. A sintaxe para esse comando é

if ([condição])

[comando] // Executado se a condição for true

Uma variação do comando if-else permite escolher alternadamente entre dois outros comandos

a executar. Nesse caso, se o valor da expressão condicional que define o critério de seleção for

true, então o primeiro dos outros dois comandos é executado, do contrário, o segundo.

if([condição])

[comando 1] // Executado se a condição for true

else

[comando 2] // Executado se a condição for false

E se toda uma lista de comandos deve ser executada seletivamente? A esta altura, convém dizer

que há uma maneira bastante conveniente de agrupar longas seqüências de comandos formando

uma unidade lógica. Trata-se da noção de bloco de comandos. Este consiste basicamente de uma

lista de comandos delimitados por chaves { }. Para efeitos de programação, um bloco de

comandos é interpretado como se fosse um único comando. Eis alguns exemplos de blocos de

comandos:

1. {

System.out.print("x = ");

System.out.println(x);

}

2. { temp = y; y = x; x = temp; }

http://www.dm.ufscar.br/~waldeck/curso/java/part26.html#i_cond

22

Desse modo, podemos fazer também a execução seletiva de blocos de comandos conforme

ilustra o seguinte programa para discutir sobre as raízes de uma equação do segundo grau

ax2+bx+c=0:

import java.io.StreamTokenizer;

public class baskhara {


double a, b, c, delta;

StreamTokenizer in = new StreamTokenizer(System.in);

// Requisitando do usuário os dados sobre a equação a ser

// analisada.

//

try {

System.out.println("Digite os coeficientes da equação ax^2+bx+c = 0");

System.out.print("a = "); System.out.flush(); in.nextToken();

a = in.nval;

System.out.print("b = "); System.out.flush(); in.nextToken();

b = in.nval;

System.out.print("c = "); System.out.flush(); in.nextToken();

c = in.nval;

}

catch(java.io.IOException e) {

System.out.println("Falha na entrada dos dados.");

a = 0;

b = 0;

c = 0;

}

// Calculando o discriminante da equação

//

delta = b*b - 4*a*c;

System.out.println( "Equação: ("+a+")x^2+("+b+")x+("+c+")" );

// Decidindo sobre o número de raízes da equação mediante o

// valor do discriminante calculado acima

//

if ( delta > 0 ) { // A eq. tem duas raízes reais

double r, d, x1, x2;

r = Math.sqrt(delta);

d = 2*a;

x1 = ( -b - r ) / d;

x2 = ( -b + r ) / d;

System.out.println("A equação tem duas soluções reais: ");

System.out.println(" x1 = " + x1);

System.out.println(" x2 = " + x2);

}

else

23

if ( delta < 0 ) // A eq. não tem raízes reais

System.out.println("A equação não tem raízes reais.");

else { // A eq. tem uma raiz real dupla

double x;

x = -b / (2*a);

System.out.println("A equação tem uma única raiz real:");

System.out.println(" x1 = x2 = " + x);

}

System.out.println("Fim da discussão.");

}

}

O if-else compacto não é propriamente um comando, mas um operador que realiza avaliação

seletiva de seus operandos, mediante o valor de uma expressão booleana semelhante à do

comando if-else. Se essa expressão for true, então um primeiro operando é avaliado; se for

false então o segundo operando é avaliado. A sua sintaxe é

[expressão condicional] ? [expressão 1] : [expressão 2]

onde [condição condicional] deve resultar em true ou false, [expressão 1] e

[expressão 2] são os operandos, que podem ser expressões quaisquer. O valor resultante da

aplicação do operador if-else compacto é obviamente igual ao valor do operando que tiver sido

avaliado. O tipo desse valor obedece às regras de conversão entre tipos de dados discutida

anteriormente.

Para melhor ilustrar o if-else compacto, consideremos o seguinte comando:

y = x < 1 ? x*x : 2-x;

Este é logicamente equivalente à seguinte seqüência de comandos:

if (x<1) then

y = x*x;

else

y = 2-x;

É importante notar que o if-else compacto é um operador de baixa precedência, logo o uso de

parênteses para separar seus operandos não é necessário (a menos que mais de um desses

operadores esteja presente na mesma expressão). Porém há casos em que o uso de parênteses

para definir claramente os operandos é essencial. Por exemplo, y = |x|*sin(x), podeser

codificado como

y = ( x<0 ? -x : x ) * Math.sin(x); // aqui os parenteses são essenciais.

Sem os parênteses, x * Math.sin(x) seria visto pelo operador if-else compacto como se

fosse um único operando, devido à alta precedência do operador multiplicação.

http://www.dm.ufscar.br/~waldeck/curso/java/part25.html#conversao

24

Execução Seletiva de Múltiplos Comandos

Freqüentemente, desejamos que um único comando (ou único bloco de comandos) de uma lista

seja executado mediante um dado critério. Isso pode ser feito através do aninhamento ou

acoplamento de vários comandos if-else, do seguinte modo:

if ([condição 1])

[comando 1]

else if ([condição 2])

[comandos 2])

else if ([condição 3])

[comando 3]

....

else

[comando n]

A presença do último else, juntamente com seu comando, é opcional. Neste código, o [comando

1] será executado (e os demais saltados) caso a primeira condição seja true, o [comando 2]

será executado (e os demais saltados) caso a primeira condição seja false e a segunda condição

seja true, e assim sucessivamente. O [comando n] (se houver) somente será executado (e os

demais saltados) caso todas as condições sejam false.

Execução Seletiva por Valores

Assim como no caso execução seletiva de múltiplos comandos, há situações em que se sabe de

antemão que as condições assumem o valor true de forma mutuamente exclusiva, isto é, apenas

uma entre as condições sendo testadas assume o valor true num mesmo momento. Nesses casos,

a linguagem Java (como também as linguagem C, C++ e Pascal) provê um comando de controle

de fluxo bastante poderoso. Trata-se do comando swich, cuja sintaxe é a seguinte:

switch([expressão]) {

case [constante 1]:

[comando 1]

break;

case [constante 2]:

[comando 2]

break;

.

.

.

case [constante n]:

[de comando n]

break;

default:

[comando]

}

A [expressão] pode ser qualquer expressão válida. Esta é avaliada e o seu valor resultante é

comparado com as constantes distintas [constante 1], [constante 2], ..., [constante n].

Caso esse valor seja igual a uma dessas constantes, o respectivo comando é executado (e todos

http://www.dm.ufscar.br/~waldeck/curso/java/part26.html#i_select_cond

http://www.dm.ufscar.br/~waldeck/curso/java/part26.html#i_select

25

os demais são saltados). Se o valor for diferente de todas essas constantes, então o comando

presente sob o rótulo default: é executado (e todos os demais são saltados), caso este esteja

presente. Por exemplo:

public class test {


int op;

op = 2;

System.out.print("valor de op eh: "+op)

switch(op) {

case 1:

System.out.println("case 1: op="+op);

break;

case 2:

System.out.println("case 2: op="+op);

break;

case 3:

System.out.println("case 3"+op);

break;

default:

System.out.println("default: op nao esta no limite 1..3");

}

}

}

Laço de iteração enquanto/faça

Freqüentemente, desejamos que uma tarefa seja executada repetidamente por um programa

enquanto uma dada condição seja verdadeira. Isso é possível pela utilização do comando while.

Este comando avalia uma expressão condicional, que deve resultar no valor true ou false. Se o

valor for true, então o comando subjacente é executado; se a expressão for false, então o

comando é saltado e a execução prossegue adiante. A diferença é que após executar o comando

subjacente, a expressão condicional é novamente avaliada e seu resultado novamente

considerado. Desse modo a execução do comando subjacente se repetirá, até que o valor da

expressão condicional seja false. Observe, porém, que a expressão é avaliada antes de uma

possível execução do comando subjacente, o que significa que esse comando pode jamais ser

executado.

while([condição])

[comando subjacente]

Por exemplo:

// Achar o raiz quadrada de 2 pelo metodo de bissecção

public class sqrt2 {


double a, b, x=1.5, erro = 0.05;

a = 1; b = 2; // 1 < (raiz de 2) < 2

while( (b-a) > erro ) {

x = (a+b)/2;

http://www.dm.ufscar.br/~waldeck/curso/java/part26.html#i_loopwhile

26

if (x*x < 2) // x < raiz de 2

a = x;

else // x >= raiz de 2

b = x;

}

System.out.println("Valor aproximado de raiz quadrada de 2: " + x); }}

Uma das observações importantes é sempre certificar que não ocorra o laço infinito (um laço que

nunca para, pois a condição sempre é verdadeira). Caso tenha alguma chance de entrar no laço

infinito, coloque um contador ou user o laço for.

Laço de iteração faça/enquanto

Um outro tipo de laço de repetição, similar ao enquanto/faça, é o laço faça/enquanto. Este é

introduzido por um par de comandos do/while que tem a seguinte sintaxe:

do

[comando]

while([condição]);

Diferente do laço enquanto/faça, este tipo de laço de repetição executa o comando e em seguida

avalia a expressão condicional. A repetição ocorre se o valor dessa expressão for true. Se esse

valor for false, a execução prossegue adiante do while. Vejamos o seguinte exemplo:

public class Menu {


char op;

int i = 0;

double x = 0;

do {

System.out.println("\nOpcoes:");

System.out.println("p - Atribuir: x = 0.5, i = 2");

System.out.println("n - atribuir: x = -0.2, i = -1");

System.out.println("x - ver o valor de x");

System.out.println("i - ver o valor de i");

System.out.println("f - fim");

System.out.print("Sua escolha: "); System.out.flush();

try {

op = (char)System.in.read();

System.in.read(); // Para pegar o 'enter'

}

catch(java.io.IOException e) {

op = 'q';

}

switch(op) {

case 'p':

x = 0.5; i = 2;

break;

case 'n':

x = -0.2; i = -1;

break;

http://www.dm.ufscar.br/~waldeck/curso/java/part26.html#i_loopdowhile

27

case 'x':

System.out.println("\n--> x = " + x);

break;

case 'i':

System.out.println("\n--> i = " + i);

break;

case 'f':

break;

default:

System.out.println("\n--> Opcao invalida");

}

} while(op != 'f');

System.out.println("\nAte logo.");

}

}

Laço de iteração com contagem

Em certas situações, precisamos de laços de repetições nos quais alguma variável é usada para

contar o número de iterações. Para essa finalidade, temos o laço for. Este é o tipo de laço mais

geral e mais complicado disponível na linguagem Java. Sua sintaxe é a seguinte:

for ([expressão 1]; [condição]; [expressão 2])

[comando]

Onde [expressão 1] é chamada expressão de inicialização, [condição] é uma expressão

condicional e [expressão 2] é uma expressão qualquer a ser executado no final de cada iteração.

O laço for acima é equivalente a:

[expressão 1]

while ([condição]) {

[comando]

[expressão 2]

}

Isto que dizer que o laço for avalia inicialmente a expressão de inicialização. Em seguida, avalia

a expressão condicional. Se o valor desta for true, então o comando é executado, a segunda

expressão é avaliada em seguida, e finalmente o laço volta a avaliar novamente a expressão

condicional. Do contrário, se o valor da expressão for false, a execução prossegue adiante do

laço for. Este arranjo é muito conveniente para manter variáveis de contagem, conforme ilustra

o seguinte exemplo:

for (i=0; i<n; i++)

System.out.println("V["+i+"]="+v[i]);

Este código imprime os valores de cada elemento v[i] de um vetor v, para i variando de 0 até n-

1. O operador ++ foi utilizado na ultima expressão do laço for para somar um ao valor da

variável de contagem. Caso necessitássemos de um incremento (ou decremento) maior do que

um, poderíamos usar os operadores += ou -=. Por exemplo, para imprimir todos os números

pares entre de 0 até 10, poderíamos fazer:

http://www.dm.ufscar.br/~waldeck/curso/java/part26.html#i_loopfor

28

for(i=0; i<=10; i+=2)

System.out.println(" " + i);

Tanto a [expressão 1] quanto a [expressão 2] do laço for permitem acomodar múltiplas

expressões, bastando separá-las por vírgula. Por exemplo, a soma de {1/n} n=1,2, .., N pode ser

obtida por:

for (soma=0, n=1; n<=N;n++)

soma += 1/n;

ou ainda por

for(soma=0, n=1; n<=N; soma += 1/n, n++);

Break e continue

O comando break é usado para interromper a execução de um dos laços de iteração vistos acima

ou de um comando switch. Este comando é comumente utilizado para produzir a parada de um

laço mediante a ocorrencia de alguma condição específica, antes da chegada do final natural do

laço.

Exemplo:

// Achar i tal que v[i] é negativo

for(i=0; i<n;i++)

if(v[i] <0) break;

if(i == n)

system.out.println("elemento negativo não encontrado.");

E se isto se der dentro de um laço duplo? Nesse caso, o comando break provocará a interrupção

apenas do laço em que o comando é imediatamente subjacente. Os outros laços continuam

normalmente.

Exemplo:

// Notificando a existencia de elemento nulo em cada linha do matriz A

for(i=0; i<m; i++) // Para cada linha i da matriz faça

for(j=0; j<n; j++) // Para cada coluna j da matriz faça

if(A[i][j] == 0) {

System.out.println("A possui elemento nulo na linha "+i);

break;

}

O comando continue tem a função de pular direto para final do laço, mas em vez de interromper

o laço como no break, ele continua executando o próximo passo do laço. Não vamos ficar

estudando o uso de continue por ser puco usual na programação estruturada.

O comando "goto" em Java é feito pelo break ou continue com rótulo. Isto é útil para

interromper de uma vez só, a execução de um laço multiplo ou pular para um determinado ponto

http://www.dm.ufscar.br/~waldeck/curso/java/part26.html#i_break

29

do programa. O uso de saltos deste tipo deve ser evitado na programação estruturada, exceto

quando trata de alguma otimização muito importante. Caso contrário, nosso programas pode

tornar totalmente ilegível. Nós vamos ver um exemplo, mas lembre-se que se necessitar de um

"goto", está faltando a estruturação do programa. Nós estudamos essas coisas para poder

entender o programa já feito.

exemplo:

// calculando a raiz da soma dos quadrados de A[i][j]

soma = 0;

for(i=0;i<m;i++)

for(j=0;j<n;j++)

if(A[i][j]<0) {

System.out.println("Erro. existe elemento negativo.");

break fim;

}

esle

soma += Math.sqrt(A[i][j]);

fim:

System.out.println("soma = " + soma);

Bibliografia

http://www.dm.ufscar.br/~waldeck/curso/java/

http://www.dm.ufscar.br/~waldeck/curso/java/

JAVA - Engenheiro de Computação · ao nome que aparece após a palavra class na primeira linha do...

Documents

Transcript of JAVA - Engenheiro de Computação · ao nome que aparece após a palavra class na primeira linha do...