View source for Programação com Objectos/Teste de 2011/01/10

{{TOCright}}
== Parte 1 (resposta múltipla) ==

[[Image:UML-teste-po-20100121.png|frame|right| Figura 1]]
'''1.1.''' Considere o diagrama UML da figura 1 (à direita). Qual das seguintes afirmações está correcta?
:#doThat pode ser invocado através de referências para I
:#doThat não está definido para B
:#doIt pode ser invocado através de referências para C
:#A implementa I
:#A é uma classe derivada de C

'''1.2.''' Que padrão de desenho permite especificar numa classe o esqueleto de um algoritmo, deixando para as subclasses a concretização dos seus passos?
:#Strategy
:#Bridge
:#Template Method
:#Visitor
:#State

'''1.3.''' Em Java, qual das seguintes frases está correcta?
:#todas as classes são derivadas de java.lang.Class
:#uma classe interna não pode ser anónima
:#uma classe anónima pode implementar uma interface
:#java.lang.Object contém os métodos que permitem definir a ordem por omissão entre quaisquer objectos
:#uma classe abstracta pode ser instanciada se definir construtores

'''1.4.''' Em Java, um construtor...
:#não pode chamar outros construtores
:#não pode chamar funções static
:#chama sempre o construtor da superclasse
:#não pode ser privado
:#não pode declarar variáveis locais

'''1.5.''' Em Java, as classes internas...
:#não podem ser serializáveis (i.e., não podem implementar java.io.Serializable)
:#não podem conter métodos que lancem excepções
:#podem ser instanciadas dentro de qualquer bloco de uma função
:#constituem um mecanismo para uso exclusivo do tratamento de excepções
:#não podem ter métodos públicos

'''1.6.''' Em Java, o método equals...
:#não está disponível nas classes da package java.util
:#é utilizado para definir ordem entre as instâncias de uma classe
:#está disponível apenas para classes que implementem  java.io.Serializable
:#permite comparar apenas objectos com outros da mesma classe
:#permite comparar dois objectos de qualquer tipo

'''1.7.''' Em Java, a interface java.lang.Comparable ...
:#é implementada pela classe java.lang.Object
:#as instâncias das suas implementações podem ser utilizadas como chaves pela classe java.util.TreeMap
:#uma classe não deve implementá-la se quiser que as suas instâncias sejam serializáveis
:#só é relevante para classes que implementem java.util.List
:#as respostas anteriores estão erradas

'''1.8.''' Relativamente aos padrões de desenho State e Strategy...
:#ambos especificam a delegação de acções em objectos usados pelo cliente
:#as estratégias têm de ser fixadas na altura da criação do cliente, mas os estados não
:#são idênticos, mas as classes que implementam as estratégias são em número fixo
:#gerem as dependências de objectos das suas implementações
:#tratam da mesma forma objectos individuais e suas agregações

'''1.9.''' O padrão de desenho Decorator...
:#permite adicionar funcionalidade a um objecto sem alterar a sua interface
:#não pode ser aplicado em conjunto com padrão Visitor
:#permite ajustar a interface e o comportamento de um objecto
:#permite aplicar uma operação a uma estrutura de objectos
:#permite estabelecer o esqueleto de um algoritmo

'''1.10.''' O padrão de desenho Abstract Factory...
:#representa a construção de uma colecção
:#gerir as dependências de outros objectos relativamente ao estado de um objecto
:#permite abstrair a criação de famílias de objectos para uma aplicação
:#permite tratar famílias de objectos e seus grupos indiscriminadamente
:#permite que o comportamento de um objecto mude quando o seu estado muda

== Parte 2 ==

'''2.1.''' (1.5 val.) Na linguagem Smalltalk, o método '''subclassResponsibility''' pode ser invocado por uma superclasse para indicar que a implementação de um determinado método é da responsabilidade de uma subclasse. Desse modo, se for usada uma subclasse que não implemente o método, o programa chama a versão da superclasse e recebe uma notificação da falta durante a execução. Qual é o mecanismo discutido acima e como é disponibilizado na linguagem Java? Diga quais são as suas vantagens relativas.

'''2.2.''' (1.5 val.) O mecanismo de herança potencia o desenvolvimento incremental e a reutilização de funcionalidade existente. No entanto, apesar destes aspectos positivos, apresenta algumas limitações. Descreva algumas das limitações do mecanismo de herança (pode particularizar para Java) e em que medida a utilização de arquitecturas como as previstas em alguns padrões de desenho as minimizam.

'''2.3.''' (1.5 val.) Descreva o padrão de desenho ''State'' e as vantagens da sua utilização. Explique em que medida o mecanismo de polimorfismo de inclusão é importante para a definição e funcionamento da arquitectura prevista pelo padrão. Dê um exemplo de utilização do padrão.

'''2.4.''' (1.5 val.) O padrão de desenho ''Visitor'' permite abstrair a aplicação de uma operação a uma estrutura de objectos. Diga qual é o princípio de funcionamento do padrão e que vantagens apresenta a sua utilização. Quais são os problemas introduzidos pela utilização do padrão? Dê um exemplo de aplicação.

'''2.5.''' Considere o seguinte programa em Java:
<java5>
public abstract class Shell {
  protected Ghost _ghost;
  protected Shell(Ghost ghost) { 
    _ghost = ghost;
    System.out.println(getClass().getName());
  }
  public abstract boolean isOperational();
  public abstract void powerOn();
}

public class Virtual extends Shell {
  public Virtual(Ghost ghost) { super(ghost); }
  public boolean isOperational() { return _ghost.isHappy(); }
  public void powerOn() { System.out.println("always on: nothing to do"); }
}

public class Physical extends Shell {
  private boolean _poweredOn = false;
  public Physical(Ghost ghost) { super(ghost); powerOn(); }
  public boolean isOperational() { return _poweredOn && _ghost.isHappy(); }
  public void powerOn() { _poweredOn = true; }
}

public class NotReadyException extends Exception {}

public class ShellTester {
  public void assertOperational(Shell shell) throws NotReadyException {
    if (!shell.isOperational()) {
      throw new NotReadyException();
    }
  }
}

public class Ghost {
  String _name;
  public Ghost(String name) { _name = name; }
  public boolean isHappy() { return true; /* ghosts are happy */ }
}

public class Application {
  public static void main(String args[]) {
    Shell kusanagi = new Virtual(new Ghost("草薙素子"));
    Shell batou = new Physical(new Ghost("バトー"));
    ShellTester tester = new ShellTester();
    try { tester.assertOperational(kusanagi); }
    catch (NotReadyException e) { System.out.println("Kusanagi not ready!"); }
    try { tester.assertOperational(batou); }
    catch (NotReadyException e) { System.out.println("Batou not ready!"); }
  }
}
</java5>

'''2.5.1.''' (1.0 val.) Que resultado se obtém quando se executa o seguinte programa? (represente mudanças de linha com \n)

'''2.5.2.''' (0.5 val.) Que padrão de desenho é usado no programa?

'''2.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; não é necessário explicitar o construtor de '''Shell''').

'''2.6.''' Considere o seguinte domínio:

Uma biblioteca possui livros, CDs, vídeos e jogos. Todas estas obras são identificadas por um número de série, uma data de aquisição e uma descrição de catálogo. Os livros, CDs e vídeos têm ainda a indicação de qual é o título e de quem é o autor. Os vídeos e os jogos têm indicação de qual é a idade mínima para empréstimo. A biblioteca mantém sobre os seus visitantes um registo, no qual inclui (sobre cada um) o nome, a data de nascimento, morada e número de telefone. Quando é realizado um novo registo, o novo utilizador fica sem acesso às obras com idade controlada se a idade for menor que um valor dado (à medida que o tempo passa e o utilizador envelhece, o acesso vai também evoluindo). São definidos três níveis de acesso: infantil (>0), juvenil (>12) e adulto (>18). No caso de utilizadores não adultos, a biblioteca associa ao menor um utilizador adulto, que é responsável pelas obras emprestadas (mantém um registo dedicado às obras emprestadas ao menor). A biblioteca guarda um registo dos empréstimos realizados (obra emprestada, utilizador e datas de empréstimo e limite para entrega). É possível pedir várias obras num único empréstimo e é possível contabilizar, tanto por utilizador, como na totalidade dos utilizadores, o número de obras emprestadas. Se uma obra não estiver disponível, é possível deixar um contacto para notificação em caso de devolução.

'''2.6.1.''' (2.0 val.) Desenhe o diagrama de classes UML correspondente ao domínio apresentado. Represente as classes (seus nomes, métodos e atributos). Indique também as relações de herança, associação e agregação.

'''2.6.2.''' (4.0 val.) Implemente em Java todas as classes, bem como os seus atributos e métodos, do domínio apresentado. Considere que deve haver flexibilidade na definição do tipo de cliente, na forma de transitar entre tipos de cliente, e no registo de empréstimos.

== Chave da Parte 1 ==

[[Image:UML-teste-po-20100121.png|frame|right| Figura 1]]
'''1.1.''' Considere o diagrama UML da figura 1 (à direita). Qual das seguintes afirmações está correcta?
:#<s>doThat pode ser invocado através de referências para I</s>
:#<s>doThat não está definido para B</s>
:#doIt pode ser invocado através de referências para C
:#<s>A implementa I</s>
:#<s>A é uma classe derivada de C</s>

'''1.2.''' Que padrão de desenho permite especificar numa classe o esqueleto de um algoritmo, deixando para as subclasses a concretização dos seus passos?
:#<s>Strategy</s>
:#<s>Bridge</s>
:#Template Method
:#<s>Visitor</s>
:#<s>State</s>

'''1.3.''' Em Java, qual das seguintes frases está correcta?
:#<s>todas as classes são derivadas de java.lang.Class</s>
:#<s>uma classe interna não pode ser anónima</s>
:#uma classe anónima pode implementar uma interface
:#<s>java.lang.Object contém os métodos que permitem definir a ordem por omissão entre quaisquer objectos</s>
:#<s>uma classe abstracta pode ser instanciada se definir construtores</s>

'''1.4.''' Em Java, um construtor...
:#<s>não pode chamar outros construtores</s>
:#<s>não pode chamar funções static</s>
:#chama sempre o construtor da superclasse
:#<s>não pode ser privado</s>
:#<s>não pode declarar variáveis locais</s>

'''1.5.''' Em Java, as classes internas...
:#<s>não podem ser serializáveis (i.e., não podem implementar java.io.Serializable)</s>
:#<s>não podem conter métodos que lancem excepções</s>
:#podem ser instanciadas dentro de qualquer bloco de uma função
:#<s>constituem um mecanismo para uso exclusivo do tratamento de excepções</s>
:#<s>não podem ter métodos públicos</s>

'''1.6.''' Em Java, o método equals...
:#<s>não está disponível nas classes da package java.util</s>
:#<s>é utilizado para definir ordem entre as instâncias de uma classe</s>
:#<s>está disponível apenas para classes que implementem  java.io.Serializable</s>
:#<s>permite comparar apenas objectos com outros da mesma classe</s>
:#permite comparar dois objectos de qualquer tipo

'''1.7.''' Em Java, a interface java.lang.Comparable ...
:#<s>é implementada pela classe java.lang.Object</s>
:#as instâncias das suas implementações podem ser utilizadas como chaves pela classe java.util.TreeMap
:#<s>uma classe não deve implementá-la se quiser que as suas instâncias sejam serializáveis</s>
:#<s>só é relevante para classes que implementem java.util.List</s>
:#<s>as respostas anteriores estão erradas</s>

'''1.8.''' Relativamente aos padrões de desenho State e Strategy...
:#ambos especificam a delegação de acções em objectos usados pelo cliente
:#<s>as estratégias têm de ser fixadas na altura da criação do cliente, mas os estados não</s>
:#<s>são idênticos, mas as classes que implementam as estratégias são em número fixo</s>
:#<s>gerem as dependências de objectos das suas implementações</s>
:#<s>tratam da mesma forma objectos individuais e suas agregações</s>

'''1.9.''' O padrão de desenho Decorator...
:#permite adicionar funcionalidade a um objecto sem alterar a sua interface
:#<s>não pode ser aplicado em conjunto com padrão Visitor</s>
:#<s>permite ajustar a interface e o comportamento de um objecto</s>
:#<s>permite aplicar uma operação a uma estrutura de objectos</s>
:#<s>permite estabelecer o esqueleto de um algoritmo</s>

'''1.10.''' O padrão de desenho Abstract Factory...
:#<s>representa a construção de uma colecção</s>
:#<s>gerir as dependências de outros objectos relativamente ao estado de um objecto</s>
:#permite abstrair a criação de famílias de objectos para uma aplicação
:#<s>permite tratar famílias de objectos e seus grupos indiscriminadamente</s>
:#<s>permite que o comportamento de um objecto mude quando o seu estado muda</s>

== Resolução da Parte 2 ==

===2.1. Classes Paramétricas e Polimorfismo  ===

Aspectos importantes:
* Definição de uma classe estruturalmente independente do(s) tipo(s) manipulado(s) (os seus parâmetros).
* O polimorfismo implicado pelas relações de herança (inclusão) permite o uso de uma instância de uma subclasse onde se espera uma de uma superclasse. O polimorfismo paramétrico permite a definição de classes concretas que manipulam qualquer tipo (potencialmente com restrições), evitando a definição de relações de herança (dependência) relativamente a um tipo determinado (introduz restrições desnecessárias). Note-se que uma classe paramétrica pode participar em relações de herança/implementação e ser usada polimorficamente (inclusão) como qualquer outra (e.g., List<A> e ArrayList<A>). No entanto, casos como  ArrayList<Animal> e ArrayList<Gato> não estão relacionadas polimorficamente.

===2.2. Visitor & Strategy  ===

Aspectos importantes:
* Descrição da estrutura e funcionamento do Visitor
* Vantagens e inconvenientes
* Exemplos: geração de código num compilador a partir de uma árvore sintáctica; desenho de uma cena a partir de uma descrição abstracta; cálculo de impostos sobre uma estrutura composta. Em geral, situações em que uma operação a realizar sobre uma estrutura de objectos e suas folhas possa ser generalizada.
* Visitor vs. Strategy: embora ambos os padrões permitam encapsular algoritmos a realizar sobre estruturas "clientes", tanto a estrutura como o modo de funcionamento são diferentes. No Strategy, apesar de ser possível definir múltiplas versões de um algoritmo, não é possível especializar a operação dependendo do tipo específico do objecto.

===2.3. Abstract Factory ===

Aspectos importantes:
* Descrição da estrutura e funcionamento do Abstract Factory
* Abstract Factory utiliza polimorfismo para permitir o intercâmbio de fábricas sem ser necessário alterar a aplicação cliente
* Exemplo: escola com professores, salas, alunos, etc.: a estrutura da escola é sempre a mesma, mas a parametrização definida pela fábrica altera o funcionamento (por produzir intervenientes diferentes)

===2.4. Composite ===

Aspectos importantes:
* Estrutura: uma superclasse define o conceito abstracto a manipular. As subclasses, tanto atómicas, como as composições de componentes, são tratadas indistintamente e apresentam a mesma interface. O processamento de uma composição faz-se pelo processamento iterativo dos seus elementos.
* Exemplo: Rebanhos e Ovelhas (relativamente, por exemplo, à operação tosquiar).

===2.5.1. Saída do programa===
 A\nC\nB\nA\nC\n

===2.5.2. Identificação do padrão de desenho utilizado===

O padrão utilizado é o State (Ghost).

===2.6. Diagrama de classes (UML) ===

Esboço do diagrama de classes para o problema apresentado.

[[Image:PO-20100121-class.png]]

===2.7. Diagrama de sequência (UML)===

Note-se que alguns objectos não indicam variáveis associadas (os resultados da criação desses objectos são imediatamente passados como argumentos de outros métodos).

[[Image:PO-20100121-seq.png]]

===2.8. Exercício de programação (Apoio Humanitário) ===

Usa-se o padrão Visitor como forma de abstrair o cálculo da ajuda prestada.

Definem-se quatro conceitos: o beneficiário abstracto (HelpTarget), e cada um dos concretos (Person, Village, Region).

<java5>
/**
 * Basic help target.
 */
public abstract class HelpTarget {
        /**
         * No actual value is returned in this case.
         *
         * @param calculator the visitor used to evaluate assistance.
         * @return help received by this target.
         */
        public double accept(Calculator calculator) { throw new UnsupportedOperationException(); }
}
</java5>

<java5>
/**
 * Individual.
 * We omitted the initialisation code.
 */
public class Person extends HelpTarget {
        /**
         * @see HelpTarget#accept(Calculator)
         */
        @Override
        public double accept(Calculator calculator) { return calculator.evalPerson(this); }
}

</java5>

<java5>
import java.util.ArrayList;

/**
 * A village has villagers (persons).
 * We omitted the initialisation code.
 */
public class Village extends HelpTarget {
        /**
         * The villagers in this village.
         */
        private ArrayList<Person> _villagers = new ArrayList<Person>();

        /**
         * Simple constructor for initialising the village with some villagers.
         */
        public Village() {
                int count = (int) (Math.random() * 100);
                for (int i = 0; i < count; i++) _villagers.add(new Person());
        }

        /**
         * @return size of village (number of villagers).
         */
        public int size() { return _villagers.size(); }

        /**
         * @param index
         * @return a villager
         */
        public Person getVillager(int index) { return _villagers.get(index); }

        /**
         * @see HelpTarget#accept(Calculator)
         */
        @Override
        public double accept(Calculator calculator) { return calculator.evalVillage(this); }
}
</java5>

<java5>
import java.util.ArrayList;

/**
 * A region has villages.
 * We omitted the initialisation code.
 */
public class Region extends HelpTarget {
        /**
         * The villages in this region.
         */
        private ArrayList<Village> _villages = new ArrayList<Village>();

        /**
         * Simple constructor for initialising the region with some villages.
         */
        public Region() {
                int count = (int) (Math.random() * 100);
                for (int i = 0; i < count; i++) _villages.add(new Village());
        }

        /**
         * @return size of region (number of villages).
         */
        public int size() {return _villages.size(); }

        /**
         * @param index
         * @return a village
         */
        public Village getVillage(int index) { return _villages.get(index); }

        /**
         * @see HelpTarget#accept(Calculator)
         */
        @Override
        public double accept(Calculator calculator) { return calculator.evalRegion(this); }
}
</java5>

A classe Calculator define a interface de cálculo para cada conceito.
<java5>
/**
 * The Calculator visitor interface.
 */
public abstract class Calculator {
        /**
         * @param person
         * @return help received by this person.
         */
        public abstract double evalPerson(Person person);

        /**
         * @param village
         * @return help received by this village.
         */
        public abstract double evalVillage(Village village);

        /**
         * @param region
         * @return help received by this region.
         */
        public abstract double evalRegion(Region region);
}
</java5>

O processo de cálculo simples é definido pela classe Standard.

<java5>
/**
 * "Standard" help calculator.
 */
public class Standard extends Calculator {

        /**
         * @see Calculator#evalVillage(Village)
         */
        @Override
        public double evalVillage(Village village) {
                double tax = 0;
                for (int index = 0; index < village.size(); index++)
                        tax += village.getVillager(index).accept(this);
                return tax;
        }

        /**
         * @see Calculator#evalPerson(Person)
         */
        @Override
        public double evalPerson(Person person) {
                return 1;
        }

        /**
         * @see Calculator#evalRegion(Region)
         */
        @Override
        public double evalRegion(Region region) {
                double tax = 0;
                for (int index = 0; index < region.size(); index++)
                        tax += region.getVillage(index).accept(this);
                return tax;
        }

}
</java5>

O processo de cálculo para emergências é definido pela classe Emergency.

<java5>
/**
 * The emergency help system.
 */
public class Emergency extends Calculator {

        /**
         * High-water marker for region occupation.
         */
        private final int REGION_MAX = 20;

        /**
         * High-water marker for population.
         */
        private final int VILLAGE_MAX = 100;

        /**
         * @see Calculator#evalVillage(Village)
         */
        @Override
        public double evalVillage(Village village) {
                double help = 0;
                for (int index = 0; index < village.size(); index++)
                        help += village.getVillager(index).accept(this);
                if (village.size() > VILLAGE_MAX) help *= .75;
                return help;
        }
 
        /**
         * @see Calculator#evalPerson(Person)
         */
        @Override
        public double evalPerson(Person person) { return 1; }
 
        /**
         * @see Calculator#evalRegion(Region)
         */
        @Override
        public double evalRegion(Region region) {
                double help = 0;
                for (int index = 0; index < region.size(); index++)
                        help += region.getVillage(index).accept(this);
                if (region.size() > REGION_MAX) help *= .9;
                return help;
        }

}
</java5>

Simple aoolication.

<java5>
public class App {
        /**
         * @param args
         */
        public static void main(String[] args) {
                HelpTarget v1 = new Village();
                HelpTarget r1 = new Region();
                HelpTarget p1 = new Person();
 
                Calculator sh = new Standard();
                Calculator eh = new Emergency();
 
                System.out.println("Village help (standard): " + v1.accept(sh));
                System.out.println("Region taxes (standard): " + r1.accept(sh));
                System.out.println("Person taxes (standard): " + p1.accept(sh));
                System.out.println("Village taxes (emergency): " + v1.accept(eh));
                System.out.println("Region taxes (emergency): " + r1.accept(eh));
                System.out.println("Person taxes (emergency): " + p1.accept(eh));
        }
}
</java5>

[[category:PO]]
[[category:Ensino]]