|
|
| (4 intermediate revisions by the same user not shown) |
| Line 1: |
Line 1: |
| {{TOCright}}
| | #REDIRECT [[ist:Programação com Objectos/Teste de 2012/11/19]] |
| | |
| == 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]]
| |