Aula 08 - LPG

Prévia do material em texto

Aula 08: Aplicando os conceitos de OO 
 
Objetivos 
 
 Recordando... 
Nas aulas passadas, criamos algumas aplicações Java para ilustrar os conceitos de POO 
apresentados. Nestas aplicações usamos variáveis de diversos tipos, operadores e alguns 
comandos de decisão e repetição. Hoje vamos rever esses tipos e comandos 
detalhadamente. Também veremos como ler dados do teclado, pois até agora só 
imprimimos dados. 
 Tipos primitivos e tipos de referência 
Em Java, trabalhamos com dois tipos de dados: primitivos e de referência, estes também 
denominados como não primitivos. 
Primitivos: 
Tipo Quant. bits Valores armazenáveis na variável 
boolean 1 True ou False 
byte 8 –128 até 127 ( -27 a 27-1 ) 
char 16 „\u0000‟ a „\uFFFF‟ (0 a 65535) 
short 16 –32768 até 32767 ( -215 a 215-1 ) 
int 32 –2.147.483.648 até 2.147.483.647 (-231 a 231-1 ) 
long 64 (-2
63
 a 2
63
-1 ) 
float 32 1,40 X 10
-45
 a 3,40 X 10
38
 
double 64 4,94 X 10
-324
 a 1,70 X 10
308
 
 
Variável de tipo primitivo pode armazenar exatamente um valor do seu tipo declarado. 
Variáveis de tipo de referência são utilizadas para armazenar as localizações de objetos 
na memória do computador. 
Os atributos de tipo primitivo são iniciados por ocasião da instanciação do objeto. Os 
atributos de tipos byte, char, short, int, long, float e double são iniciadas com zero, as 
variáveis do tipo boolean com false. Podem ser especificados valores iniciais para 
variáveis destes tipos quando de sua declaração. Variáveis locais de métodos não são 
iniciadas automaticamente. 
As variáveis de instância de tipo de referência são iniciadas por padrão com o valor 
null – palavra reservada que representa uma “referência a nada”. Somente depois que o 
objeto é instanciado é que a variável contém uma referência para o objeto. 
Por exemplo, o comando Curso meuCurso = new Curso(); cria uma instância 
(objeto) da classe Curso, e a variável meuCurso contém uma referência a esse objeto. 
A partir de então, a variável pode ser usada para chamar métodos do objeto ou 
referenciar seus atributos. 
 Diferenciar tipos primitivos de dados e tipos de referência a objetos 
 Entender o uso dos operadores aritméticos, lógicos e relacionais 
 Aprender a sintaxe e semântica das estruturas de controle de fluxo 
 Tratar entradas de dados 
 Aprender a utilizar a classe String 
 
 
 Usando Operadores 
O Java oferece um conjunto amplo de operadores aritméticos, relacionais e lógicos. 
Veja a tabela abaixo: 
Tipo Op. Significado Ex. Op. Significado Ex. 
a
ri
tm
é
ti
c
o
s
 
 
+ Adição a+b % Resto da divisão a%b 
- Subtração a-b - Menos unário -a 
* Multiplicação a*b ++ Incremento unário ++a ou a++ 
/ Divisão a/b -- Decremento unário --a ou a-- 
re
la
c
io
n
a
is
 
 
== Igual a==b >= Maior ou igual a>=b 
!= Diferente a!=b < Menor que a<b 
> Maior que a>b <= Menor ou igual a<=b 
ló
g
ic
o
s
 
 
&& E lógico a&&b ! Negação !a 
|| OU lógico a||b 
 
 Estruturas de Controle do fluxo 
Java contém três tipos de estruturas de controle (instruções): seqüência, seleção e 
repetição. Um programa é formado pela combinação destas estruturas, de forma a 
implementar o que o algoritmo determina. 
A estrutura de seqüência permite aglutinar vários comandos em um bloco de comandos 
delimitado por chaves ({...}). Isto deve ser feito sempre que queiramos delimitar os 
comandos que façam parte de uma outra estrutura de controle de decisão ou repetição 
(if/else, switch, for, while, etc.). 
 Instruções de seleção 
Comando if 
O if é uma instrução que permite a seleção entre dois caminhos distintos, conforme a 
avaliação de uma condição lógica como falsa ou verdadeira. 
if (expressão lógica)comando1; else comando2; 
Exemplo: 
if ( nota >= 6 ) 
 System.out. println (“Aprovado”); 
else 
 System.out. println (“Reprovado”); 
A parte do else é opcional. Comando1 e Comando2 podem ser blocos de comandos. O 
compilador Java sempre associa um else à instrução if imediatamente anterior, a menos 
que instruído de outro modo pela colocação das chaves 
 
Operador condicional ternário 
Como já vimos em aulas anteriores, em algumas situações podemos usar o operador “?”, 
que realiza a mesma operação do comando if. Ex: 
System.out.println(nota > 6 ? “Aprovado”:“Reprovado”); 
 
Comando switch 
Este comando equivale a um conjunto de if encadeados: 
switch (expressão ordinal) { 
 case ordinal1: comando1; break; 
 case ordinal2: comando2; break; 
 case ordinalN: comandoN; break; 
 default: comandoDefault; 
} 
Exemplo: 
switch (opcao) { 
 case „a‟: 
 case „A‟: System.out.println(“letra A”); 
 break; 
 case „b‟: 
 case „B‟: System.out.println(“letra B”); 
 break; 
 default: System.out.println(“letra invalida”); 
} 
 
 Estruturas de repetição 
 
Comando for 
O comando for é indicado para repetirmos um trecho de código uma quantidade fixa de 
vezes. Sua sintaxe possui três seções opcionais: 
for (seção1; seção2; seção3) comando; 
a seção1 é executada apenas uma vez e geralmente é usada para iniciar uma variável de 
controle do for. A seção2 é executada antes de cada iteração do for e habilita a execução 
de mais uma iteração, caso verdadeira (true). Geralmente é usada para testar a variável 
de controle do for. A seção3 é executada ao final de cada iteração do for e geralmente é 
usada para incrementar a variável de controle. 
Exemplo: 
for (int i = 0; i < 4;i++) 
 System.out.printf(“%d ”,i); //imprime de 0 a 3 
 
Comandos while / do 
O comando while é indicado quando desejamos repetir um trecho de código uma 
quantidade indefinida de vezes, enquanto uma determinada condição for verdadeira. 
Sintaxe: 
 while (expressão lógica) 
 comando1; 
 
Exemplo: 
while ( produto <= 100 ) 
 produto = 3 * produto; 
Caso a condição seja inicialmente falsa, nenhuma iteração será executada. Nos casos em 
que desejamos executar pelo menos uma vez os comando da repetição, devemos usar o 
comando do / while, Cuja sintaxe é a que se segue: 
do 
 comando1; 
while (expressão lógica); 
Veja o exemplo: 
do 
 produto = 3 * produto; 
while ( produto <= 100 );// testa após ter executado 
 // pelo menos uma vez 
 Lendo valores do teclado 
Até agora, nossas aplicações apenas escreviam valores na tela de console. Fizemos isso 
usando (embora sem ter sido ainda explicado) um Stream de dados. Um Stream é um 
canal que conduz os dados de um lugar (um arquivo ou um dispositivo) para outro. A 
stream de saída padrão (out) está na classe Java.lang.System e é aberta 
automaticamente pela máquina virtual Java, já associada ao dispositivo de saída padrão 
(display). 
Já a stream de entrada padrão (in), disponível estaticamente através da mesma classe 
Java.lang.System, é de utilização bastante precária, na medida em que disponibiliza 
métodos apenas de acesso a bytes, de forma que, para que se leia valores inteiros, reais 
ou strings, é necessário ir concatenando bytes para formar a entrada desejada. Assim, não 
utilizaremos essa forma de entrada e sim uma classe mais elaborada, disponível na 
biblioteca java.util.Scanner, que permite a chamada de métodos para ler diretamente 
strings, números inteiros e números reais. 
Para utilizá-la, é necessário instanciar um objeto da classe Scanner e chamar um 
método apropriado para ler cada um dos tipos básicos ou String de um dispositivo 
qualquer. Por exemplo, para ler do dispositivo padrão de entrada, podemos ter o seguinte 
código: 
// cria Scanner para ler entrada na janelade comando 
 Scanner entrada = new Scanner( System.in ); 
// faz Scanner ler variáveis de diferentes tipos 
 palavra = entrada.next() // lê String até <branco> 
 nome = entrada.nextLine() // lê String até <ENTER> 
 valorI = entrada.nextInt() // lê valor inteiro 
 valorF = entrada.nextFloat() // lê valor float 
 valorD = entrada.nextDouble() // lê valor double 
 valorB = entrada.nextBoolean() // lê valor boolean 
 
Além de ler os valores, podemos também testar se o valor é do tipo esperado, através de 
métodos que retornam valores lógicos. Por exemplo: 
if (entrada.hasInt()) { // true, se entrada inteira 
if (entrada.hasFloat()) { // true, se entrada float 
if (entrada.hasDouble()) { // true, se entrada double 
if (entrada.hasBoolean()) { // true,se entrada boolean 
 
 
 
 A classe String 
A classe String fornece construtores para iniciar objetos String de várias maneiras. 
Quatro delas são mostradas no módulo main da classe abaixo. 
public class StringConstructors{ 
 public static void main( String args[] ) { 
 char cArray[]={'b','i','r','t','h',' ','d','a','y'}; 
 String s = new String( "hello" ); 
 String s1 = new String(); 
 String s2 = new String(s); 
 String s3 = new String(cArray ); 
 String s4 = new String(cArray, 6, 3 ); 
 System.out.printf( 
 "s1 = %s\ns2 = %s\ns3 = %s\ns4 = %s\n", 
 s1, s2, s3, s4 ); // exibe strings 
 } // fim de main 
} 
 
Alguns métodos da classe String: 
length() – retorna o comprimento de uma string 
 public int length() 
 
charAt(índice) – retorna o caractere de uma localização específica do string 
 public char charAt(int index) 
 
getChars – retorna o conjunto de caracteres de um string como array char. 
public void getChars(int srcBegin, int srcEnd, 
 char[] dst, int dstBegin) 
 
O funcionamento desses métodos é visto na classe Miscelanea a seguir: 
public class Miscelanea{ 
 public static void main( String args[] ) { 
 String s1 = "OTO AMA ANA"; 
 char charArray[] = new char[3]; 
 System.out.printf("O String s1: %s", s1 ); 
 System.out.printf("\nTamanho: %d",s1.length()); 
 // percorre s1 com charAt e exibe em ordem inversa 
 System.out.print( "\nO String invertido: " ); 
 for ( int count=s1.length()-1; count>=0; count--) 
 System.out.printf( "%s", s1.charAt( count )); 
 // copia caracteres do String para o charArray 
 s1.getChars( 4, 7, charArray, 0 ); 
 System.out.print("\Caracteres de 4 ate 6: " ); 
 for (char caracter : charArray ) 
 System.out.print( caracter ); 
 System.out.println(); 
 } // fim de main 
} 
 
 
Aplicando os conceitos aprendidos 
Para consolidar os conceitos de operadores, estruturas de controle e criação de interfaces, 
vamos criar uma aplicação diferente da que vínhamos fazendo nas aulas passadas. Nossa 
aplicação possuirá apenas uma classe (Curso), que guardará seu próprio nome, o nome de 
um aluno e as notas das três avaliações desse aluno no curso. A classe oferece métodos de 
get e set para seus atributos e um método que avalia se o aluno foi aprovado ou reprovado, 
de acordo com as notas das avaliações, retornando um String com essa avaliação final. Para 
julgar se o aluno foi aprovado, é feita a média das duas maiores notas e o aluno estará 
aprovado se esta for maior ou igual a 6,0. 
public class Curso { 
 private String nomeCurso; 
 private String nomeAluno; 
 private float notas[]; 
 
 public Curso(String nomeCurso,String nomeAluno) { 
 this.nomeCurso = nomeCurso; 
 this.nomeAluno = nomeAluno; 
 notas = new float[3]; 
 } 
 
 public void setNomeCurso( String nomeCurso ) { 
 this.nomeCurso = nomeCurso; 
 } 
 
 public String getNomeCurso() { 
 return nomeCurso; 
 } 
 
 public void setNomeAluno( String nomeAluno ) { 
 this.nomeAluno = nomeAluno; 
 } 
 
 public String getNomeAluno() { 
 return nomeAluno; 
 } 
 
 public void setNotas (float nota, int posicao){ 
 notas[posicao] = nota; 
 } 
 public float calcularMedia() { 
 int indNota=0; // indice das notas 
 float piorNota=11; // valor da nota a descartar 
 int indPiorNota=0; // indice da nota a descartar 
 while ( indNota < 3 ) { // descobre a pior nota 
 if (notas[indNota] < piorNota){ 
 piorNota = notas[indNota]; 
 indPiorNota = indNota; 
 } 
 indNota++; 
 } // fim do while 
 switch (indPiorNota){//media das 2 melhores 
 case 0: return ((notas[1]+notas[2])/2); 
 case 1: return ((notas[0]+notas[2])/2); 
 case 2: return ((notas[0]+notas[1])/2); 
 
 } 
 return 0; 
 } // fim do método calcularMedia 
 
 public String determinarSituacao() { 
 String situacao; 
 if (calcularMedia() >= 6.0) 
 situacao = "APROVADO(A)"; 
 else 
 situacao = "REPROVADO(A)"; 
 return String.format( 
 "\n%s %s %s %s %s %s %s %.2f\n\n", 
 "O(a) aluno(a)",getNomeAluno(),"foi", 
 situacao,"no curso",getNomeCurso(), 
 "com media",calcularMedia()); 
 } // fim do método determinarSituacao 
 
} // fim da classe LivroNotas 
 
A classe da aplicação de teste possui o seguinte código: 
import java.util.Scanner; // Classe Scanner 
public class AppCurso 
{ 
 public static void main( String args[] ) { 
 float nota; 
 String curso="",aluno=""; //inicia Strings 
 // cria Scanner para ler entrada do console 
 Scanner entrada = new Scanner( System.in ); 
 System.out.printf("\nEntre com nome do curso: "); 
 curso = entrada.nextLine() ; 
 System.out.printf("\nEntre com nome do aluno: "); 
 aluno = entrada.nextLine(); 
 Curso meuCurso = new Curso(curso,aluno); 
 for (int cont=0; cont<3; cont++){ 
 System.out.printf("\nDigite a nota %d: ",cont+1); 
 nota = entrada.nextFloat(); // lê a próxima nota 
 meuCurso.setNotas(nota,cont); 
 } 
 System.out.printf("%s", 
 meuCurso.determinarSituacao()); 
 } // fim de main 
} // fim da classe AppCurso 
 
 Exercícios 
1. Implemente e rode todos os exercícios desta aula (Ex1 até Ex9). 
2. Coloque na classe Curso um atributo frequencia, que represente o percentual de aulas 
assistidas pelo aluno. Modifique o método determinarSituacao de forma que seja 
considerado um percentual mínimo de 75% para que o aluno seja aprovado. 
3. Substitua o comando for da classe de teste pelo comando do/while.