AULA PRÁTICA Nº 2

Introdução

Um comando de seleção define uma condição em um programa, que permite que grupos de comandos sejam executados de maneira condicional, de acordo com o resultado da avaliação de um determinado teste (verdadeiro ou falso). Ou seja, programas utilizam comandos de seleção para escolher entre cursos alternativos de ações. A sintaxe do comando de seleção em Java é:

if (expressão-booleana) comando1 else comando2

O comando1 (seja lá o que for), será executado se o resultado da avaliação de expressãobooleana for verdadeiro (digamos x > 3). Caso contrário (else) o comando2 será executado.

Comentários:

•Vários comandos podem ser executados na cláusula if ou na cláusula else, bastando para isso que sejam usados os delimitadores de escopo { } (abre chaves e fecha chaves).

•Comandos de seleção podem existir dentro de outros comandos de seleção (na cláusula if ou else).

Comandos de seleção são estruturas de controle básicas de qualquer linguagem de programação e devem por isso ser largamente estudadas e praticadas pelos alunos (ou seja, os alunos são aconselhados a resolverem vários tipos de problemas diferentes usando comandos de seleção).

Comando if - else

1)O programa utilizado nesta prática lê a idade de uma pessoa e imprime mensagens com orientações sobre a sua situação eleitoral.

2)Crie uma classe “Selecao” e preencha o método main para que fique parecido com o seguinte trecho de código.

3{
5{
6Scanner sc = new Scanner(System.in);
7System.out.println("Entre com a sua idade: ");
8int idade = sc.nextInt();
9if (idade < 16)
10System.out.println("Você não está habilitado a votar!");
1Else
13}

3)O comando de seleção da linha “9” testa se a idade é menor que 16 anos. O resultado da avaliação da expressão booleana (idade < 16) pode ser verdadeiro (true) ou falso (false). Caso seja verdadeiro, o fluxo do programa entrará na cláusula if, e a mensagem “Você não está habilitado a votar!” será impressa. Caso contrário, o programa entrará na cláusula else, e a mensagem “Eleitor! Exerça o seu direito!” será impressa.

Comandos de seleção aninhados

4)Comandos de seleção podem aparecer dentro de outros comandos de seleção, ou seja, eles podem ser “aninhados”. Diferentes maneiras de escrever comandos aninhados podem ser usadas. como pode ser visto abaixo. A forma no lado esquerdo é a tradicional, que consome mais linhas de programa. No lado direito está uma forma mais compacta que será usada nesta prática.

comando2else if (condicao3)
elsecomando3
if (condicao3)
comando3

if (condicao1)if (condicao1) comando1 comando1 else else if (condicao2) if (condicao2) comando2

5)Faça uma cópia da classe utilizada na seção anterior (para preservar o exemplo anterior).

6)A mensagem apresentada ao eleitor não contempla todos os casos com exatidão, pois os jovens entre 16 e 18 anos têm o direito de votar, mas não a obrigação, enquanto que os maiores de 70 anos não tem mais obrigação de votar, embora possam continuar exercendo o seu o direito de votar. O programa abaixo trata esses casos, usando comandos de seleção aninhados. Reescreva o seu programa.

9if (idade < 16) 10 System.out.println("Você ainda não está habilitado a votar!"); 11else if (idade < 18) 12 System.out.println("Jovem! Você tem o direito de votar!"); 13else if (idade < 70) 14 System.out.println("Eleitor! Exerça o seu direito e dever!"); 15else if (idade >= 70) 16 System.out.println("Cidadão! Seu voto não é obrigatório!");

Aumentando a complexidade da expressão booleana (operadores && e ||)

7)Nesta seção será apresentado o uso de expressões booleanas mais complexas, usando os operadores && (E lógico) e || (OU lógico). A tabela verdade para esses operadores booleanos é ilustrada a seguir:

Cond1 Cond2 Resultado Cond1 Cond2 Resultado V V V V V V V F F V F V F V F F V V F F F F F F

8)Faça uma nova cópia da classe utilizada na seção anterior.

9)Usando os operadores E e OU, é possível condensar a programação das linhas 1 a 16 (6 linhas) da seção 6 em apenas 4 linhas. Substitua-as pelas linhas abaixo:

11if (idade >= 18 && idade < 70)

12 System.out.println("Para você, votar é um direito e uma obrigação!");

13if ((idade >=16 && idade < 18) || idade >= 70)

14 System.out.println("Para você, votar é um direito, mas não é uma obrigação!");

10)Na linha “12” a expressão booleana garante que a mensagem “Para você, votar é um direito e uma obrigação!” somente será impresso caso a idade seja maior ou igual a 18 e menor que 70 anos. O operador “&&” garante que as duas condições devem ser verdadeiras para que a expressão booleana seja avaliada como verdadeira.

1)Na linha “14” a mensagem “Para você, votar é um direito, mas não é uma obrigação!” é impressa em duas situações (uma ou outra). A primeira ocorre quando a idade for maior ou igual a 16 e menor que 18 anos. A segunda ocorre quando a idade for maior ou igual a 70 anos. A primeira condição está entre parênteses para garantir que seja avaliada em primeiro lugar.

12)Repare que este exemplo é apenas ilustrativo das possibilidades de utilização de comando de seleção em Java.

Grupo de vários comandos dentro de um único comando de seleção

13)Nessa seção o programa da seção 2 é re-escrito, usando múltiplos comandos dentro das cláusulas if e else. Para que isso possa ser feito, deve-se utilizar os delimitadores de escopo { } (abre e fecha chaves).

14)Faça uma cópia da classe da seção anterior e reescreva o programa para ficar semelhante ao programa abaixo:

12 System.out.println("Você ainda não está habilitado a votar!");

System.out.println("O voto é um direito reservado para os maiores de 16 anos.");

13 espera = 16 – idade;

19System.out.println("O voto é obrigatório para os maiores de 18 e

20 espera = 70 - idade;

2System.out.println("Daqui a " + espera + " anos você não

21 if (espera > 0) será mais obrigado a votar.");

24System.out.println("Já faz " + (-espera) + " anos que você

23 Else não é mais obrigado a votar.");

15)Neste programa, as chaves abertas na linha “1” e fechadas na linha “15” indicam que os comandos nas linhas “12”, “13” e “14” deverão ser executados quando a idade for menor que 16 anos. Em caso contrário, são os comandos das linhas “18” a “24” que devem ser executados.

Estruturas de repetição: Laços

Introdução

Nesta prática serão empregados as estruturas de repetição (laços), do...while, while e for para a implementação de simulações numérica. Dentro do contexto da programação orientada a objetos, um programa será construído para o cálculo de funções polinomiais de primeiro, segundo e terceiro grau:

f(x) = ax + b(primeiro grau)
f(x) = ax2 + bx + c(segundo grau)
f(x) = ax3 + bx2 + cx + d(terceiro grau)

Será construída uma classe chamada polinomio onde os métodos implementão as funções e outra classe de CalculaFuncao com um método main, para usá-la e testá-la.

Além disso, iremos usar a estrutura de seleção switch, para selecionar o grau do polinômio, com a finalidade de exibir três implementações diferentes de laços. Para esse fim, as funções serão implementadas dentro de um domínio (x) onde as variáveis de entrada desse programa serão o valor mínimo de x, o valor máximo de x e o número de pontos nesse intervalo.

Por fim, utilizaremos janelas gráficas de entrada de dados, e a janela de output para a saída de duas colunas de dados, x e f(x) respectivamente.

O exercício será iniciado de maneira mais simples e a complexidade será adicionada aos poucos.

Criando uma classe ‘polinomio’

1.Crie uma classe Polinomio, que terá quatro atributos (os valores dos coeficientes) e um método para calcular o valor da função.

2
3private double coefA, coefB, coefC, coefD;
5public Polinomio(double a, double b, double c, double d) {
6coefA = a;
7coefB = b;
8coefC = c;
10}
12public double calcula (double x)
13{
14double f=(coefA * x * x * x) + (coefB * x * x) + (coefC * x) + coefD;
15return f;
16}

Testando os polinômios via classe “CalculaFuncao”

2.Dentro do método public static void main(String[] args) da classe CalculaFuncao, serão colocados os comandos para para que os polinômios possam ser testados no programa, confrome exibido no código abaixo.

5
6public static void main(String[] args) {
8double coefX0=0.0, coefX1=0.0, coefX2=0.0, coefX3=0.0;
9
10coefX0 = Double.parseDouble(JOptionPane.showInputDialog("Coeficiente de x0"));
1coefX1 = Double.parseDouble(JOptionPane.showInputDialog("Coeficiente de x1"));
12coefX2 = Double.parseDouble(JOptionPane.showInputDialog("Coeficiente de x2"));
13coefX3 = Double.parseDouble(JOptionPane.showInputDialog("Coeficiente de x3"));
15Polinomio f = new Polinomio (coefX3, coefX2, coefX1, coefX0);
17double minX = Double.parseDouble(JOptionPane.showInputDialog("Valor mínimo de 'x'"));
18double maxX = Double.parseDouble(JOptionPane.showInputDialog("Valor máximo de 'x'"));
19double pontos = Double.parseDouble(JOptionPane.showInputDialog("Número de pontos "));
21double x = minX;
2double y;
23double incremento = (maxX - minX)/(pontos-1);
24System.out.println("x f(x)");
26while(x <= maxX) {
27y = f.calcula(x);
28System.out.printf("%4.4f \t%4.4f \n", x, y);
29x += incremento; // mesmo que x = x + incremento;
30}
31
32}
3

3.Execute o programa e verifique para as diferentes opções de entrada os respectivos resultados. O resultado deve ser semelhante a:

xf(x)

-10,0 -909,0

-7,7778-416,7915
-5,5556-145,1591
-3,3-28,2593
-1,1-0,2483
1,14,7174
3,352,4815
5,5556208,8875
7,7778539,7791

10,0 1,0

Apresentando os resultados graficamente (Microsoft Office)

4.Gere um gráfico da função escolhida, usando os valores de x e f(x) gerados pelo programa.

5.Para isso, abra uma planilha eletrônica (Microsoft Excel ou equivalente) e digite ou copie e cole os resultados.

6.Para copiar e colar irá surgir uma limitação, pois se quando se copiam as duas colunas e cola na planilha, a planilha entende como sendo apenas uma coluna. Uma solução é usar um programa de edição de textos (o Microsoft Word, por exemplo) como intermediário e cortar somente a primeira coluna e depois somente a segunda coluna. O Microsoft Word permite fazer isso pressionando as teclas Ctrl e Alt simultaneamente e marcando com o mouse, como mostrado abaixo:

7.Então, deve-se cortar (pressionando Ctrl+X) esta coluna e colar em uma coluna da planilha. Depois, fazer novamente para a segunda coluna.

8.Se a planilha for o Microsoft Excel, a geração de gráficos é feita através do botão

(ou Inserir/Gráfico) e a seguinte tela aparecerá, na qual se escolhe gráfico de dispersão com pontos de dados conectados por linhas suaves, como explicado.

9.Existem maneiras melhores de fazer isto. É possível escrever os dados de saída em um arquivo e depois importar na planilha. Além disso, pode-se desenhar o gráfico diretamente em Java. Estes seriam bons exercícios para os alunos interessados.

Polinômio e grau 1 a 3

10.Na classe CalculaFuncao apresentada, caso o usuário queira uma função polinomial de grau 1 ou 2, ele deve simplesmente fornecer valores zero para os coeficientes. Esta seção faz uma modificação para que o usuário escolha explicitamente o grau e como resultado somente a quantidade de coeficientes correta seja pedida.

1.Substitua as linhas 10 a 13 da classe CalculaFuncao apresentada acima pelas seguintes linhas e execute o programa novamente.

String menu = String.format("Escolha o grau do polinômio \n1 - Primeiro grau\n2 - Segundo grau\n3 - Terceiro grau\n\n"); int grau = Integer.parseInt(JoptionPane.showInputDialog(menu));

coefX2=Double.parseDouble(JOptionPane.showInputDialog("Coeficiente de x2"));
}

coefX0 = Double.parseDouble(JOptionPane.showInputDialog("Coeficiente de x0")); coefX1 = Double.parseDouble(JOptionPane.showInputDialog("Coeficiente de x1")); if (grau > 1) { if (grau > 2) { coefX3=Double.parseDouble(JOptionPane.showInputDialog("Coeficiente de x3")); }

Usando estruturas de repetição “do while” e “for”

12.Na classe CalculaFuncao, o cálculo da função foi realizado através de um comando do tipo “while”, que possui um teste no início do laço e a variável de controle precisa que sua variável de controle tenha o valor modificado dentro do corpo do laço para que ele chegue ao fim. Nesta seção, serão usados também os laços do tipo “do..while” e

13.No laço “do..while” o teste é executado no final do laço. A diferença é que neste caso os comandos dentro do laço são executados pelo menos uma vez, mesmo que a condição seja falsa logo de início da execução.

14.O laço “for” contem uma variável de controle que é inicializada e incrementada automaticamente, além de executar o teste.

15.Nesta seção, o programa será modificado para usar um tipo de laço para cada grau de função disponível (grau 1, 2 e 3). Note que neste caso isso não é necessário e não acrescenta funcionalidade nenhuma ao programa. O objetivo aqui é apenas didático.

16.Este exemplo também introduz o comando “switch” que é uma estrutura de múltipla escolha, ou seja, uma forma mais organizada de se testar múltiplas condições sem usar uma estrutura com comandos “if” aninhados.

17.Reestruture o seu programa para que ele fique da seguinte maneira.

switch (grau){
case 1:
while(x <= maxX) {
y = f.calcula(x);
System.out.printf("%4.4f %4.4f \n", x, y);
x += incremento;
}
break;
case 2:
do {
y = f.calcula(x);
System.out.printf("%4.4f %4.4f \n", x, y);
x += incremento;
} while(x <= maxX);
break;
case 3:
for(int i=1; i<=pontos; i++) {
y = f.calcula(x);
System.out.printf("%4.4f %4.4f \n", x, y);
x += incremento;
}
break;
}
}

Comentários