|
|
| (9 intermediate revisions by the same user not shown) |
| Line 1: |
Line 1: |
| {{TOCright}}
| | #REDIRECT [[ist:Programação com Objectos/Teste de 2012/01/30]] |
| | |
| == Parte 1 ==
| |
| | |
| '''1.1.''' (1.5 val.) Discuta a importância do encapsulamento e relacione-o com os conceitos de interface e implementação. Em que medida contribuem aqueles conceitos para a qualidade da programação. Como estão disponíveis em Java?
| |
| | |
| <div style="padding: 8px; border-style: dashed; border-width: 1px; border-color: #2f6fab; background: #f9f9f9; ">
| |
| (resposta)
| |
| </div>
| |
| | |
| '''1.2.''' (1.5 val.) O padrão ''State'' permite simplificar a programação de máquinas de estados. Explique pormenorizadamente como é realizada a função do padrão pelos seus intervenientes. Quais são as vantagens de utilização do padrão?
| |
| | |
| <div style="padding: 8px; border-style: dashed; border-width: 1px; border-color: #2f6fab; background: #f9f9f9; ">
| |
| (resposta)
| |
| </div>
| |
| | |
| '''1.3.''' (1.5 val.) O padrão de desenho ''Template Method'' permite definir métodos cujas etapas podem não estar definidas (no sentido de não estarem implementadas). Como funciona o padrão? Que significa dizer-se que há inversão de controlo no funcionamento do padrão? Contraste com o processo habitual de redefinição de métodos na presença de herança.
| |
| | |
| <div style="padding: 8px; border-style: dashed; border-width: 1px; border-color: #2f6fab; background: #f9f9f9; ">
| |
| (resposta)
| |
| </div>
| |
| | |
| '''1.4.''' (1.5 val.) O padrão de desenho ''Abstract Factory'' permite abstrair a criação de objectos pertencentes a uma família de conceitos. Explique como estão organizados os conceitos envolvidos no padrão e como é a interacção com o código cliente. Dê um exemplo de aplicação.
| |
| | |
| <div style="padding: 8px; border-style: dashed; border-width: 1px; border-color: #2f6fab; background: #f9f9f9; ">
| |
| (resposta)
| |
| </div>
| |
| | |
| '''1.5.''' Considere o seguinte programa em Java: <java5>
| |
| public class Chicken {
| |
| private Stomach _stomach = new Hungry();
| |
| public void eat() { _stomach.eat(); }
| |
| public void sleep() { _stomach.sleep(); }
| |
| public void setMood(Stomach stomach) { _stomach = stomach; }
| |
| }
| |
| | |
| public abstract class Stomach {
| |
| protected Stomach() { System.out.println("Hmmm..."); }
| |
| public void eat() { System.out.println("..."); }
| |
| public void sleep() { System.out.println("..."); }
| |
| }
| |
| | |
| public class Hungry extends Stomach {
| |
| public Hungry() { System.out.println("I'm hungry!!"); }
| |
| public void eat() { System.out.println("Eating..."); }
| |
| public void sleep() { System.out.println("I'm too hungry to sleep!!"); }
| |
| }
| |
| | |
| public class Sated extends Stomach {
| |
| public Sated() { System.out.println("I'm sleepy!!"); }
| |
| public void eat() { System.out.println("I'm not hungry..."); }
| |
| public void sleep() { System.out.println("ZzZz..."); }
| |
| }
| |
| | |
| public class Farm {
| |
| public static void main(String args[]) {
| |
| Chicken chicken = new Chicken();
| |
| chicken.eat();
| |
| chicken.setMood(new Sated());
| |
| chicken.sleep();
| |
| chicken.setMood(new Hungry());
| |
| chicken.sleep();
| |
| }
| |
| }
| |
| </java5>
| |
| | |
| '''1.5.1.''' (1.0 val.) Que resultado se obtém quando se executa o seguinte programa? (represente mudanças de linha com '''\n''')
| |
| | |
| Hmmm...\nI'm hungry!!\nEating...\nHmmm...\nI'm sleepy!!\nZzZz...\nHmmm...\nI'm hungry!!\nI'm too hungry to sleep!!
| |
| | |
| '''1.5.2.''' (0.5 val.) Que padrão de desenho é usado no programa?
| |
| | |
| ''Strategy''
| |
| | |
| '''1.5.3.''' (1.5 val.) Desenhe o diagrama de sequência UML correspondente à execução do programa, incluindo as etapas de criação dos objectos. O diagrama de sequência deve conter os nomes das mensagens trocadas (não é necessário representar os argumentos dessas mensagens nem as de retorno; represente todas as chamadas ao método '''println''').
| |
| | |
| <div style="padding: 8px; border-style: dashed; border-width: 1px; border-color: #2f6fab; background: #f9f9f9; ">
| |
| Note-se que alguns objectos (anotados) não definem as variáveis associadas no momento indicado.
| |
| | |
| [[Image:PO-20120130-seq.png]] | |
| </div>
| |
| | |
| '''1.6.''' Considere o seguinte domínio:
| |
| | |
| Uma transportadora tem vários camiões e comboios capazes de transportar vários tipos de animais (inicialmente, ovelhas, vacas e cavalos, embora seja de prever que venham a ser considerados outros). Os camiões e comboios têm identificadores únicos e uma dada capacidade de transporte, determinada pelo peso máximo que pode transportar. Desta forma, é possível acrescentar um animal a transportar a um dado camião ou comboio se a capacidade de transporte não tiver sido ultrapassada. Dado um meio de transporte, é possível saber a capacidade de transporte ainda disponível.
| |
| | |
| Os animais têm um identificador único, registo do peso, sabem andar e comer, e têm o registo de quem é o seu dono. Cada tipo de animal tem capacidades adicionais distintas: os cavalos sabem correr, as ovelhas pastar e as vacas mugir. Os donos são identificados pelo nome. Por vezes, os donos transportam lotes de animais, todos no mesmo meio de transporte. Os lotes têm um identificador único e apresentam as mesmas capacidades que os animais individuais.
| |
| | |
| Um comboio é constituído por carruagens e cada carruagem tem uma capacidade máxima de transporte. A capacidade máxima de transporte de um comboio é igual à soma das capacidades das suas carruagens. É possível adicionar carruagens a um comboio. Quando se adiciona uma dada carga a transportar a um comboio, o comboio utiliza a primeira carruagem com capacidade disponível para transportar essa carga.
| |
| | |
| Considere que os comboios podem transportar qualquer tipo de animal. No entanto, e por enquanto, os camiões apenas podem transportar vacas ou cavalos, podendo no futuro aceitar novos tipos de animais. Apresente uma solução que garanta a flexibilidade sem impacto no código existente.
| |
| | |
| '''1.6.1.''' (2.0 val.) Desenhe o diagrama de classes UML correspondente ao domínio apresentado. Represente todas as classes (seus nomes, métodos e atributos). Indique também as relações de herança, associação e agregação.
| |
| | |
| <div style="padding: 8px; border-style: dashed; border-width: 1px; border-color: #2f6fab; background: #f9f9f9; ">
| |
| Esboço do diagrama de classes para o problema apresentado.
| |
| | |
| [[Image:PO-20120130-class.png|900px|PO-20120130-class.png]]
| |
| </div>
| |
| | |
| '''1.6.2.''' (4.0 val.) Implemente em Java as classes do domínio apresentado (ver nota abaixo), bem como os seus atributos e métodos (excepto ''getters'' e ''setters''). Os atributos identificados devem ser suficientes para suportar a funcionalidade e os métodos devem conter implementações que permitam verificar inequivocamente que a funcionalidade desejada está presente e que realiza as operações especificadas.
| |
| | |
| '''Nota:''' não é necessário implementar as classes que representam os seguintes conceitos: camião, cavalo, vaca.
| |
| | |
| <java5>
| |
| | |
| </java5>
| |
| | |
| == Parte 2 (resposta múltipla) ==
| |
| [[Image:UML-teste-po-20120130.png|frame|right|UML-teste-po-20120107.png]] '''2.1.''' Considere o diagrama UML da figura 1 (à direita). Qual das seguintes afirmações está correcta?
| |
| | |
| :#<s>'''doIt''' pode ser directamente invocado através de referências para '''I'''</s>
| |
| :#<s>'''doThat''' não está definido para '''B'''</s>
| |
| :#<s>'''B''' implementa a interface '''I''' (através de '''C''')</s>
| |
| :#'''C''' implementa a interface '''I'''
| |
| :#<s>'''A''' implementa a interface '''I'''</s>
| |
| | |
| '''2.2.''' Que padrão de desenho permite criar famílias de objectos relacionados, de modo que os seus elementos possam ser usados de modo alternativo?
| |
| | |
| :#<s>Strategy</s>
| |
| :#<s>Builder</s>
| |
| :#<s>Visitor</s>
| |
| :#<s>Template Method</s>
| |
| :#Abstract Factory
| |
| | |
| '''2.3.''' O padrão de desenho ''Composite'' tem por objectivo...
| |
| | |
| :#<s>criar objectos complexos a partir de pequenos objectos diferentes</s>
| |
| :#<s>adicionar funcionalidade a um objecto adaptando a sua interface</s>
| |
| :#<s>que o comportamento de um objecto mude quando o seu estado muda</s>
| |
| :#que os clientes tratem os objectos individuais e composições de objectos de forma uniforme
| |
| :#<s>estabelecer o esqueleto de um algoritmo</s>
| |
| | |
| '''2.4.''' Qual é o padrão de desenho que tem o objectivo de converter a interface de uma classe numa outra interface (esperada pelos clientes) e permitir que classes possam colaborar, apesar das incompatibilidades das suas interfaces?
| |
| | |
| :#<s>Builder</s>
| |
| :#<s>Visitor</s>
| |
| :#<s>Observer</s>
| |
| :#<s>Abstract Factory</s>
| |
| :#Adapter
| |
| | |
| '''2.5.''' Quando se pretende que todos os clientes de uma classe usem sempre a mesma instância dessa classe, qual é a melhor opção?
| |
| | |
| :#<s>definir a classe como '''final'''</s>
| |
| :#<s>definir a classe como '''static'''</s>
| |
| :#<s>aplicar o padrão de desenho ''Proxy''</s>
| |
| :#aplicar o padrão de desenho ''Singleton''
| |
| :#<s>utilizar uma variável global, definida através da palavra reservada '''global'''</s>
| |
| | |
| '''2.6.''' Qual das seguintes frases está correcta, relativamente a uma instância (designada por inst) de uma classe interna não '''static'''?
| |
| | |
| :#<s>não pode aceder aos atributos '''static''' da classe envolvente</s>
| |
| :#<s>só pode invocar métodos não-'''static''' da classe envolvente</s>
| |
| :#<s>não pode ter métodos que lancem excepções (iriam corromper o objecto da classe envolvente)</s>
| |
| :#pode aceder a qualquer atributo (privado ou não) do objecto da classe envolvente
| |
| :#<s>todas frases anteriores são falsas</s>
| |
| | |
| '''2.7.''' Quais são as características que todos os objectos possuem?
| |
| | |
| :#<s>(a) apenas identidade, estado e comportamento</s>
| |
| :#<s>(b) apenas estado e comportamento</s>
| |
| :#<s>(c) apenas comportamento</s>
| |
| :#existência
| |
| :#<s>(e) dimensão e peso</s>
| |
| | |
| '''2.8.''' Em Java, o fragmento de código '''catch(Exception e) { /* … */ }'''
| |
| | |
| :#<s>apanha todos os objectos que forem atirados por um '''throw''' anterior</s>
| |
| :#<s>é inútil desde que exista um qualquer '''catch''' anterior</s>
| |
| :#o seu bloco pode lançar, ele próprio, uma excepção
| |
| :#<s>volta a apanhar todos os objectos, mesmo os que já tenham sido apanhados por um '''catch''' anterior</s>
| |
| :#<s>não apanha nunca nenhum objecto</s>
| |
| | |
| '''2.9.''' Em Java, o método '''main''' é especial porque...
| |
| | |
| :#<s>é o único método que pode criar objectos</s>
| |
| :#o interpretador começa sempre a execução da aplicação invocando o método '''main''' de uma determinada classe
| |
| :#<s>todas as classes têm de ter um método '''main'''</s>
| |
| :#<s>é o único método '''static''' que uma classe pode ter</s>
| |
| :#<s>só uma classe da aplicação pode ter o método '''main'''</s>
| |
| | |
| '''2.10.''' Em Java, quando um método atribui um valor a um atributo de um objecto passado como seu argumento, esse objecto...
| |
| | |
| :#<s>não é alterado, porque o método recebe uma cópia do objecto</s>
| |
| :#<s>não é alterado, porque essa operação nunca é permitida</s>
| |
| :#é alterado imediatamente
| |
| :#<s>é alterado, mas a alteração só é visível quando o método termina</s>
| |
| :#<s>é alterado, mas só se o método não for private</s>
| |
| | |
| [[Category:PO]]
| |
| [[Category:Ensino]]
| |