Programação com Objectos/Teste de 2012/11/19: Difference between revisions

From Wiki**3

< Programação com Objectos
← Older edit
Root (talk | contribs)
PRIVATE, Bureaucrats, Administrators
15,130 edits
Root (talk | contribs)
PRIVATE, Bureaucrats, Administrators
15,130 edits
 
(3 intermediate revisions by the same user not shown)
Line 5: Line 5:
'''1.1.''' (3.0 val.) [[Introdução à Modelação com UML/Empresa de Mobiliário|Empresa de Mobiliário]]
'''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.
'''1.2.''' (1.0 val.) [[Polimorfismo, Interfaces, Classes Abstractas/Exercício 06: Tabuleiros e Peças|Tabuleiros e Peças]]
 
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.  
'''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; ">
* [[Polimorfismo, Interfaces, Classes Abstractas]]
* 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?  
'''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; ">
* [[Polimorfismo, Interfaces, Classes Abstractas]]
* 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)  ==
== Parte 2 (resposta múltipla)  ==

Latest revision as of 13:24, 18 November 2013

Parte 1

1.1. (3.0 val.) Empresa de Mobiliário

1.2. (1.0 val.) Tabuleiros e Peças

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.

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?

Parte 2 (resposta múltipla)

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?

  1. a implementação de doThis tem de estar necessariamente em C
  2. doThis não está definido para B
  3. doIt pode ser directamente invocado através de referências para I
  4. I fornece a implementação para métodos declarados por A
  5. nenhuma das anteriores está correcta

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

  1. Uma classe pode estender uma única classe
  2. Uma classe pode estender várias classes
  3. Uma classe só pode implementar uma única interface
  4. Uma classe não pode simultaneamente estender uma classe e implementar uma interface
  5. Uma classe não pode simultaneamente estender uma classe e implementar mais do que uma interface

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

  1. só pode ser acedido dentro da própria classe ou por classes derivadas
  2. não pode ser redefinido
  3. não pode chamar outros métodos que também não sejam protected
  4. pode ser acedido por classes da mesma package
  5. só pode ser usado por construtores

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?

  1. List<Integer> myList = new ArrayList<Integer>();
  2. List<Integer> myList = new List<Integer>();
  3. List<Object> myList = new ArrayList<Integer>();
  4. ArrayList<Integer> myList = new List<Integer>();
  5. Todas estão correctas

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>

  1. sempre done finally
  2. sempre finally
  3. sempre done
  4. ou finally ou done finally
  5. ou done ou finally ou done finally
Retrieved from "https://web.tecnico.ulisboa.pt/~david.matos/w/pt/index.php?title=Programação_com_Objectos/Teste_de_2012/11/19&oldid=4998"