2014-1 Aed1 Ed01 PDF

PUC-Minas - Cincia da Computao
AED1 Estudo Dirigido 01

Perodo: 24-28/02/2014
Tema: Introduo programao

Atividade: Montagem de programas em Java
01.) Editar e salvar um esboo de programa em Java,

o nome do arquivo dever ser Exemplo0001.java,
tal como o nome da classe abaixo,
concordando maisculas e minsculas, sem espaos em branco:
/**
* Exemplo0001
*
* @author
* @version 01
*/
// ---------------------------------------------- dependencias
import IO.*;
// ---------------------------------------------- definicao da classe principal
public class Exemplo0001

{
// ---------------------------------------------- definicao de metodos
// ---------------------------------------------- definicao do metodo principal
/**
* main() metodo principal
*/
public static void main ( String [ ] args )
{
IO.println ( "EXEMPLO0001 - Programa em Java" );
IO.println ( "Autor: ________________________" );
IO.pause ( Apertar ENTER para terminar. );
} // fim main( )
} // fim class Exemplo0001
// ---------------------------------------------- documentacao complementar

//
// ---------------------------------------------- historico
//
// Versao Data Modificacao
// 0.1 01/08 esboco
//
// ---------------------------------------------- testes
//
// Versao Teste
// 0.1 01. ( ___ ) identificacao de programa
//
02.) Compilar o programa.
Se houver erros, identificar individualmente a referncia para a linha onde ocorrem.
Consultar atentamente o modelo acima na linha onde ocorreu o erro (e tambm linhas prximas),
editar as modificaes necessrias.
Compilar novamente e proceder assim at que todos os erros tenham sido resolvidos.
Se no houver erros, seguir para o prximo passo.
DICA: Se precisar de ajuda sobre como proceder a compilao,
consultar os vdeos com as demonstraes sobre algumas formas para faz-lo.
SUGESTO: Para se acostumar ao tratamento de erros,

registrar a mensagem de erro (como comentrio)
e o que foi feito para resolv-lo.
03.) Executar o programa.

Observar as sadas.
Registrar os resultados.
// ---------------------------------------------- testes
//
// Versao Teste
// 0.1 01. ( OK ) identificacao de programa
//
Em caso de erro (ou dvida), usar comentrios para registrar a ocorrncia e,

posteriormente, tentar resolv-lo (ou esclarecer a dvida).
04.) Copiar a verso atual do programa para outra (nova) Exemplo0002.java.
05.) Editar mudanas no nome do programa e verso,

conforme as indicaes a seguir,
tomando o cuidado de modificar todas as referncias,
inclusive as presentes em comentrios.
Incluir na documentao complementar as alteraes feitas,
acrescentar indicaes de mudana de verso e
prever novos testes.
/**
* Exemplo0002
*
* @author
* @version 02
*/
// ---------------------------------------------- dependencias
import IO.*;
// ---------------------------------------------- definicao da classe principal
public class Exemplo0002

{
// ---------------------------------------------- definicao de metodos
// ---------------------------------------------- definicao do metodo principal
/**
* main() metodo principal
*/
{
IO.println ( "Autor: ________________________" );
} // fim main( )
} // fim class Exemplo0002
// ---------------------------------------------- documentacao complementar

//
// ---------------------------------------------- historico
//
// Versao Data Modificacao
// 0.1 01/08 esboco
// 0.2 01/08 mudana de verso
//
// ---------------------------------------------- testes
//
// Versao Teste
// 0.2 01. ( ___ ) identificacao de programa
//
06.) Compilar o programa novamente.

Se houver erros, resolv-los e compilar novamente, at que todos tenham sido resolvidos.
Observar as sadas.
// ---------------------------------------------- testes
//
// Versao Teste
//
09.) Acrescentar ao programa a definio de um dado (x)

para armazenar valor inteiro:

{
// definicao de dados
int x = 0; // valor inicial definido

IO.println ( "Autor: ________________________" );
IO.println ( x = + x ); // exibir valor do dado
} // fim main( )
DICA: O melhor lugar para se colocar as definies de dados

prximo aos cabealhos (assinaturas) dos mtodos (ou da classe),
pois ficar mais fcil localiz-los no futuro.
SUGESTO: Recomenda-se uma rpida compilao

para verificar se a introduo de um novo dado
ocorre sem inserir erros no programa existente.
Recomenda-se tambm definir valores iniciais
para os dados que serviro como variveis,
segundo o tipo valor que armazenaro.
Portanto, se quiser experimentar a forma de definio abaixo,
ela no dever ter qualquer consequncia sobre o resultado.
int x; // forma alternativa, sem definir o valor inicial...
...
x = 0; // e definir o valor depois

IO.println ( x = + x ); // exibir valor do dado apos a definicao

11.) Acrescentar ao programa uma modificao do valor armazenado no dado (x):

{
// definir dados
int x = 0;

IO.println ( "Autor: ________________________" );
x = 5; // atribuir novo valor ao dado

IO.println ( x = + x ); // exibir novo valor do dado

} // fim main( )
DICA: A atribuio (ou transferncia de valor) para o dado ser sempre feita
com a referncia para o dado (nome ou destino) esquerda do sinal de
atribuio (=), e o valor a ser transferido direita deste (fonte).
SUGESTO: Recomenda-se uma rpida compilao

para verificar se a introduo de um novo comando
ocorre sem inserir erros no programa existente.
12.) Acrescentar ao programa uma forma de se exibir o valor do dado (x):

{
// definir dado
int x = 0;

IO.println ( "Autor: ________________________" );
IO.println ( x = + x ); // exibir valor do dado antes

x = 5; // atribuir valor ao dado
IO.println ( x = + x ); // exibir valor do dado depois

} // fim main( )
DICA: A exibio (ou transferncia para a sada padro) de valor de um dado poder ser feita,
sempre que necessrio, para se consultar o que estiver armazenado.
Como a sada exige uma converso para os smbolos correspondentes aos padres
da lngua do usurio, faz-se necessrio converter valores numricos em equivalentes
literais (caracteres), o que ser indicado mediante a sequncia (String) entre aspas
que anteceder a referncia para o valor a ser convertido (x).
O sinal (+) indicar, neste caso, uma operao particular de composio
(chamada de concatenao) da sequncia com a converso do valor.
Para essa operao ser bem sucedida, a sequncia dever sempre vir primeiro,
e entre aspas, se tiver um contedo constante.
SUGESTO: Recomenda-se preceder a exibio do valor pelo nome escolhido para o mesmo.
13.) Acrescentar na documentao complementar
a indicao de teste do dado introduzido.
// ---------------------------------------------- testes
//
// Versao Teste
// 02. ( ___ ) introduo de dado inteiro
//


Observar as sadas.
// ---------------------------------------------- testes
//
// Versao Teste
// 02. ( OK ) introduo de dado inteiro
//
17.) Acrescentar a atribuio inicial de valor ao dado e

suspender a execuo da atribuio mediante uso de comentrio (//),
conforme indicado abaixo.

{
// definir dado
int x = 5; // forma alternativa para definir dado com valor inicial

IO.println ( "Autor: ________________________" );
// x = 5; // atribuir valor ao dado

} // fim main( )

Observar as sadas.
// ---------------------------------------------- testes
//
// Versao Teste
// 03. ( OK ) introduo de dado inteiro com valor inicial
//
20.) Alterar a atribuio inicial, conforme indicado abaixo.

{
// definir dado
int x = 2+3; // forma alternativa para definir valor inicial por operao

IO.println ( "Autor: ________________________" );
X = IO.readint ( "Entrar com um valor inteiro: " );
IO.println ( x = + x ); // exibir valor lido

} // fim main( )


Observar as sadas.
// ---------------------------------------------- testes
//
// Versao Teste
// 03. ( OK ) introduo de dado inteiro com valor inicial
// 04. ( OK ) introduo de dado inteiro com valor inicial com operao
//
Exerccios:
DICAS GERAIS: Consultar o Anexo Java 02 na apostila para outros exemplos.
Prever, realizar e registrar todos os testes efetuados.
01.) Fazer um programa (Exemplo0006) capaz de guardar e mostrar um valor literal (char).
DICAS: Copiar o modelo do Exemplo0005, e realizar as modificaes sugeridas abaixo.
Para definir (em substituio definio anterior):
char x;
Para atribuir um valor constante:
x = A; // um nico smbolo, sempre entre apstrofos
Para mostrar, manter o comando para exibio:
IO.println ( "x=" + x );
Para ler um caractere por vez e armazen-lo, antes de mostrar seu valor:
x = IO.readchar ( Entrar com um caractere: );
Repetir o comando para exibir o valor lido.
02.) Fazer um programa (Exemplo0007) capaz de guardar e mostrar um valor real (double).
DICAS: Repetir o procedimento indicado no exerccio anterior.
Para definir:
double x;
Para atribuir um valor constante:
x = 43.21; // parte inteira separada da fracionria por ponto
Mostrar o valor atribudo.
Para ler um dado real e armazen-lo, antes de mostrar seu valor:
x = IO.readdouble ( Entrar com um valor real: );

03.) Fazer um programa (Exemplo0008) capaz de guardar e mostrar um valor lgico (boolean).
DICAS: Para definir:
boolean x;
Para atribuir:
x = true; // ou false
Para ler um dado lgico e armazen-lo, antes de mostrar seu valor:
x = IO.readboolean ( Entrar com um valor lgico: );
OBS.: Para testar. usar apenas as palavras true ou false.
04.) Fazer um programa (Exemplo0009) capaz de guardar e mostrar uma sequncia de literais (String).
String x;
Para atribuir:
x = 43.21; // uma sequncia de literais (caracteres) deve sempre vir entre aspas
Para ler um dado literal e armazen-lo, antes de mostrar seu valor:
x = IO.readString ( Entrar com uma cadeia de caracteres: );

05.) Fazer um programa (Exemplo0010) capaz de guardar e mostrar uma sequncia de literais (String)
cujo valor ser atribudo a partir da converso de um valor inteiro.
String x;
int y = 5;
Para atribuir:
x = +y; // uma sequncia de literais vazia ( )

// concatenada converso de valor inteiro (y)
Para mostrar, manter o comando para exibir apenas (x) e acrescentar outro para (y).
cujo valor ser atribudo a partir da converso de um valor inteiro somado a outro real.
String x;
int y = 5;
double z = 0.4;
Para atribuir:
x = +(y+z); // uma sequncia de literais vazia ( )

// concatenada soma (por isso o parnteses) da converso de valor real
Para mostrar, manter o comando para exibir apenas (x) e acrescentar outros para (y e z).
cujo valor ser atribudo a partir da converso de um valor lgico (ou booleano).
String x;
int y = 5;
double z = 0.4;
boolean w;
Para atribuir:
w = (y>z); // operao relacional para se avaliar uma condio

x = + w; // uma sequncia de literais vazia ( ) concatenada converso de valor lgico
Para mostrar, acrescentar um comando para cada valor.

cujo valor ser exibido a partir da converso de um valor lgico (ou booleano).
String x;
int y = 5;
double z = 0.4;
boolean w;
Sem usar atribuies, incluir a expresso em um comando para exibir o resultado:
x = +(y>z) // uma sequncia de literais vazia ( ) concatenada

// ao resultado do teste (por isso o parnteses) entre valores inteiro e real
Para mostrar, acrescentar um comando para cada valor.
09.) Fazer um programa (Exemplo0014) capaz de guardar e mostrar valores inteiros (int)
cujos valores sero lidos da entrada padro.
int x;
int y;
Para ler um valor inteiro por vez e armazen-lo,

antes de mostra-lo:
x = IO.readint ( Entrar com um valor inteiro: );
Para mostrar, usar o mesmo comando do primeiro exerccio:
IO.println ( "x=" + x );
E repetir os comandos para ler e exibir o valor do outro dado.

10.) Fazer um programa (Exemplo0015) capaz de guardar dois dados reais (double)
cujos valores sero lidos da entrada padro, somados e exibidos,
bem como o resultado de sua soma.
double x, y; // possvel definir mais de um dado do mesmo tipo
Para ler um valor real e armazen-lo em um dado,

antes de mostrar seu valor:
x = IO.readdouble ( Entrar com um valor real: );
Acrescentar um comando para ler o valor de (y).
Para mostrar, usar um comando para os dois valores, juntos.
IO.println ( "x=" + x + " y=" + y );
11.) Fazer um programa (Exemplo0016) capaz de guardar dois dados literais (char)
cujos valores sero lidos da entrada padro e mostrados separadamente.
char x, y; // possvel definir mais de um dado do mesmo tipo
Para ler um caractere por vez e armazen-lo em um dado,

Acrescentar um comando para ler o valor de (y).
Para mostrar, usar um comando para os dois valores, juntos.

12.) Fazer um programa (Exemplo0017) capaz de guardar dois dados literais (char)
cujos valores sero lidos da entrada padro e mostrar o resultado de sua concatenao (+)
em uma nica cadeia de caracteres (z).
char x, y; // possvel definir mais de um dado do mesmo tipo

String z; // para guardar o resultado
// rever as dicas dos exerccios 05 (Exemplo0010) e 06 (Exemplo0011)
Para ler um caractere e armazen-lo em um dado,

Para ler o valor de (y), usar a forma alternativa:
z = IO.readString ( "Entrar com outro caractere: " );
y = IO.getchar ( z ); // para extrair o primeiro caractere do que for lido
Para concatenar os valores lidos em (z), usar o modelo do exerccio 06:
Para mostrar, usar um comando para o resultado com os dois valores concatenados.
13.) Fazer um programa (Exemplo0018) capaz de guardar dois dados literais (String)
cujos valores sero lidos da entrada padro e mostrar o resultado de sua concatenao (+)
em uma nica cadeia de caracteres (z).
String x, y; // possvel definir mais de um dado do mesmo tipo

String z; // para guardar o resultado da concatenao
Para ler uma cadeia de caracteres e armazen-los em um dado,

x = IO.readString ( Entrar com uma sequencia de caracteres: );
Fazer o mesmo para (y).
Ao concatenar, incluir uma separador entre eles ( | ).
Para mostrar, usar um comando para o resultado dos dois valores concatenados,
com o separador entre eles.
14.) Fazer um programa (Exemplo0019) capaz de guardar dois dados literais (String)
e dois inteiros cujos valores sero lidos da entrada padro, e mostrar como o resultado
a sua concatenao (+) em uma nica cadeia de caracteres (z).
String x, y; // possvel definir mais de um dado do mesmo tipo

int a, b;
String z; // para guardar o resultado da concatenao de (x) com (a) e (y) com (b)
Para ler uma cadeia de caracteres e armazen-la:
x = IO.readString ( Entrar com uma sequencia de caracteres: );
Repetir para a outra varivel literal ( y );
Para ler um dos valores inteiros e guard-lo em seu respectivo armazenador,

usar a sugesto do exerccio 09 (Exemplo0014).
Para ler e guardar um valor inteiro, experimentar a forma alternativa:
z = IO.readString ( "Entrar com uma sequencia de dgitos: " );
a = IO.getint ( z ); // para tentar converter de literal para valor inteiro
Para armazenar uma informao nova no mesmo lugar da memria,

juntando cadeia de caracteres com outro tipo de valor:
x = x + a;
Repetir para (y).
Para mostrar, usar um comando para cada valor resultante (x e y).

15.) Fazer um programa (Exemplo0020) capaz de guardar e mostrar dados reais (double)
e inteiros cujos valores sero lidos da entrada padro bem como o resultado de sua
concatenao (+) em uma nica cadeia de caracteres (z), antes de mostrar tudo.
double x, y;
int a, b;
String z ; // para guardar o resultado da concatenao

// e mostrar apenas seu valor ao final
Para ler um dos valores reais e guard-lo em seu respectivo armazenador,

usar a sugesto do exerccio 10.
Para ler um dos valores inteiros e guard-lo em seu respectivo armazenador,

usar a sugesto do exerccio 09.
Para ler e guardar o segundo valor real, experimentar a forma alternativa:
z = IO.readString ( "Entrar com uma sequencia de dgitos: " );
b = IO.getdouble ( z ); // para tentar converter de literal para valor real
Para ler e guardar o segundo valor inteiro, experimentar a forma alternativa,

como descrito no exerccio 14.
Para armazenar informaes em um mesmo lugar da memria,

juntando cadeia de caracteres com outro tipo de valor:
z = "(" + x + "," + a + );
Mostrar continuar juntando outras cadeias de caracteres:
z = z+ "(" +y + "," + b);
Mostrar o valor final (z), concatenados o par (x,a) e o par (y,b) em um nico valor.

2014-1 Aed1 Ed01 PDF

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

2014-1 Aed1 Ed01 PDF

Caricato da

Copyright:

Formati disponibili

PUC-Minas - Cincia da Computao

AED1 Estudo Dirigido 01

Tema: Introduo programao

01.) Editar e salvar um esboo de programa em Java,

// ---------------------------------------------- definicao da classe principal

public class Exemplo0001

// ---------------------------------------------- definicao do metodo principal

// ---------------------------------------------- documentacao complementar

SUGESTO: Para se acostumar ao tratamento de erros,

03.) Executar o programa.

Em caso de erro (ou dvida), usar comentrios para registrar a ocorrncia e,

04.) Copiar a verso atual do programa para outra (nova) Exemplo0002.java.

05.) Editar mudanas no nome do programa e verso,

// ---------------------------------------------- definicao da classe principal

public class Exemplo0002

// ---------------------------------------------- definicao do metodo principal

// ---------------------------------------------- documentacao complementar

06.) Compilar o programa novamente.

08.) Copiar a verso atual do programa para outra (nova) Exemplo0003.java.

09.) Acrescentar ao programa a definio de um dado (x)

public static void main ( String [ ] args )

IO.println ( "EXEMPLO0003 - Programa em Java" );

DICA: O melhor lugar para se colocar as definies de dados

SUGESTO: Recomenda-se uma rpida compilao

int x; // forma alternativa, sem definir o valor inicial...

x = 0; // e definir o valor depois

10.) Copiar a verso atual do programa para outra (nova) Exemplo0004.java.

public static void main ( String [ ] args )

IO.println ( "EXEMPLO0004 - Programa em Java" );

x = 5; // atribuir novo valor ao dado

IO.pause ( Apertar ENTER para terminar. );

SUGESTO: Recomenda-se uma rpida compilao

12.) Acrescentar ao programa uma forma de se exibir o valor do dado (x):

public static void main ( String [ ] args )

IO.println ( "EXEMPLO0004 - Programa em Java" );

IO.println ( x = + x ); // exibir valor do dado antes

IO.pause ( Apertar ENTER para terminar. );

14.) Compilar o programa novamente.

15.) Executar o programa.

16.) Copiar a verso atual do programa para outra (nova) Exemplo0005.java.

17.) Acrescentar a atribuio inicial de valor ao dado e

public static void main ( String [ ] args )

IO.println ( "EXEMPLO0005 - Programa em Java" );

// x = 5; // atribuir valor ao dado

IO.println ( x = + x ); // exibir valor do dado

IO.pause ( Apertar ENTER para terminar. );

18.) Compilar o programa novamente.

20.) Alterar a atribuio inicial, conforme indicado abaixo.

public static void main ( String [ ] args )

IO.println ( "EXEMPLO0005 - Programa em Java" );

IO.println ( x = + x ); // exibir valor do dado

X = IO.readint ( "Entrar com um valor inteiro: " );

IO.println ( x = + x ); // exibir valor lido

IO.pause ( Apertar ENTER para terminar. );

21.) Compilar o programa novamente.

22.) Executar o programa.

Para atribuir um valor constante:

x = A; // um nico smbolo, sempre entre apstrofos

Para mostrar, manter o comando para exibio:

x = IO.readchar ( Entrar com um caractere: );

Repetir o comando para exibir o valor lido.

Para atribuir um valor constante:

x = 43.21; // parte inteira separada da fracionria por ponto