Estruturas de Programação Java por Gilberto Hiragi
Estruturas de Programação
JAVA
Por
Gilberto Hiragi
Março/2006
Página: 1
Prepare-se para as provas
Estude fácil! Tem muito documento disponível na Docsity
Ganhe pontos para baixar
Ganhe pontos ajudando outros esrudantes ou compre um plano Premium
Guias e Dicas
Prepare-se para as provas
Estude fácil! Tem muito documento disponível na Docsity
Encontrar documentos
Prepare-se para as provas com trabalhos de outros alunos como você, aqui na Docsity
Encontra documentos específicos para os exames da tua universidade
Encontra documentos específicos para os exames da tua universidade
Videoaulas
Prepare-se com as videoaulas e exercícios resolvidos criados a partir da grade da sua Universidade
Quiz
Responda perguntas de provas passadas e avalie sua preparação.
Ganhe pontos para baixar
Ganhe pontos ajudando outros esrudantes ou compre um plano Premium
apostila introdutória de JAVA
Tipologia: Notas de estudo
Antes de 2010
1 / 26
Esta página não é visível na pré-visualização
Não perca as partes importantes!
Documentos relacionados
Pré-visualização parcial do texto
Baixe apostila de Java e outras Notas de estudo em PDF para Informática, somente na Docsity!
Estruturas de Programação
JAVA
Por
Gilberto Hiragi
Março/
Estruturas de Programação em Java Utilizaremos aplicações do tipo console para demostrar as estruturas fundamentais que envolvem a programação em Java. A entrada de dados será feita através da linha de comando e estaremos desta forma fazendo uso da string de argumentos recebida pelo método main , já a saída será através do console utilizando o método System.out.println. Java é similar a C++ em muitos aspectos e aqueles que tem um bom conhecimento em C ou C++ tem uma vantagem inicial considerável, principalmente em relação às estruturas fundamentais. O primeiro detalhe a ser observado é que Java é sensível a maiúsculas e minúsculas, abaixo temos exemplos de identificadores distintos dentro de Java: Numero, numero e NUMERO Todos os identificadores acima são diferentes, podendo apontar para valores distintos, mas o principal é estar atento para não se enganar com relação à caixa alta e baixa durante a codificação. Veja que isso é válido para todos os objetos: nome de variáveis, métodos, classes entre outros. Um outro detalhe importante é que o nome da classe pública deve ser o mesmo do nome do arquivo onde ela esta sendo definida, portanto inclusive aqui deve ser respeitada a regra das letras. Abaixo temos um programa simples: FirstPrg.java package estruturas; // Nosso primeiro programa public class FirstPrg{ public static void main(String[] args){ System.out.println ("2 + 2 = " + (2+2)); } } O primeiro detalhe aqui é relativo à declaração de uma classe: public class FirstPrg Esta classe tem escopo global (public) e é regra em java colocarmos primeiro o tipo e depois o identificador, por isso primeiro class depois o identificador FirstPrg, que é o nome da classe. // Nosso primeiro programa Note que a linha anterior é ignorada pelo compilador (javac), pois (//) representa que a seguir vem apenas comentário, outras forma de comentários são (/* e / para mais de uma linha), ou (/* e */ para mais de linha e utilização de javadoc).
Os arrays em java são definidos pelo uso de ([]) e o primeiro elemento é o zero, portanto o último é numerado como N-1, quando N é o número de elementos do array. A linha System.out.println (“2 + 2= “ + (2+2)); demostra como faremos para mostrar algo no console, o método println esta dentro de out, que esta dentro de System, relembrando a hierarquia de linguagens que trabalham com objetos. Um outro detalhe aqui é que Strings são delimitadas por aspas (“”), portanto, o que fica entre aspas representa um texto literal que não será modificado. Já o que esta fora de aspas é processado e pode sofrer modificação, neste caso + (2+2) esta fora das aspas, analisando (2+2) , que é processado primeiro, (já que há precedência pela existência dos parênteses) é calculado e o resultado é 4, o System.out.println se encarrega de compatibilizar os tipos e fazer a concatenação sugerida pelo primeiro + fora das aspas. Esta concatenação entre um número é uma String resulta em String, em Java o tipo String é sempre mais forte em uma expressão, portanto: String + Qualquer tipo = String Um último lembrete é que os comandos devem ser finalizados por dois pontos (;), para Java não importa se um comando ocupa mais de uma linha, pois quem delimita o fim de uma instrução sempre é o (;). Não há ponto ao final de um arquivo de codificação como em Delphi. A saída deste programa será: 2 + 2 = 4 Nada de espantoso, porém os mecanismos básicos para definir uma classe e um método foram destrinçados, além disso, já reconhecemos array e strings, além de conhecer os mecanismos básicos para obter informações através da linha de comando e imprimir um valor para o console. Abaixo temos mais um exemplo, este programa irá pegar dois valores via teclado e imprimir a soma destes valores: Sum2Numbers.java package estruturas; import javax.swing.*; public class Sum2Numbers{ public static void main(String[] args){ int first, second; first =Integer.parseInt(JOptionPane.showInputDialog("Primeiro Número?")); second=Integer.parseInt(JOptionPane.showInputDialog("Primeiro Número?")); System.out.println (first + " somado com " + second +
" é igual a " + (first+second)); System.exit(0); } } Passamos a explicação das novas características do programa Sum2Numbers , o primeiro detalhe é que para executar este programa devemos fornecer dois número através de caixas de diálogos. Para executar usando NetBeans, crie um pacote chamado estruturas e dentro dele uma classe simples Sum2Numbers com o código anterior, use Shift+F6 no editor para rodar a classe. Temos como novidade a declaração de variáveis temos duas variáveis First e Second , sendo declaradas como inteiras na linha: i nt first, second; A sintaxe para declaração de variáveis é da seguinte forma:
Note que no exemplo anterior utilizamos a classe Float e o método parseFloat para converter a string em um número real simples, algo similar acontece com os outros tipos por exemplo existe Double.parseDouble para conversão de string para double, note que o tipo de dados é todo minúsculo (float) e a classe que contém o método tem a primeira maiúscula (Float). Alguns detalhes interessantes de conversão de dados numéricos, falam sobre a hierarquia dos tipos, veja as regras abaixo para expressões matemáticas:
- Se um operando for double então qualquer outro é convertido para double.
- Se um operando for float então o outro, não sendo double é convertido para float.
- E assim segue com long, int, short e byte. Porém nem sempre queremos partir para conversões para os tipos mais abrangentes, às vezes, queremos restringir o dado, ou seja, converter para um tipo mais limitado, por exemplo, de real para inteiro. Nestes casos fazemos uso de conversões explicitas do tipo (cast), vale lembrar que neste tipo de conversão pode haver perda de informação. Exemplos: double num = 7.7; int numInt = (int) num; A variável numInt terá o valor 7, desprezando portanto a parte fracionária. double num = 7.7; int numInt = (int) Math.round(num); Neste momento numInt recebe o valor 8, porque round da classe Math , faz arredondamento. Uma outra forma de declaração é a constante, como usual constantes não podem ter o valor alterado durante o processamento do programa, exemplo: final double salario = 3767.54; Para finalizar esta seção de conversão de dados, gostaríamos de apresentar o método toString , este método existe nas classes numéricas e é capaz de transformar o número no String correspondente, portanto o toString faz o inverso dos métodos parse , exemplo: float num=10.9; String str=Float.toString(num); Para completarmos a seção de tipos numéricos, passamos uma lista de operadores que podem ser úteis na manipulação destes tipos:
Operadores aritméticos: + - * / % são usados para somar, subtrair, multiplicar, dividir e resto da divisão. Para fazer exponenciação pode ser utilizado o método pow , que trabalha com o tipo double , exemplo: double num=Math.pow(2,3); Num será igual à 8, ou seja 2 elevado a 3. Como em C, java aceita os operadores de incremento(++) e decremento (- -), exemplo: int contador=0; contador++; // contador fica igual a 1 Os operadores lógicos também estão presentes em java, inclusive com uma gama extensa de possibilidades, inclusive em termos de métodos, estes operadores devolvem valores do tipo booleano, os principais operadores lógicos comparativos são:
- Igualdade (==), exemplos: (4 == 7) é falso, (5 == 5) é verdadeiro.
- Diferente (!=), exemplos: (4 != 7) é verdadeiro, (5 != 5) é falso.
- Além desses temos os operadores < (menor que), > (maior que), <= (menor ou igual a) e >= (maior ou igual a) Para completar os operadores lógicos temos os conectivos (&&) e lógico, (||) ou lógico e (!) a negação. Exemplos: (1=1) && (1!=1) é falso (1=1) || (1!=1) é verdadeiro ! (1=1) é falso Para modificar a precedência é possível fazer uso dos parênteses, a precedência segue a seguinte lista do que é feito primeira para o último a ser avaliado: () !, ++, - - *, /, % + - <, <=, >, >= ==, != && || =
QualCaractere.java package estruturas; import javax.swing.JOptionPane; public class QualCaractere{ public static void main(String[] args){ int cod; char caractere; cod=Integer.parseInt(JOptionPane.showInputDialog("Qual o código?")); caractere=(char)cod; System.out.println("O código é " + cod); System.out.println("O caractere correspondente é " + caractere); System.exit(0); } } Strings São seqüências de caracteres e tem funcionalidade similar aos das linguagens tradicionais, no Java o delimitador de Strings é as aspas (“”). Para concatenar uma String a outra basta usar o operador (+), exemplo: String frase = “Esta é uma “; frase = frase + “frase”; String em java não é um tipo primitivo, uma String qualquer é uma instância da classe String e como tal tem alguns métodos interessantes, tais: substring: String s=”Linguagem”; String d=s.substring(0,6); // d será igual à “Lingua” String e=s.substring(3,6); // e será igual à “gua” Tamanho de uma string: String s=”Servlet”; int n=s.length(); // n será igual à 7
Retornando um determinado caractere de uma String: String s=”Java Server Pages”; char c1=s.chatAt(1); // c1 será igual à ‘a’ char c2=s.charAt(5); // c2 será igual à ‘S’
- No java os índices sempre iniciam em zero. Transformar em maiúscula e minúsculas: String s=”TomCat”; String u=s.toUpperCase(); // u será igual à “TOMCAT” String l=s.toLowerCase(); // l será igual à “tomcat” Comparação entre Strings: Não é aconselhável usar (==) para comparar Strings, existem dois métodos adequados para isso equals e equalsIgnoreCase, como em: String s=”Java”; boolean t1=s.equals(“java”); // t1 será igual à falso boolean t2=s.equals(“Java”); // t2 será igual à verdadeiro boolean t3=s.equalsIgnoreCase(“java”); // t3 será igual à verdadeiro Trocando caractere de uma String: String s=”Jakarta”; String x=s.replace(‘a’,’x’); // x será igual à “Jxkxrtx” Trocando uma substring de uma String: String s=”Java Server Pages”; String x=s.replaceAll(“a”,”ah”); // x será igual à “Jahvah Server Pahges” Eliminando espaços em branco: String s=” Tem espaço de mais “; String x=s.trim(); // x será igual à “Tem espaço de mais” Existem outros métodos interessantes na classe String, é válido acessar a documentação da Sun para esta classe.
int n2=Integer.parseInt(JOptionPane.showInputDialog("Qual o segundo inteiro?")); if (n1>n2) System.out.println (n1 + " é maior que " + n2); else if (n2>n1) System.out.println (n2 + " é maior que " + n1); else System.out.println (n1 + " é igual a " + n2); System.exit(0); } } Como é usual nas linguagens de programação atual, o if é a estrutura básica de decisão, ele executa ou não um bloco de comandos (ou comando) conforme o valor booleano da condição. Note que acima não foi necessário utilizar chaves ({}), visto que para cada resultado de condição é associado apenas um comando, ou seja, a chamada do método System.out.println. O exemplo a seguir diz o tamanho de uma string de entrada e julga se ela ultrapassa o limite de quinze caracteres, isso pode ser usado na validação de dados, por exemplo, em um banco de dados o nome não pode conter mais que “n” caracteres. ValNome.java package estruturas; import javax.swing.*; public class ValNome{ public static void main (String[] args){ String nome; nome=JOptionPane.showInputDialog("Qual o nome?"); System.out.println ("O nome " + nome + " tem " + nome.length()
- " caracteres "); if (nome.length()>15) System.out.println ("Foi ultrapasso o valor máximo" + " de 15 caracteres"); System.exit(0); } }
Laços Outra estrutura importante em java é a estrutura de repetição, normalmente com variável de controle numérica, ou seja, o for. A sintaxe básica de for é: for (<inicialização>; <condição>;
tentativas++; if (palpite==sorteado){ acertou=true; System.out.println ("*** VOCÊ ACERTOU !!! É mesmo " + palpite + "***"); } else if (palpite<sorteado) System.out.println ("Palpite é menor que o valor sorteado."); else if (palpite>sorteado) System.out.println ("Palpite é maior que o valor sorteado."); } catch (NumberFormatException err){ System.out.println("Erro na conversão ..."); System.out.println(err); } } System.out.println("--------------"); System.out.println("Você acertou em " + tentativas + " tentativas."); } } Necessitamos usar try , porque estamos fazendo operação de conversão, é uma maneira mais robusta de tratar possíveis erros no momento da conversão, por exemplo, não é possível converter um caractere “?” por um número, porém como a entrada de dados é liberada o usuário final poderá digitar algo inadequado, resultando em erro e quebra da execução do programa por falha, com o try podemos evitar esta queda brusca e então tratar o erro da melhor forma. Utilizamos o método random, da classe Math, esta classe Math possui alguns métodos interessantes, tais: ceil() – Retorna a parte inteira de um double. floor() – Retorna o menor inteiro de um double. min() – Retorna o menor entre dois números. max() – Retorna o maior entre dois números. sqrt() – Retorna a raiz quadrada do número. random() – Retorna um número double entre 0 e 1, qualquer. A sintaxe básica para estes métodos é: x = Math.método(<lista-de-parâmetros>), sendo x alguém que possa receber o valor calculado. Para finalizar as estruturas de repetição básicas do java, iremos tratar de switch , esta estrutura é útil quando estamos fazendo decisão encima de um mesmo valor inteiro com várias alternativas, normalmente é mais legível que utilização de if aninhado. Veja o exemplo abaixo que ilustra como esta estrutura pode ser utilizada:
Escolha.java package estruturas; import javax.swing.; public class Escolha{ public static void main(String[] args){ byte mes=0; String leTeclado; while (true){ try{ leTeclado=JOptionPane.showInputDialog("Qual o mês?"); mes =Byte.parseByte(leTeclado); if (mes==0){ System.out.println ("** Boa Noite Tchau tchau ***"); break; } switch (mes){ case 1 : System.out.println ("Janeiro"); break; case 2 : System.out.println ("Fevereiro"); break; case 3 : System.out.println ("Março"); break; case 4 : System.out.println ("Abril"); break; case 5 : System.out.println ("Maio"); break; case 6 : System.out.println ("Junho"); break; case 7 : System.out.println ("Julho"); break; case 8 : System.out.println ("Agosto"); break; case 9 : System.out.println ("Setembro"); break; case 10 : System.out.println ("Outubro"); break; case 11 : System.out.println ("Novembro"); break; case 12 : System.out.println ("Dezembro");
Veja o exemplo anterior que a partir do número do mês imprimimos o mês por extenso, ele pode ser reescrito utilizando um vetor: EscolhaArray.java package estruturas; import javax.swing.; public class EscolhaArray{ public static void main(String[] args){ byte mes=0; String leTeclado; String[] meses = {"Janeiro", "Fevereiro", "Março", "Abril", "Maio", "Junho", "Julho", "Agosto", "Setembro", "Outubro", "Novembro", "Dezembro"}; while (true){ try{ leTeclado=JOptionPane.showInputDialog("Qual o mês?"); mes =Byte.parseByte(leTeclado); if (mes==0){ System.out.println ("** Boa Noite Tchau tchau ***"); break; } if (mes>12 || mes<1){ System.out.println ("Mês inválido"); } if (mes>0 && mes<13){ System.out.println (meses[mes-1]); } } catch (NumberFormatException err){ System.out.println("Erro na conversão ..."); System.out.println(err); } } } } Veja que é possível declarar um array de forma literal, ou seja, informando entre chaves ({}) os valores elemento a elemento separados por vírgulas do array. O acesso ao elemento ocorre através do índice que é colocado entre colchetes ([]), sendo que o primeiro elemento é numerado como zero. Portanto se é declarado um vetor como em int[] num = new int[10], você terá os seguintes elementos: num[0], num[1], ..., num[9].
Um aspecto interessante em java é que um array pode ter como elementos, ou seja, o tipo dele pode ser inclusive uma classe, portanto você pode criar um array de objetos, tal como em Delphi. O exemplo a seguir preenche uma matriz com 3 linhas e 3 colunas e então imprime a soma das linhas e a soma das colunas: Matriz.java package estruturas; import javax.swing.*; public class Matriz{ public static void main(String[] args){ byte mes=0; String leTeclado; int[][] matriz = new int[3][3]; int soma; String linha; // Recebendo dados ... for (byte l=0;l<3;l++){ for (byte c=0;c<3;c++){ try{ leTeclado=JOptionPane.showInputDialog ("Entre com valor para linha " + l + " e coluna " + c + " : "); matriz[l][c]=Integer.parseInt(leTeclado); } catch (NumberFormatException err){ System.out.println("Erro na conversão ..."); System.out.println(err); } } } // Mostrando em forma de matriz System.out.println (" *** Matriz de Entrada *** "); for (byte l=0;l<3;l++){ linha=""; for (byte c=0;c<3;c++){ linha+=" " + String.valueOf(matriz[l][c]); } System.out.println(linha); } // Calculando soma nas linhas System.out.println (" *** "); for (byte l=0;l<3;l++){ soma=0; for (byte c=0;c<3;c++){ soma+=matriz[l][c]; } System.out.println("Soma da linha " + l + " é " + soma);