clp-2006-02

Prova Final de Características das Linguagens de Programação – 2006-02
1a questão (3
pontos): O código a seguir define e implementa a classe
ListOfNumbers. Esta classe cria um objeto do tipo Vector que contém 10
elementos Integer com valores seqüenciais de 0 a 9. A classe ListOfNumbers
também define o método writeList, o qual escreve a lista de números no arquivo
texto OutFile.txt. São utilizadas classes para output definidas no package
java.io.
//Nota: Esta classe não irá compilar corretamente!
import java.io.*;
import java.util.Vector;
public class ListOfNumbers {
private Vector vector;
private static final int SIZE = 10;
public ListOfNumbers () {
vector = new Vector(SIZE);
for (int i = 0; i < SIZE; i++) {
vector.addElement(new Integer(i));
}
}
public void writeList() {
PrintWriter out = new PrintWriter(
new FileWriter("OutFile.txt"));
for (int i = 0; i < SIZE; i++) {
out.println("Value at: " + i + " = " +
vector.elementAt(i));
}
out.close();
}
}
Responda: I) Que exceções (exceptions) podem ser lançadas em decorrência da execução dos
comandos mostrados em negrito-cor azul?
II) Altere o código acima, de forma a tratar as exceções eventualmente lançadas pelos
comandos em negrito-cor azul no corpo do método writeList. Sugestão: Use o
bloco finally para fechar o objeto out.
III) Relativamente ao código da 1a questão que comando você deveria acrescentar ao
método writeList, de forma a que este fosse responsável pelo lançamento da
exceções e o código resultante fosse corretamente compilado?
IV) Suponha que você não deseje, em hipótese alguma, imprimir valores maiores que
1000 no arquivo "OutFile.txt". Que comandos você deveria acrescentar ao
código acima para lançar uma exceção do tipo ValuetoLargeException?
Sugestão: inspire-se no código situado no diretório chap09/bankaccount do livro
Java
Now.
Em
nosso
lab
ele
situa-se
no
path
../Java/javacode/javanow/chap09/bankaccount.
2a questão (3 pontos): Considere o código a seguir de um applet, denominado
UpdateApplet, que mantém um thread para automaticamente atualizar o seu
display em intervalos regulares.
//package exploringjava.threads;
public class UpdateApplet extends java.applet.Applet implements Runnable {
private Thread updateThread;
int updateInterval = 1000;
public void run() {
while ( true ) {
try {
Thread.sleep( updateInterval );
} catch (InterruptedException e ) {
return;
}
repaint();
}
}
public void start() {
if ( updateThread == null ) {
updateThread = new Thread(this);
updateThread.start();
}
}
public void stop() {
if ( updateThread != null ) {
updateThread.stop();
updateThread = null;
}
}
}
Usando herança, codifique um applet, denominado Clock, que simplesmente mostre na tela, em
intervalos regulares de 1 segundo, o tempo corrente do sistema.
Atenção: nas questões 3, 4 e 5, cada opção errada assinalada, descontará uma opção
corretamente assinalada!
3a questão (2 pontos): Considere o modelo para tratamento de eventos da AWT denominado
Delegation Model (1.1 AWT Event Model). Considerando as afirmações abaixo,
relativamente ao Delegation Model, assinale a(s) opção(opções) correta(s).
Afirmações sobre o AWT Delegation Model
1. Vários objetos receptores (listeners) de eventos podem receber (tratar) eventos de
todos os tipos gerados (emitidos) por diversos objetos geradores de eventos;
2. Eventos de um determinado tipo só podem ser tratados por manipuladores de eventos
que sejam todos instâncias de uma única classe;
3. É opcional registrar uma instância de uma classe manipuladora de eventos como uma
receptora de eventos para eventos gerados por um componente específico;
4. Tratadores de eventos (Event handlers) só podem ser instâncias de classes específicas,
associadas aos tipos de eventos gerados;
5. No comando “class” do tratador de eventos (event handler) deve-se obrigatoriamente
incluir um trecho de código, indicando que a classe tratadora de eventos implementa a
interface receptora (listener) correspondente ao tipo de evento que se deseja tratar;
4a questão (2 pontos): Considere o código abaixo, que implementa um servidor para jogar jogo
da velha com diversos clientes simultaneamente. Assuma que o protocolo existente entre o
cliente e o servidor consiste de uma descrição do jogo em seu estágio atual [já incluindo a jogada
do cliente e/ou servidor, seguida de um caráter de <new line> (\n)]. Assinale apenas as
afirmações corretas após o código que se segue.
import java.net.*;
import java.io.*;
import java.util.*;
public class ServidorJogoDaVelha {
public static void main( String argv[] ) throws IOException {
ServerSocket ss = new ServerSocket( Integer.parseInt(argv[0]) );
while ( true )
new JogoDaVelhaConnection( ss.accept() );
}
}
class JogoDaVelhaConnection extends Thread {
Socket sock;
JogoDaVelhaConnection ( Socket s ) {
sock = s;
setPriority( NORM_PRIORITY - 1 );
start();
}
public void run() {
try {
OutputStream out = sock.getOutputStream();
String req = new DataInputStream(sock.getInputStream()).readLine;
// processa a requisição do cliente, isto é, comandos para "ler" a descrição atual do
// a jogo (já incluída a jogada do cliente), e analisá-la;
// Repare que, no início do jogo, o cliente simplesmente realiza a
// conexão – solicitando jogar - e não envia nenhuma descrição do
// jogo. A descrição inicial do jogo é, então, enviada pelo servidor ao // cliente.
....
....
// o servidor responde adequadamente, isto é, envia para o cliente
// uma nova descrição do jogo (já incluída a jogada-resposta do
// servidor)
...
...
// algo como:
// PrintStream(out).println (“representação simbólica de uma nova descrição do
// jogo”);
sock.close();
}
catch ( IOException e ) {
System.out.println( "I/O error " + e );
}
}
}
Afirmações:
1. O servidor jamais sairá do loop iniciado pelo comando “while (true)”.
2. Todos os comandos deste servidor podem ser executados em “paralelo”, devido à
presença de múltiplos threads de execução.
3. Caso só exista apenas um cliente e após findo o jogo deste único cliente com o servidor,
será executado o comando “sock.close()”, que fechará o socket entre o cliente e o
servidor, terminando, assim, a execução do servidor.
4. O comando “setPriority( NORM_PRIORITY - 1 );” indica que o
atendimento a cada cliente terá uma prioridade diferente, para evitar que o servidor entre
em “deadlock”, em virtude de não ter como atender a mais de um cliente com a mesma
prioridade.
5. Apenas um cliente de cada vez poderá executar o trecho correspondente aos comandos:
OutputStream out = sock.getOutputStream();
String req = new DataInputStream(sock.getInputStream()).readLine;
Apenas um cliente de cada vez poderá executar o trecho correspondente aos comandos:
JogoDaVelhaConnection ( Socket s ) {
sock = s;
setPriority( NORM_PRIORITY - 1 );
start();
7. Somente podem ser executados em paralelo no servidor, os commandos compreendidos
pelo método “run()”.
8. Caso já exista um servidor atuando na porta indicada por “argv[0]” o loop
while ( true )
new JogoDaVelhaConnection( ss.accept() );
}
não será executado.
6.
5a questão (2 pontos): Assinale a(s) afirmação(ões) correta(s) :
a) Herança é quando uma classe herda de outra classe, apenas alguns métodos que lhe
interessa;
b) Polimorfismo é o recurso de determinadas linguagens orientadas a objeto que permitem a
um único objeto tomar a forma, em sua totalidade, de diferentes objetos, dependendo do
contexto;
c) Overload de um método é quando o método torna-se excessivamente carregado de
código, impactando o uso da cpu ou, até mesmo, podendo causar um overflow na pilha do
sistema;
d) Encapsulamento é quando desejamos evitar que a implementação de um método seja de
conhecimento geral, isto é, sejam visíveis a partir de outros objetos. Para implementar
esta característica as linguagens orientadas a objeto fornecem modificadores de acesso
que, quando aplicados a variáveis de instância e métodos, alteram o grau de visibilidade
destes;
e) Abstração é a característica das linguagens orientadas a objeto que nos permite não
considerar certas dificuldades de implementação, concentrando-nos apenas nos aspectos
para os quais a linguagem nos oferece os recursos necessários à implementação dos
objetos desejados;
f) Hierarquia é quando uma classe determina a uma subclasse quais as variáveis de instância
a que ela pode ter acesso e quais os métodos que ela pode executar.
g) Persistência é a característica de algumas linguagens orientadas a objeto que possuem
variáveis globais. Em função desta característica estas variáveis globais podem
“persistir”, isto é, permanecerem ativas, durante todo o tempo de execução do programa.