|
|
| 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; ">
| |
| * Separação entre interface e implementação
| |
| * Isolamento de responsabilidades e de consequências
| |
| * Esconder a implementação de módulos e os seus dados (objectos)
| |
| * Java: palavras chave de controlo de acesso
| |
| * Java: explicitação do conceito de interface e de classe abstracta
| |
| </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; ">
| |
| * Cliente e objectos do estado
| |
| * Delegação de funcionalidade no objecto de estado actual
| |
| * Comutação entre objectos de estado opaca para o cliente
| |
| * Simplicidade de estruturação do esquema de transições
| |
| * Explicitação da máquina de estados
| |
| * Remoção de código de verificação de condições no cliente
| |
| </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; ">
| |
| * Superclasse (possivelmente, mas não necessariamente) abstracta define algoritmo
| |
| * Superclasse especifica passos do algoritmo (métodos, possivelmente abstractos, mas não necessariamente)
| |
| * Subclasses definem os métodos que correspondem aos passos do algoritmo
| |
| * Inversão de controlo: controlo a partir da superclasse (princípio de Hollywood - "don't call us, we'll call you")
| |
| * No processo de herança, as subclasses chamam o código da superclasses e, de um modo geral, pelo mecanismo de redefinição detêm o controlo da execução e da definição dos métodos
| |
| </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; ">
| |
| * Cliente é definido em termos de conceitos gerais, tando relativamente à fábrica, como aos tipos (concretos) de objectos construídos
| |
| * A fábrica relaciona implicitamente os tipos de objectos contruídos num todo coerente (têm sentido no mesmo contexto)
| |
| * Cliente é "inicializado" com fábrica concreta
| |
| * Cliente usa interface relativa à criação de objectos "gerais", mas a fábrica produz os "concretos"
| |
| * Exemplo: escola com salas, professores, alunos, disciplinas, com variação de matérias ensinadas
| |
| </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.) [[Introdução à Modelação com UML/Galinha com fome|Galinha com fome]]
| |
| | |
| '''1.6.''' (6.0 val.) [[Introdução à Modelação com UML/Transportadora de animais|Transportadora de animais]]
| |
| | |
| == Parte 2 (resposta múltipla) ==
| |
| [[Image:UML-teste-po-20120130.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>'''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>apenas identidade, estado e comportamento</s>
| |
| :#<s>apenas estado e comportamento</s>
| |
| :#<s>apenas comportamento</s>
| |
| :#existência
| |
| :#<s>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]]
| |