Exemplo

public class exemplo {

public static void main (String agrs[])

{
int x=10, y=20;
double dolar=2.62;
[Link](x);
[Link](y);
[Link](dolar);
}
}

Exemplo0203

public class exemplo0203 {

public static void main (String arg[])
{
//declaração e inicialização de variável
int x=10; int y=3;
//várias operações com as variáveis
[Link]("x="+x);
[Link]("y="+y);
[Link]("-x="+(-x));
[Link]("x/y="+(x/y));
[Link]("Resto de X por Y=" + (x/y));
[Link]("Inteiro de Y por Y=" +
(int)(x/y));
[Link]("x+1="+(++x));
}
}
//A linha public atact void main (sting arg[]) aparece em todas as
classes executáveis neste mesmo formato.
//Public é um qualificador do método que indica que ele é acessível
externamenta]e a essa classe. Isso é útil quando uma classe necessita
utilizar alguma funcionalidade de outra classe, característica muito
comum na linguagem Java.
//Static qualificador que indica que o método deve ser compartilhado
por todos os objetos que são criados apartir dessa classe.
//Void é o valor de retorno do método quando não há nenhum valor, ele
retoma void, uma espécie de valor vazio que deve ser específica.
//Main este é o nome do método que indica algo compilador o inicio do
programa. É o método principal, em que todas as variáveis, argumentos
e instruções são interpretados e processados para a execussão do
programa.
//(String arg[]) é o argumento do método principal e por consequencia,
do programa todo, ele é um Vetor de String formado por todos os
argumentos passados ao programa na linha de comando do Sistema
Operacional quando invocado.
 Exemplo 0206
import [Link].*; //import - indica que determinado pacote de classes
deve ser carregada no momento da compilação. Java - Classe
especialista em entrada e saida de dados. * - deve ser carregada
todas as classes.

public class exemplo0206

{
public static void main(String args[])
{
String S = "";
float nota1=0, nota2=0, trabalho=0, media=0;
DataInputStream dado; //Classe que possibilita a entrada de dados no
teclado.
try //tente
{
[Link]("Entre com a nota 1.");
dado = new DataInputStream([Link]); //nesta linha o objeto
dado recebe o que foi digitado pelo usuário.
S = [Link](); //a variável S ecebe o conteúdo texto do
objeto dado.
nota1 = [Link](S);
[Link]("Entre com a nota 2.");
dado = new DataInputStream([Link]);
S = [Link]();
nota2 = [Link](S); //o conteúdo da variável S é
convertido em uma variável numérica do tipo float
[Link]("Entre com a nota de trabalho.");
dado = new DataInputStream([Link]);
S = [Link]();
trabalho = [Link](S);

media=(nota1+nota2+trabalho)/3;
[Link] ("Média: "+ media);
}
catch(IOException erro) // trata erros em entrada de dados.
{
[Link]("Houve erro na entrada de dados");
}
catch(NumberFormatException erro) //Number - trata erros quanto a
formatos, ou seja, erro de converção
{
[Link]("Houve um erro na conversão, digite apenas
caracteres numéricos");
}
}
}
//Bloco [Link] é um conjunto que atua juntos. O interpretador java
tentará executar o bloco Try e se algum erro acontecer, a execussão do
programa será desviada para um bloco Catch
 Exemplo0208
import [Link];
public class exemplo0208 {
public static void main (String args [])
{
String aux="";
float nota1=0, nota2=0, trabalho=0, media=0;
try
{
aux=[Link](null, "entre com a
nota um");
nota1=[Link](aux);
aux=[Link](null,"Entre com a
nota dois"); //showInputDialog: responsável por abrir caixas de
diálogo e permite digitaçaõ
nota2=[Link](aux); //parseFloat: permite
conversão do número;
aux=[Link](null,"Entre com a
nota do trabalho");
trabalho=[Link](aux);
media=(nota1+nota2+trabalho)/3;
[Link](null,"A media é:
"+media); //[Link]: abre caixa de saída de
valores.

}
catch(NumberFormatException e) //e é uma variável qualquer
{
[Link](null,"Houve um erro na
converção, digite apenas caracteres numéricos");
}
[Link](0); //força o encerramento do programa
}

}
 Exemplo 301
//Estrutura if-else
import [Link];
public class Exemplo301
{

public static void main (String args[])

{
String aux=[Link](null, "Forneça um
valor numérico entre 0 e 10: ");
if (aux!=null)//!= diferente
{
try
{
float x=[Link](aux);
if (x>=0 && x<=10)//&& e
[Link] (null, "Nota ="+x
+ " , Valor válido");
else
[Link] (null,
"Nota ="+x + " , Valor inválido");
}
catch (NumberFormatException erro)
{
[Link] (null, "Digite
apenas valores numéricos ");
}
}
[Link](0);
}

}
 Exemplo302
//Estrutura switch-case
import [Link];
public class Exemplo302 {
public static void main (String args [])
{
String aux=[Link](null, "Forneça um
número inteiro entre 0 e 9: ");
if (aux!=null)
{
try
{
int x=[Link](aux);
String extenso= "";
switch (x)

{
case 0: extenso= "zero"; break;
case 1: extenso= "um"; break;
case 2: extenso= "dois"; break;
case 3: extenso= "três"; break;
case 4: extenso= "quatro"; break;
case 5: extenso= "cinco"; break;
case 6: extenso= "seis"; break;
case 7: extenso= "sete"; break;
case 8: extenso= "oito"; break;
case 9: extenso= "nove"; break;

default: extenso= "Número desconhecido";

}
[Link](null,"Número
Fornecido: " + extenso);
}
catch (NumberFormatException erro)
{
[Link](null,"Digite
apenas valores numéricos inteiros ");
}
}
}
}
 Exemplo303
import [Link];
public class Exemplo303 {
public static void main (String args [])
{
String aux1= [Link] (null, "Forneça o
valor do 1° número: ");
if (aux1==null);
[Link](0);
String aux2= [Link] (null, "Forneça o
valor do 2° número: ");
if (aux2==null);
[Link](0);
try
{
int num1=[Link] (aux1);
int num2=[Link] (aux2);

[Link] (null, "soma= " +

(num1+num2));
[Link] (null, "subtração= " +
(num1-num2));
[Link] (null, "multiplicação=
" + (num1*num2));
[Link] (null, "divisão= " +
(num1/num2));
}
catch (ArithmeticException e)
{
[Link](null, "Erro de divisão
por zero! ", "ERRO ",JOptionPane.ERROR_MESSAGE);
}
catch (NumberFormatException erro)
{
[Link] (null, "Digite apenas
números INTEIROS! ", "ERRO ", JOptionPane.ERROR_MESSAGE);
}
[Link](0);
}
}
Uso do Bloco Finally

O Bloco Finally faz parte da estrutura, inserido geralmente após o último catch. O
finally é opcional e fornece um conjunto de códigos que é sempre executado,
independentemente de uma exceção. Quando se utiliza a estrutura try sem nenhum
bloco catch, o bloco finally é obrigatório, isto é, existe a possibilidade da utilização das
estruturas try-catch, try-catch-finally, ou ainda try-finally. O objetivo do finally é
manter códigos para a liberação de recursos adquiridos em seu bloco try
correspondente. Um exemplo prático dessa utilização será mostrado mais adiante na
manipulação de arquivos de texto em que o bloco finally será utilizado para fechar um
arquivos após abri-lo, ou seja, liberar um recurso, externo, depois de adquiri-lo.
Durante a execução de um programa, caso nenhuma exceção, ocorra, os blocos cacth
não são executadose o controle prossegue para o bloco finally, que libera o recurso e
passa a executar a primeira instrução após o bloco finally, caso ocorra alguma exessão a
execução do programa será desviada para o grupo de instruções catch.
A seguir, independentemente de ter havido ou não uma exceção o controle passa para o
bloco finally para a liberação de recursos. Mesmo que não exista nenhuma instrução
catch referente a execução gerada, o controle passa para o bloco finally. Isso pode ser
útil para o desenvolvedor caso necessite controlar apenas alguns tipos de erros pois
erros diferentes dos tratados podem ser desviados para o finally.
A figura abaixo esboça um fluxograma representa a seqüência de execução da estrutura
try-catch-finally .

try

sim
erros catch

finally não

Para que o leitor possa verificar o funcionamento do finally modifique o trecho final do
exemplo 3.3 inserido o trecho em negrito
Catch (numberFormatException erro)
{
[Link](null, “Digite apenas números
inteiros”,”Erro”, JOptionPane ERROR MESSAGE);
}
Finally
{
[Link](null,”Final da execussão!”);
}
[Link](0);
}
}
Bloco_finally

import [Link];
public class bloco_finally {
public static void main (String args [])
{
String aux1= [Link] (null, "Forneça o
valor do 1° número: ");
if (aux1==null);
[Link](0);
String aux2= [Link] (null, "Forneça o
valor do 2° número: ");
if (aux2==null);
[Link](0);
try
{
int num1=[Link] (aux1);
int num2=[Link] (aux2);

[Link] (null, "soma= " +

(num1+num2));
[Link] (null, "subtração= " +
(num1-num2));
[Link] (null, "multiplicação=
" + (num1*num2));
[Link] (null, "divisão= " +
(num1/num2));
}
catch (ArithmeticException e)
{
[Link](null, "Erro de divisão
por zero! ", "ERRO ",JOptionPane.ERROR_MESSAGE);
}
catch (NumberFormatException erro)
{
[Link] (null, "Digite apenas
números INTEIROS! ", "ERRO ", JOptionPane.ERROR_MESSAGE);
}
finally
{
[Link](null,"Final da
execussão!");
}

[Link](0);
}
}
Uso da clausula throws

Em alguns momentos, pode ocorrer de um programa não querer realizar

controles sobre uma execução, isto é, não desejar tratar um erro. Java
permite ao programador que o erro seja “descartado”, mesmo que ele
ocorra, é preciso que este fato seja informado na declaração do
método.

Exemplo0304_throws
import [Link].*;
public class exemplo0304_trown {
public static void main (String args [])throws IOException
{
BufferedReader dado;
[Link]("Entre com o seu nome.");
dado= new BufferedReader (new
InputStreamReader([Link]));
[Link]("Seu nome é: "+ [Link]());

}
}
//é uma alternativa para entrada de dados pelo teclado sem
obrigatoriedade do tratamento da excessão IOException

Laço de Repetição

Uso do laço For

É um tipo de contador finito, ou seja, realiza a contagem de um valor
inicial conhecido até um valor final também conhecido.
Então temos a seguinte estrutura:
For (inicialização; condição; incremento ou decremento)

Valor inicial Variável que É o passo

da variável controla a com que a
de controle continuação variável de
do laço. do laço. controle que
será
acrescida ou
decrescida.

Exemplo0307
//for (int x=0; x<10; x++)
public class Exemplo0307 {
public static void main (String args [])
{
for (int i=10; i>0; i--) // passo menos 1
{
[Link] (i+"");
}
[Link] ();
[Link] ("Acabou");
}

}
 Laço de Repetição
// outro exemplo com controle de tempo
public class exemplo0308 {
public static void main (String args [])
{
Thread tempo; //Thread=objeto que cria uma ligação segundo
a segundo - Tempo=criando um objeto (tempo) para controle do tempo
tempo = new Thread ();
[Link]();
int a,b;
for (a=0; a<=10; a++) //contagem de 0 a 10 no passo 1
{
[Link] (a+"");
}
[Link] ();
for(a=50; a>0; a=a-5) // contagem de 50 a 0 no passo -5
{
[Link](a+"");
}
[Link]();
for (a=10; a>=-10; a=a-2)//contagem de 10 até -10 no passo
-2
{
[Link](a+"");
for (b=0; b<500; b++)//b=temporizador caseiro
{
[Link] (b+"");
int h, m, s;
[Link] ("Para encerrar o relógio,
precione ctrl+c");
for (h=0; h<24; h++)
for (m=0; m<60; m++)
for (s=0; s<60; s++)
//o laço mais interno (s)
controla os segundos e será executado 60x a cada minuto (laço
superior). Da mesma forma o laço de minuto será executado 60x a cada
hora;
{
[Link] (h+"h= "+m+"mind
minutos= "+s+"s");
try
{
[Link](1000); //envoca o
temporizador que espera mil até a execução da próxima instrução
if (s==5) // bloco if
controla o final do relógio
[Link](0);
}
catch (InterruptedException Erro)
{
//tratamento de erro
}
}
}
}
}
 Laço While
É outro laço condicional, isto é, um conjunto de instruções que são
repitidas enquanto o resultado de uma expressão lógica (uma condição)
é avaliada como verdadeira.
Exemplo: while (condição)
{
Conjunto de instrução
}

Há outro tipo de laço condicional, o chamado do-While, é parecido com

While, porém o conjunto de instruções é executado antes da avaliação
expressão lógica. Isso faz com que essa instrução seja executada pelo
menos uma vez.
//exemplo utilizando do-wile
public class Exemplo0309 {
public static void main (String args []){
Thread tempo; //Thread=objeto que cria uma ligação segundo
a segundo - Tempo=criando um objeto (tempo) para controle do tempo
tempo = new Thread ();
[Link]();
int a;
try
{
a=[Link](args[0]);
while (a>=0)
{
[Link](""+a);
[Link](1000);
a--;

}
[Link]("Fim da primeira contagem");
[Link]();
[Link](1000);
do
{
[Link](""+a);
[Link](1000);
a++;

}
while (a>0);
[Link]("Fim da segunda contagem");

}
catch (ArrayIndexOutOfBoundsException Erro)
{
[Link] ("Digite um argumento!");
}
catch (InterruptedException Erro)
{
[Link]("Algo interrompeu a contagem!");
}
catch (NumberFormatException Erro)
{
[Link]("Não foi fornecido um número
inteiro válido!");//se o argumento for inválido
}
}