View source for Programação com Objectos/Teste de 2012/11/19

{{TOCright}} 

== Parte 1  ==

'''1.1.''' (3.0 val.) [[Introdução à Modelação com UML/Empresa de Mobiliário|Empresa de Mobiliário]]

'''1.2.''' (1.0 val.) Implemente, em Java, as classes '''Tabuleiro''' e '''Peça'''. A classe '''Tabuleiro''' guarda um número variável de peças e tem o método '''desenhaPeças()''' que é responsável por desenhar todas as peças guardadas. A classe '''Peça''' tem dois atributos inteiros que representam as suas coordenadas no tabuleiro, um atributo que representa a côr da peça (cadeia de caracteres) e dois métodos: o método '''move()''' e o método '''devolveCor()'''. Existem dois tipos de peças: '''Cabo''' e '''Sargento'''. Cada tipo de peça move-se de forma distinta: as peças do tipo '''Cabo''' avançam uma unidade em cada uma das coordenadas enquanto que as peças do tipo '''Sargento''' avançam 3 unidades em cada uma das coordenadas. Para simplificar o seu trabalho considere que o tabuleiro não tem limites.

Se necessário pode implementar outras classes e/ou métodos.

<div style="padding: 8px; border-style: dashed; border-width: 1px; border-color: #2f6fab; background: #f9f9f9; ">
A solução contém cinco classes (4 são as descritas no enunciado e a 5ª é a que contém o método '''main''', '''App'''). Os métodos descritos no enunciado estão assinalados como "required method" e os atributos com "required attributes". Note-se que a solução é mínima e que algumas opções não são ideias em casos gerais (o uso de '''ArrayList''' na classe '''Tabuleiro''', por exemplo).
</div>

Ficheiro '''Tabuleiro.java''': 
<java5>
import java.util.List;
import java.util.ArrayList;

public class Tabuleiro {
  // could be more sophisticated
  private List<Peça> _board = new ArrayList<Peça>();

  public void add(Peça piece) {
    _board.add(piece);
  }

  /**
   * Note: required method
   */
  public void desenhaPeças() {
    for (Peça p: _board)
      System.out.println(p);
  }

  /**
   * Moves all pieces.
   */
  public void shake() {
    for (Peça p: _board)
      p.move();
  }

}
</java5>

Ficheiros '''Peça.java''', '''Cabo.java''' e '''Sargento.java''':
<java5>
public abstract class Peça {
  private int _x;        // Note: required attribute
  private int _y;        // Note: required attribute
  private String _color; // Note: required attribute
  private int _xstep;
  private int _ystep;

  public Peça(int x, int y, String color, int xstep, int ystep) {
    _x = x;
    _y = y;
    _color = color;
    _xstep = xstep;
    _ystep = ystep;
  }

  public Peça(int x, int y, String color, int xystep) {
    this(x, y, color, xystep, xystep);
  }

  public Peça(int x, int y, String color) {
    this(x, y, color, 1);
  }

  public String toString() {
    return "Peça at (" + _x + ", " + _y + ") is " + _color + " (" + getClass().getName() + ")";
  }

  /**
   * Note: required method
   * @return color
   */
  public String devolveCor() { return _color; }

  /**
   * Note: required method
   */
  public void move() {
    _x += _xstep;
    _y += _ystep;
  }

}
</java5>

Ficheiros '''Cabo.java''':
<java5>
public class Cabo extends Peça {
  public Cabo(int x, int y, String color) {
    super(x, y, color);
  }
}
</java5>

Ficheiros '''Sargento.java''':
<java5>
public class Sargento extends Peça {
  public Sargento(int x, int y, String color) {
    super(x, y, color, 3);
  }
}
</java5>

Ficheiro '''App.java''':
<java5>
public class App {
  public static void main(String[] args) {
    Tabuleiro t = new Tabuleiro();
    t.add(new Cabo(1, 1, "azul"));
    t.add(new Cabo(2, 5, "azul"));
    t.add(new Sargento(4, 1, "amarelo"));
    System.out.println("Initial:");
    t.desenhaPeças();
    t.shake();
    System.out.println("After shaking:");
    t.desenhaPeças();
  }
}
</java5>

'''1.3.''' (1.5 val.) Diga em que consistem e como se expressam os conceitos de sobrecarregamento (overloading) e redefinição (overriding) de métodos nas linguagens de programação com objectos. Dê exemplos práticos, se possível, relacionados com o projecto. 

<div style="padding: 8px; border-style: dashed; border-width: 1px; border-color: #2f6fab; background: #f9f9f9; ">
* Overloading: definição de métodos com o mesmo nome, mas com diferenças nos argumentos (tipo, número ou ambos) na mesma ou em classes relacionadas;
* Overriding: redefinição de um método definido anteriormente por uma das superclasses da hierarquia de uma classe.
* Overloading: '''Gato(int age) {...}''' e '''Gato(String name) {...}'''
* Overriding: redefinição por parte de '''Gato.respirar()''' de '''Animal.respirar()''' (sendo '''Gato''' uma subclasse de '''Animal''')
</div>

'''1.4.''' (1.5 val.) Explique em consiste o mecanismo de abstracção presente em linguagens como o Java e o C++. Qual é a sua relação com o polimorfismo. Que consequências têm estes dois aspectos na produção de código? 

<div style="padding: 8px; border-style: dashed; border-width: 1px; border-color: #2f6fab; background: #f9f9f9; ">
* Abstracção: possibilidade de desenvolver código ou conceitos "abstractos" (tanto classes ou interfaces que devem ser especializadas, como código/implementações baseadas nelas)
* Polimorfismo: possibilidade de referenciar um objecto através de um tipo genérico ou de um tipo mais abstracto que o seu (numa hierarquia de classes, por exemplo)
* Consequências: possibilidade de utilizar tipos concretos (ou mais específicos) em código escrito para tipos menos específicos; redução e reutilização de código; desenvolvimento incremental.
</div>

== Parte 2 (resposta múltipla)  ==
[[Image:UML-teste-po-20121119.png|frame|right|Figura 1 (todos os métodos estão implementados)]] '''2.1.''' Considere o diagrama UML da figura 1 (à direita). Qual das seguintes afirmações está correcta? 

:#<s>a implementação de '''doThis''' tem de estar necessariamente em '''C'''</s> 
:#<s>'''doThis''' não está definido para '''B'''</s> 
:#<s>'''doIt''' pode ser directamente invocado através de referências para '''I'''</s> 
:#<s>'''I''' fornece a implementação para métodos declarados por '''A'''</s> 
:#nenhuma das anteriores está correcta

'''2.2.''' Em Java, qual das seguintes frases está correcta? 

:#Uma classe pode estender uma única classe
:#<s>Uma classe pode estender várias classes</s>
:#<s>Uma classe só pode implementar uma única interface</s>
:#<s>Uma classe não pode simultaneamente estender uma classe e implementar uma interface</s>
:#<s>Uma classe não pode simultaneamente estender uma classe e implementar mais do que uma interface</s>

'''2.3.''' Em Java, um método declarado '''protected'''...

:#<s>só pode ser acedido dentro da própria classe ou por classes derivadas</s>
:#<s>não pode ser redefinido</s>
:#<s>não pode chamar outros métodos que também não sejam '''protected'''</s>
:#pode ser acedido por classes da mesma package
:#<s>só pode ser usado por construtores</s>

'''2.4.''' Supondo que está a fazer os imports correctos, qual das seguintes instruções não gera nem avisos nem erros de compilação?

:#'''List<Integer> myList = new ArrayList<Integer>();'''
:#<s>'''List<Integer> myList = new List<Integer>();'''</s>
:#<s>'''List<Object>  myList = new ArrayList<Integer>();'''</s>
:#<s>'''ArrayList<Integer> myList = new List<Integer>();'''</s>
:#<s>Todas estão correctas</s>

'''2.5.''' Quais são as possíveis saídas do seguinte programa em Java:

<java5>
public static void main(String[] args) { 
  try {         
    if (args.length == 0) throw new Exception();         
  } 
  catch (Exception e) { 
    System.out.print("done ");  
  } 
  finally {
    System.out.println("finally ");
  } 
}
</java5>

:#<s>sempre '''done finally '''</s>
:#<s>sempre '''finally '''</s>
:#<s>sempre '''done '''</s>
:#ou '''finally ''' ou '''done finally '''
:#<s>ou '''done ''' ou '''finally ''' ou '''done finally '''</s>

[[Category:PO]]
[[Category:Ensino]]