clp-1997-02-pf

Solução da Prova Final de Características de Linguagens de Programação
1997 – 20 Semestre
1a questão: Adicionaríamos o seguinte método à classe AppletFrontEnd (uma das possíveis soluções):
public boolean action(Event evt, Object arg) {
// possivelmente aqui haveria algum codigo extra da aplicação...
--switch (evt.id) {
case Event.ACTION_EVENT:
if ("Add".equals(evt.arg))
{
//código a ser executado ao se pressionar o botão “Add”
return true;
}
if ("Delete".equals(evt.arg))
{
//código a ser executado ao se pressionar o botão “Delete”
return true;
}
if ("Submit".equals(evt.arg))
{
//código a ser executado ao se pressionar o botão “Submit”
return true;
}
if ("Exit".equals(evt.arg))
{
//código a ser executado ao se pressionar o botão “Exit”
System.exit(0);
return true;
}
break;
default:
return false;
}
return true;
}
2a questão:
import java.net.*;
import java.io.*;
import java.util.*;
public class solution02 {
public static void main (String args[]) {
StringTokenizer st;
int token, count = 0;
String word = new String ("PUC"); //string a contar
String thisLine;
URL u;
File saida = new File ("puc-rio.html"); //armazena o documento
if (args.length > 0) {
//Open the URL for reading
try {
u = new URL(args[0]);
try {
DataInputStream theHTML = new DataInputStream(u.openStream());
PrintStream pout = new PrintStream (new FileOutputStream (saida));
try {
while ((thisLine = theHTML.readLine()) != null) {
st = new StringTokenizer(thisLine);
while (st.hasMoreTokens())
if (st.nextToken().toUpperCase().equals (word))
count++;
pout.print(thisLine); // inner while loop ends here
} // outer while loop ends here
pout.close();
System.out.println (word + "aparece " + count + " vezes em " +
u.toString());
} // end try
catch (Exception e) {
System.err.println(e);
}
} // end try
catch (Exception e) {
System.err.println(e);
}
} // end try
catch (MalformedURLException e) {
System.err.println(args[0] + " is not a parseable URL");
System.err.println(e);
}
} // end if
} // end main
} // end viewsource
3a questão: Uma explicação plausível:
O applet UpdateApplet caracteriza-se por efetuar o update da área que ocupa no vídeo a cada updateInterval
milisegundos (1000, no caso). Como UpdateApplet consegue este efeito? Inicialmente ele declara um thread de
nome updateThread. A cada vez que o applet se torna visível o método start() do applet é invocado e cria o
thread updateThread passando como parâmetro para o constructor a referência this do próprio UpdateApplet.
Inicia-se o thread recém-criado através da chamada ao método UpdateApplet.start(), o qual invoca de imediato o
método run() da classe target do thread, isto é, aquela que foi passada como parâmetro para o constructor de
updateThread - o próprio UpdateApplet via a referência this.
O método stop() é chamado sempre que o applet se torna invisível. Nesta ocasião termina-se a execução do thread
updateThread.
O método run(), que corresponde ao novo thread de execução, efetua a atualização do vídeo a intervalos de
updateInterval, ao invocar repaint(). Consegue-se este efeito através do while loop. No corpo do while suspende-se
o thread por 1 segundo e, após invoca-se repaint(), que por sua vez chama update() assim que puder, o qual
finalmente invoca paint(), responsável direto pela atualização do vídeo.
O applet Animation é uma classe de UpdateApplet, portanto herda todo o comportamento anteriormente descrito.
Em resumo, o método paint() de Animation estará sendo periodicamente invocado a intervalos de 1 segundo. Se
inserirmos no código de paint() um mecanismo que, ora pinte um círculo vermelho, ora pinte um círculo amarelo,
teremos o efeito desejado. Isto é conseguido através do tipo de dado primitivo toggle. Se toggle é true desenhamos
o círculo vermelho e alteramos toggle para false. Alternativamente se toggle é false pintamos o círculo amarelo e
alternamos toggle para true. Preste atenção que toggle deve ser declarado externamente ao método paint() para ter o
seu valor preservado entre as diversas invocações a paint().
4a questão:
// CopyTextFileandFilter.java
import java.io.*;
public class CopyTextFileandFilter {
public static void main(String[] args) {
String flag = new String("//Desconsidere esta linha");
if (args.length < 2) {
System.err.println("Usage: java CopyTextFile <src> <dest>");
return;
}
try {
DataInputStream istream = new DataInputStream(new
FileInputStream(args[0]));
PrintStream ostream = new PrintStream(new
FileOutputStream(args[1]));
String line;
while ((line = istream.readLine()) != null) {
if (! line.equals(flag))
ostream.println(line);
}
istream.close();
ostream.close();
}
catch (IOException e) {
System.err.println(e);
return;
}
}
}
5a questão:
Esta seria uma possível solução, em uma implementação minimalista:
(Você deveria adicionar ainda classes para manipular streams, tanto no Cliente quanto no servidor: FileInputStream,
FileOutputStream, etc..., e seuasmétodos respectivos)
No cliente:
Classes
URL
No Servidor


Métodos
public URL (String url) throws MalformedURLException
public URLConnection openConnection() throws java.IOException
Classes
ServerSocket
Socket
Thread









Métodos
public ServerSocket (int port) throws IOException, BindException
public Socket accept() throws IOException
public InputStream getInputStream() throws IOException
public OutputStream getOutputStream() throws IOException
public synchronized void close() throws IOException
public void start()
public void stop()
public void run()
public final void setPriority(int newPriority)
6a questão: Leia atentamente o código abaixo. Como, fundamentado no output deste código, você conseguiria
afirmar qual a política de scheduling adotada pela sua Java Virtual Machine? Justifique a sua resposta.
//codigo para descobrir qual a politica de Scheduling da sua MVJ:
//round robin ou time-slicing
class Thready {
public static void main(String args[]) {
new MyThread("Foo").start();
new MyThread("Bar").start();
}
}
class MyThread extends Thread {
String message;
MyThread (String message) {
this.message = message;
}
public void run() {
while (true)
System.out.println(message);
}
}
7a questão: Explique o que é um applet. Quais são as possibilidades a nível de programação de um applet, isto é, o
que você consegue fazer com um applet? Quais as restrições que se aplicam aos applets, ou seja, o que um applet
está normalmente impedido de fazer? Por que?
8a questão: exemplo retirado dos programas do livro Java Now.
// BankAccount - a general bank account class
public class BankAccount
{
// algumas declarações
--// balance - the current account's balance
private double m_dBalance;
// implementação de alguns métodos
--// Withdrawal - make a withdrawal
public void Withdrawal(double dAmount)
throws InsufficientFundsException
{
// if there's insufficient funds on hand...
if (m_dBalance < dAmount)
{
// ...throw an exception
throw new InsufficientFundsException(this, dAmount);
}
// otherwise, post the debit
m_dBalance -= dAmount;
}
} // end class BankAccount
public class InsufficientFundsException extends Exception
{
private BankAccount m_ba; // account with problem
private double m_dWithdrawalAmount;
InsufficientFundsException(BankAccount ba, double dAmount)
{
super("Insufficient funds in account ");
m_ba = ba;
m_dWithdrawalAmount = dAmount;
}
public String toString()
{
StringBuffer sb = new StringBuffer();
sb.append("Insufficient funds in account ");
sb.append(m_ba.Id());
sb.append("\nBalance was ");
sb.append(m_ba.Balance());
sb.append("\nWithdrawal was ");
sb.append(m_dWithdrawalAmount);
return sb.toString();
}
}
Boa Sorte !
Prof. Oscar Luiz Monteiro de Farias