Figuras. Introdução

Transcrição

1 Figuras Introdução O objectivo deste guião é explorar a polimorfia. Há vários mecanismos para se obter polimorfia, entre os quais se incluem a herança, a implementação das interfaces Java, e os tipos genéricos. Neste guião, vamos abordar os dois primeiros, com quatro tarefas A-D. A polimorfia dá aos objectos a capacidade de serem de vários tipos ao mesmo tempo. Graças a essa capacidade, podemos fornecer aos métodos um objecto de um tipo diferente daquele que é declarado na lista de parâmetros do método. Desde que o objecto de tipo diferente respeite certas regras, o compilador não gera erros e o programa que resulta da compilação funciona correctamente. Isto permite que partes de um programa sejam extensíveis. Assim, podemos acrescentar ao programa novas funcionalidades sem termos de alterar um único carácter que seja do seu texto fonte, ou de recompilar as classes já existentes. Vamos construir um programa que manipula objectos que representam figuras geométricas, tais como pontos, círculos, segmentos de recta e rectângulos. Mas mais do que isso, vamos estruturar o programa de modo que a maior parte deste não dependa das classes que representam as figuras. Dessa maneira, poderemos incluir no programa novas classes, representando novas figuras, ou remover algumas das classes já existentes. Assim demonstraremos que o programa é extensível para novas figuras, e cada figura concreta é desacoplável do sistema. 1. Neste exercício, vai desenvolver de raiz algumas classes e completar outras, disponíveis na área moodle para este guião. Recomenda-se que utilize o mesmo workspace que no guião anterior. É importante ser metódico na escolha das directorias e nas convenções de nomes, porque senão depois é uma confusão. Mais vale fazer tudo certo desde o início. 2. Crie no Eclipse um novo projecto denominado Figures_1. Não se esqueça de seleccionar em baixo a opção Create separate source and output folders. Garanta que está a trabalhar com a versão adequada das bibliotecas do Java. Nos menus em Window / Preferences / Java / Installed JREs a versão seleccionada deve ser uma do tipo jre1.5, jre1.6, jdk1.5 ou jdk1.6 e em Window / Preferences / Java / Compiler / Compiler compliance level deve ter pelo menos o nível 5.0. O nível de compatibilidade do compilador nunca deve ser superior à versão instalada das bibliotecas (ex: nível 5.0 com a jre1.4) ou então teremos problemas de compilação. 3. Classes disponíveis no moodle para apoio ao guião. Na área do moodle respeitante a este guião, encontra um ficheiro zip contendo um conjunto de classes. As classes incluídas no zip são as seguintes: Figure; Point e PointUnitTests; Segment e SegmentUnitTests; Rectangle e RectangleUnitTests; Circle e CircleUnitTests. Algumas das operações implementadas nestas classes, tais como rotate, translate e scale, não serão importantes neste guião. POO, Guião 2 1

2 4. Montar novas classes no projecto. Extraia para o pacote poo os ficheiros *.java contidos nesse zip. Para as classes aparecerem no Package Explorer, carregue em F5 (Refresh) e lá estarão elas. 5. O Package Explorer do Eclipse deve exibir o projecto Figures_1, além do Parabola_1, do primeiro guião. Se o projecto Parabola_1 ainda se encontra aberto, feche-o. Só se justifica manter abertos os projectos que estamos a usar. Se as classes PointUnitTests e CircleUnitTests tiverem um cartão vermelho, é porque falta a biblioteca do JUnit. Seleccione o projecto Figures_1, clique no botão do lado direito do rato e no menu que aparece seleccione a opção Java Build Path / Libraries / Add External jars e depois seleccione o ficheiro junit.jar da versão 4, que se encontra numa subdirectoria da directoria plugins do eclipse. Este último aparecerá no Package Explorer e os cartões vermelhos deverão desaparecer. 6. A primeira forma de polimorfia abordada neste guião é a que obtemos com a herança de classes. Em Java, fazemos uma classe herdar de outra através da palavra reservada extends. Lembre-se da seguinte regra importante, que se aplica tanto a classes abstractas como interfaces Java. As classes abstractas e as interfaces podem ser usadas em todos os pontos do texto fonte (source code) de um programa Java, excepto nas instruções com new, i.e., nos pontos onde se criam objectos. 7. Classes abstractas. Vamos usar a classe Figure, que é uma classe abstracta que representa figuras em geral. Embora a classe Figure declare várias operações, só duas vão verdadeiramente nos interessar: tostring e draw. 8. Sobreposição de métodos. Repare que Figure não declara tostring. Não precisa, pois tostring já é declarado em java.lang.object. Tanto as classes como as interfaces Java são tipos, e em Java, todos os tipos herdam directa ou indirectamente de java.lang.object. Isto significa que em Java, todos os objectos já possuem uma implementação de tostring. Porém, há que desenvolver uma nova implementação de tostring em cada classe de figura para configurar o seu comportamento. Ou seja, a nova implementação vai sobrepor-se (override) à implementação herdada de java.lang.object. 9. Métodos abstractos. Não é possível a classe Figure definir uma implementação para a operação draw, pois como deve calcular, não é possível arranjar instruções que sirvam tanto para desenhar círculos como rectângulos. Por esse motivo, a operação draw da classe Figure é abstracta, ou seja, o método que a implementa é declarado mas não definido, i.e. a classe Figure declara a assinaturas ou cabeçalho do método (declaração) mas não lhe define um corpo concreto contendo instruções que podem ser executadas (definição). Claro, uma classe concreta não pode ter métodos abstractos. Pretende-se construir um programa que manipula vários tipos de figuras concretas. Porém, queremos também que a maior parte desse programa apenas menciona a classe abstracta Figure. A excepção será uma parte restrita do programa que essa sim, será necessariamente dependente de classes concretas. Todas as outras classes que representam figuras concretas devem ser desacopláveis do programa. Dito de outra maneira, deverá ser possível retirar qualquer das classes concretas e recompilar o programa sem erros (excepto na tal parte restrita, que terá de ser ajustada todas as vezes). Para que isso seja possível, as classes que representam figuras têm de herdar (ser subclasses) de Figure. 10. Figuras concretas. As subclasses concretas de Figure são as seguintes. Point representa pontos no plano. Segment representa segmentos de recta. Rectangle POO, Guião 2 2

3 representara rectângulos e Circle representa círculos. Atenção, que a classe Point não é a classe que usou no guião Paremos por um instante para pensar: pontos e círculos são figuras. Logo, todas as operações que podemos fazer com qualquer tipo de figura, devemos poder fazer com pontos e círculos. Um exemplo é a operação para desenhar a figura (draw). A herança de classes é inteiramente coerente com este raciocínio. Esta relação entre Figure e as restantes classes será representada em declarações do tipo class Point extends Figure. A palavra extends significa que a classe Point herda todas as operações (métodos) da classe Figure. O mesmo se aplicaria aos membros de dados (campos), se a classe Figure tivesse membros de dados, mas não tem. O mesmo pode ser dito em relação a todas as classes que herdem de Figure. 12. Informação não essencial. A seguinte informação não deverá ser necessária para seguir o guião, mas adiantamo-la mesmo assim. Point e as restantes classes são classes que aproveitam classes já disponíveis nas APIs do Java para representar figuras e que lhes acrescentam mais funcionalidade. Uma das funcionalidades adicionais é o suporte ao conceito de referencial (i.e., o centro dos eixos x e y). Algumas operações adicionais só fazem sentido na presença desse referencial. Por exemplo, a operação rotate não é uma rotação sobre a própria figura. Em Point, rotate desloca o ponto ao longo de uma circunferência imaginária tendo como centro o centro dos eixos. 13. Através do menu em File / New / Class, crie no pacote poo a classe Main, já incluindo o método main dentro dela (seleccione a check-box correspondente ao criar a classe). Recorde que o Mooshak está à espera de uma classe Main, e vai correr o método main dessa classe. Tarefa A Polimorfia com tostring 14. Implementar os métodos tostring. Vamos começar a fazer qualquer coisa. Implemente os métodos tostring das classes Point, Segment, Rectangle e Circle. A string devolvida por estes métodos deverá ser a seguinte: a) para Point: Point[41.7, 38.3] (sem as aspas). Os valores 41.7 e 38.3 são as coordenadas x e y do ponto. Naturalmente, a string exacta devolvida por tostring dependerá dos argumentos que tenham sido passados ao construtor de Point. b) para Segment: (sem as aspas). Os 4 valores correspondem às coordenadas x1, y1, x2 e y2 dos pontos (x, y) que especificam os dois extremos do segmento de recta. Esses valores são igualmente passados ao construtor da classe. c) para Rectangle: Rectangle[(15.0, 20.0) W65.0 H50.0] (sem as aspas). Os 4 valores passados ao construtor de Rectangle correspondem às coordenadas (x, y) do canto inferior esquerdo, a largura (width) e a altura (height), respectivamente. Atenção ao W e H maiúsculos que deve surgir pegados, sem espaços, aos dois últimos valores. d) para Circle: Circle[(40.0, 40.0) R30.0] (sem as aspas). Os 3 valores são as coordenadas do centro, e o raio (radius). Atenção ao R maiúsculo que deve surgir pegado ao valor do raio Todos os valores acima mencionados devem ser do tipo double. O formato deve ter sempre uma casa decimal. Para escrever nas strings controlando o formato, sugere-se o uso das classes java.lang.stringbuilder e java.util.formatter. POO, Guião 2 3

4 15. Criação das figuras concretas. Crie um método estático task_a. Pode criá-lo na classe Main, ou se preferir numa classe FigureTester. Faça o método main da classe Main chamar esse método, e apenas esse. Crie o seguinte método (em Main ou FigureTester): public static void printfigure(figure figure) { System.out.println(figure); Reparou que este método apenas depende do tipo Figure? Mas graças à polimorfia, podemos passar-lhe como argumento qualquer instância de subclasses de Figure, como comprovará a seguir. O método tostring será chamado durante a execução de println, também graças à polimorfia. Viva a polimorfia! 16. Em task_a, crie um objecto de cada figura e chame printfigure para cada um deles, passando-o como argumento. Deve fazê-lo pela seguinte ordem: Point, Segment, Rectangle e Circle. Os valores com que deve inicializar as figuras são os seguintes: a) Point: o ponto (40.0, 40.0). b) Segment: entre os extremos (10.0, 20.0) e (70.0, 70.0). c) Rectangle: canto inferior esquerdo (15.0, 20.0), largura 65.0 e altura d) Circle: centro (40.0, 40.0) e raio A saída na consola deverá ser a seguinte: Rectangle[(15.0, 20.0) W65.0 H50.0] Circle[(40.0, 40.0) R30.0] O seu programa está pronto para ser submetido para a tarefa A. Compacte a directoria poo, com todas as classes que lá se encontram, e submeta. Tarefa B Menu de comandos 17. Menu de comandos. Generalizemos a tarefa anterior num método mais geral, task_b. Será um método cego que contém um ciclo. Em cada iteração do ciclo pede um comando que pode ser p, s, r ou c, seguidos dos valores que definem determinada figura (valores entre 0.0 e 80.0). Se for p, pede a seguir as coordenadas x e y de um ponto. Se for s, pede a seguir 4 valores correspondendo aos dois extremos de um segmento. Se for r, pede a seguir 4 valores correspondendo ao canto inferior esquerdo, largura e altura de um rectângulo (sempre o x antes do y). Se for c, pede a seguir o centro de um círculo, seguido do seu raio. Se o comando não for uma daquelas letras, não tem efeito, isto é, o programa não faz nada. De cada vez, imprime a figura criada, usando printfigure como antes. Termina com Ctrl-Z. 18. Como exemplo, considere as seguintes entradas de teste: r c c s p s POO, Guião 2 4

5 19. Neste caso, a saída correspondente é a seguinte: Rectangle[(14.7, 13.6) W70.0 H32.0] Circle[(17.0, 39.5) R41.0] Circle[(40.0, 40.0) R27.8] Segment[(10.0, 10.0)-(70.0, 72.0)] Point[45.0, 49.0] Segment[(8.0, 7.0)-(27.9, 56.5)] Tarefa C Polimorfia com draw, Fábricas de Objectos e Objecto Nulo 20. Finalmente, janelas! A próxima tarefa é montar um sistema que nos permita visualizar numa janela as diversas figuras. Para esse efeito construirá, daqui a pouco, dois métodos de teste: testfiguresgraphical e task_c. Ambos devem ser incluídos no seu programa para submissão da tarefa C. Podem ser colocados no ficheiro Main ou num ficheiro FiguresTester. 21. A API swing. Para a visualização das figuras, vamos usar algumas classes da biblioteca Swing. A API swing constitui a principal biblioteca do Java para manipular componentes gráficos. Exemplos de componentes gráficos são os botões (JButton), as etiquetas (JLabel) numa janela, campos e áreas de texto (JTextField, JTextArea). Mas estes não serão usados aqui e não tem de aprender a usar o swing para estas tarefas. Como a programação gráfica não é o foco deste guião, vamos dar-lhe a papinha toda feita. 22. Pretendemos que a parte de visualização de figuras também seja independente de qualquer subclasse de Figure. Começamos por criar uma classe FigurePanel que vai conter a área da janela onde se desenha uma figura. Crie no pacote poo uma classe FigurePanel e acrescente-lhe o seguinte código. import java.awt.*; import javax.swing.*; public class FigurePanel extends JPanel { private static final long serialversionuid = 1L; private Figure _figure; private int _width; private int _height; public FigurePanel(int width, int height, Figure fig) { _width = width; _height = height; _figure = fig; setborder(borderfactory.createlineborder(color.red)); public Dimension getpreferredsize() { return new Dimension(_width, _height); public void paintcomponent(graphics g) { _figure.draw(g); Se é perspicaz, reparou que FigurePanel herda de JPanel. JPanel é uma das classes da API swing, usada para controlar subáreas de uma janela. Vamos usar algumas POO, Guião 2 5

6 funcionalidades do swing para montar o esquema necessário para a visualização das figuras. Se não entender tudo o que se encontra neste código, não se preocupe. Neste guião, não se pressupõe que você domina os detalhes da programação gráfica e todas relacionadas são fornecidas no guião. Porém, não perderia nada em ler o capítulo 5 do livro recomendado para acompanhamento da disciplina (Horstmann, Java Concepts, 4ª edição). Esse capítulo dá uma excelente introdução à programação com gráficos. O tópico do swing é desenvolvido nos capítulos 12 e Apenas para entender melhor a classe acima, damos a seguinte informação. A classe FigurePanel representa apenas uma parte da área de uma janela. A área total da janela será preenchida por vários destes componentes gráficos. A janela propriamente dita será representada por uma instância de outra classe, que já se indicará. Em princípio, nunca terá de chamar os métodos getpreferredsize e paintcomponent, isso será feito pelos objectos swing. O método getpreferredsize destina-se a indicar qual a área da janela que se pretende que este componente gráfico ocupe (Dimension é outra classe do swing). O método paintcomponent será chamado pelos objectos swing cada vez que seja necessário voltar a desenhar a figura na janela. Para mais informações, consulte o javadoc da classe JPanel. Decerto terá reparado que Figure é a única classe relacionada com figuras que é usada. Nunca deverá ser necessário mencionar outra. 24. Com FigurePanel temos uma maneira de conter uma figura. Agora precisamos de uma outra classe para representar a janela propriamente dita, que conterá múltiplas figuras. No swing, uma classe habitualmente usada para este efeito é javax.swing.jframe. Um procedimento habitual é criar uma classe que herda de JFrame e onde acrescentamos todo o estado e comportamento adicionais da janela. Neste caso, o que o objecto janela deve fazer é aceitar um número variável de figuras. Para esse efeito, acrescentaremos um método add que recebe como parâmetro mais uma figura. 25. Crie uma nova classe Window4Figures que herda de JFrame. Não se esqueça de importar javax.swing.jframe, bem como java.awt.color, java.awt.gridlayout, javax.swing.jpanel e javax.swing.border.lineborder. 26. Acrescente a Window4Figures os seguintes membros: private static final long serialversionuid = 1L; public static final int PANEL_SIZE_X = 80; public static final int PANEL_SIZE_Y = 80; private JPanel _figurecontainerpanel; public Window4Figures(String title) { super(title); _figurecontainerpanel = new JPanel(); _figurecontainerpanel.setlayout(new GridLayout(2,3)); _figurecontainerpanel.setborder(new LineBorder(Color.BLACK)); _figurecontainerpanel.setbackground(color.yellow); add(_figurecontainerpanel); public void activate() { setdefaultcloseoperation(jframe.exit_on_close); setvisible(true); public void add(figure figure) { POO, Guião 2 6

7 FigurePanel figurepanel = new FigurePanel(PANEL_SIZE_X, PANEL_SIZE_Y, figure); _figurecontainerpanel.add(figurepanel); pack(); 27. Cada vez que usamos um objecto JFrame, há uma série de acções que habitualmente se executam, algumas das quais a janela não aparece se não forem executadas. Dão origem a código chapa zero (boiler plate code). Nessa categoria incluem-se as instruções no construtor de Window4Figures, e no seu método activate. Note que as instruções do método activate podiam ser também colocadas no fim do construtor. Apenas foram colocadas fora do construtor para dar mais controlo ao programador cliente da classe. Para fazer funcionar estas classes, deve: 1. criar um objecto que representa a janela, instanciando a classe Window4Figures; 2. para cada figura que pretenda adicionar à janela, criar o objecto da figura e acrescentá-lo à janela usando o método add; 3. Após ter acrescentado todas as figuras, chamar o método activate da janela. 28. Título da janela. Na figura abaixo, o título da janela é Figures. No seu trabalho, o título a fornecer à janela deve incluir o seu nome e número, tal como deve constar no relatório. 29. A menos que faça alguma coisa para o evitar, o método main terminará a sua execução logo após estas acções, enquanto que a janela se mantém activa. Isto é normal na programação com gráficos. Relembramos que as classes que construiu foram concebidas para dimensões e/ou posições dentro dos limites Claro, nada o impede de examinar o código e efectuar calibrações a seu gosto. Ao criar as figuras, use os seguintes valores (do tipo double): 1. Point: o ponto (40, 40). 2. Segment: extremo 1: (10, 20); extremo 2: (70, 70). 3. Rectangle: canto inferior esquerdo: (15, 20); largura: 50; altura: Circle: centro: (40, 40); raio: Acrescente à classe Main um método estático testfiguresgraphical com o qual poderemos efectuar um primeiro teste a estas classes e corra-o. Deverá ver a seguinte janela. Gostou? Bom, se acha que está pires, lançamos-lhe o seguinte desafio, extra guião: adapte as classes, por exemplo para obter cores diferentes. POO, Guião 2 7

8 31. Embora as classes Window4Figures e FigurePanel sejam independentes de qualquer figura concreta, essa independência não é possível de conseguir em todas as partes de um programa. É assim porque temos de especificar o nome exacto da classe que queremos instanciar nos pontos em que se criam os objectos (usando new). Ao mencionarmos o nome de uma classe, estamos a tornar essa parte do código dependente dessa classe, e lá se vai a independência! Este problema devese a uma limitação na maneira como os construtores funcionam nestas linguagens. Ao contrário dos métodos, os construtores não podem ser polimórficos. Por exemplo, não é possível fazer o construtor de uma classe devolver a instância de uma subclasse. Uma técnica frequentemente usada para contornar este problema é isolar, numa classe ou método, as partes de um programa que criam instâncias das classes das quais queremos que o programa se mantenha independente. Para melhor explorar as possibilidades da polimorfia, vamos agora usar essa técnica. 32. Fábricas de figuras. Uma das possíveis maneiras de encarar uma classe é como uma fábrica de objectos e o propósito de próxima classe a criar é emular esse comportamento. Com uma diferença: usando um método, temos a possibilidade de emular um construtor polimórfico. Vai criar uma classe FigureFactory com o seguinte método: public Figure createfigure() Claro, o objecto devolvido por createfigure nunca poderá ser uma instância exacta de Figure, pois Figure é uma classe abstracta e não é possível instanciar classes abstractas. Em vez disso, o método devolverá uma instância de uma das subclasses concretas de Figure, cada vez que é chamado. Isso já é permitido porque uma instância duma subclasse de Figure também é um objecto Figure. 33. Geração de números pseudo-aleatórios. Para tornar a coisa mais interessante, createfigure deverá escolher aleatoriamente a subclasse concreta que é instanciada, cada vez que createfigure é chamado. Pode esse efeito vai usar a classe java.util.random, para a geração de números pseudo-aleatórios. O prefixo pseudo significa que as sequências de números geradas por Random possuem algumas das características das sequências aleatórias, mas não todas. Uma característica que lhe falta é uma genuína imprevisibilidade. Para cada valor long diferente que passemos ao construtor de Random (chamado semente), a sequência de valores que um objecto Random gera é predeterminada e pode ser reproduzida. O seu programa deve ler o valor long da semente, criar um objecto FigureFactory passando a semente no construtor. Por sua vez, FigureFactory terá um membro Random, criado com essa semente. Cada número gerado pelo objecto Random determinará qual será a próxima figura concreta a criar. Para este efeito use o método nextint(int) de Random (consulte o javadoc de Random). O resultado deverá ser uma janela semelhante à mostrada acima, mas com um número variável de figuras, escolhidas ao acaso (i.e., determinadas pela semente). 34. Mapeamento entre números aleatórios e figuras. Em createfigure, a correspondência entre os números gerados por nextint e as figuras concretas deve ser sempre a seguinte: 0 Point; 1 Rectangle 2 Segment; e 3 Circle. O método createfigure deve usar nextint de maneira a que só sejam gerados estes valores inteiros. Vai usar uma estrutura de controlo switch ou uma cadeia de if s para mapear os números acima às classes correspondentes, não é? Para a eventualidade de haver um engano no uso de nextint e este método devolver um POO, Guião 2 8

9 valor fora da gama prevista, prepare o método createfigure para que este devolva null para qualquer outro valor devolvido por nextint. 35. Irá criar um método task_c, estático e cego, que lê um long para a semente e a seguir um int para o número de figuras a gerar. Depois, deve usar a fábrica de figuras para gerar tantas figuras, quantas as especificadas. Para cada figura especificada, imprime a figura na consola, da mesma maneira que anteriormente. Para não complicar, inicialize as figuras com os mesmos valores que em Como decerto já reparou, há um potencial problema implementação de FigureFactory, que se sente se houver um defeito (bug) na geração dos números pseudo-aleatórios. Já sabemos o que vai acontecer se createfigure ocasionalmente devolver null s: assim que for feita a primeira chamada a um método de uma referência nula, é atirada uma excepção NullPointerException e o programa aborta. Ou seja, o expediente de devolver null em caso de defeito interno é uma primeira aproximação, mas é uma solução tosca e que redunda em programas pouco robustos. Claro, podemos sempre testar se a referência é null em todos os casos em que há esse risco. Porém, isto é muito pouco elegante e atafulha o código de ifs, tornando-o mais confuso e complexo de entender. Horrível! Felizmente, este caso dá-nos a oportunidade de explorar uma técnica que também assenta na polimorfia: a técnica do Null Object. 37. Objecto nulo. O Null Object consiste em criar uma classe que expõe a mesma interface que as classes genuínas, mas não faz dada. A classe nula pode ser usada em lugar das genuínas, mas os seus objectos permanecem constantes e nada neles alguma vez muda. As suas operações são sempre fictícias (dummy): todos os métodos void são vazios e os não void devolvem sempre o mesmo valor. O valor a devolver depende dos casos, mas deve ser do tipo elemento neutro. Por exemplo, métodos que deveriam devolver um inteiro geralmente devolvem 0 ou 1. Neste caso concreto, o comportamento adequado para o método clone do objecto nulo será devolver uma referência de si próprio. O método tostring deverá devolver Null Figure ; poderia devolver simplesmente null, mas dessa maneira seria mais difícil detectar a presença de um objecto nulo. 38. Testar o uso do objecto nulo. Crie uma classe NullFigure que pode ser usada em lugar das restantes classes sobre figuras e adapte FigureFactory de modo a que createfigure devolva uma instância de NullFigure se a geração de números aleatórios não estiver bem programada. Para observarmos o funcionamento de NullFigure, vamos introduzir propositadamente um defeito no uso do gerador de números aleatórios, de modo a que este ocasionalmente também gere o número 4. Perante esse número, createfigure deverá gerar figuras nulas. 39. Para esta tarefa, deve submeter o seu programa a executar o método task_c e com este a usar a fábrica de figuras com o defeito artificial descrito. Como exemplo, task_c poderá receber as seguintes entradas de teste: Neste caso, a saída correspondente deverá ser a seguinte: Circle[(40.0, 40.0) R30.0] Null Figure Rectangle[(15.0, 20.0) W50.0 H30.0] Rectangle[(15.0, 20.0) W50.0 H30.0] Null Figure POO, Guião 2 9

10 Rectangle[(15.0, 20.0) W50.0 H30.0] Null Figure Circle[(40.0, 40.0) R30.0] Circle[(40.0, 40.0) R30.0] 41. Quando o seu programa corresponder ao exemplo acima descrito, deverá estar pronto para ser submetido para a tarefa C. Não se esqueça de incluir também o método testfiguresgraphical. Tarefa D Interfaces Java 42. Quando devemos usar uma interface? A estrutura montada até agora é viável e serve, mas permanece uma questão. A classe abstracta Figure não possui qualquer membro concreto. São tudo declarações, sem qualquer definição. Usualmente, chamamos a classes classes abstractas puras. Nesse caso, coloca-se a pergunta: por que não usar uma interface Java em lugar duma classe? Em linguagens que não possuem interfaces, como o C++, justifica-se usar classes abstractas puras, como Figure. Mas numa linguagem como o Java, só se justifica usar classes abstractas se estas tiverem algum membro concreto, ou se prevê que venham a ter. Quando não se prevê que venha a haver membros concretos, o procedimento correcto é usar uma interface Java. 43. Criar o projecto Figures_2. O que vai desenvolver a seguir é uma nova versão do programa que já desenvolveu até agora, tendo o comportamento dos métodos task_c e testfiguresgraphical como referência, mas sem o defeito incluído propositadamente. Chame-lhes task_d e testfiguresgraphical Quando correr o programa com (apenas) o método task_d, se este receber as seguintes entradas de teste: Nesse caso, a saída correspondente deverá ser a seguinte: Circle[(40.0, 40.0) R30.0] Rectangle[(15.0, 20.0) W50.0 H30.0] Rectangle[(15.0, 20.0) W50.0 H30.0] Circle[(40.0, 40.0) R30.0] Rectangle[(15.0, 20.0) W50.0 H30.0] Circle[(40.0, 40.0) R30.0] 46. Atenção, que as novas versões das classes vão ser parecidas com as anteriores, mas não serão exactamente iguais e não devem coexistir no mesmo pacote. Para POO, Guião 2 10

11 evitar confusões, vamos criar um novo projecto Figures_2 com a mesma estrutura que o anterior. Um ponto essencial é que também tem de ter um pacote poo. Isto é importante: em ambos os projectos, o nome do pacote deve ser o mesmo. 47. Doravante as instruções deste guião referem-se ao projecto Figures_2 a menos que algo seja dito em contrário. No novo pacote poo, crie um interface Java IFigure que inclui as mesmas declarações de operações que Figure. Repare que palavras reservadas public e abstract são redundantes numa interface Java. Podem lá estar, mas não são necessárias porque nas interfaces Java as declarações de métodos são sempre public e abstract. Inclua-as, se quiser; é consigo. Nesta fase, o pacote poo deverá apenas ter a interface IFigure. 48. Adaptação do programa anterior. Agora, irá progressivamente copiar e adaptar as classes de Figures_1 para Figures_2. Atenção: em circunstância alguma deve copiar a classe Figure para o novo projecto. Isso iria causar muita confusão nas adaptações que vai fazer. Se o fizer, depois não se queixe 49. Cada vez que copiar mais uma classe de Figures_1 para Figures_2, surgirá uma data de erros do compilador, mas não se assuste. É uma questão de efectuar as adaptações necessárias, seguindo o sugerido nos pontos seguintes. 50. Processo de adaptação. Copie a classe Point de Figures_1 para Figures_2. Pode, por exemplo, fazer isso no Package Explorer do eclipse, por meio de um copy-paste de Point. Após adaptar Point de modo a que não haja erros nessa classe, deverá repetir o mesmo procedimento para as restantes (antigas) subclasses de Figure, incluindo NullFigure. A seguir a cada classe de figura, copie e adapte a classe de testes unitários correspondente, se esta existir. Após as classes de figuras e respectivas classes de teste (sempre excluindo Figure), recomenda-se a seguinte ordem: FigureFactory, FigurePanel, Window4Figures e Main (e FiguresTester, se resolveu usá-lo). Quando chegar à Main (e FiguresTester), criará também os métodos task_d e testfiguresgraphical Comece por passar as classes das figuras para o novo pacote. Tenhamos Point como exemplo. Faça Point implementar a interface IFigure em lugar de herdar da classe Figure. Por defeito, Point passará a herdar de java.lang.object, a mãe de todas as classes. Quaisquer referências a Figure devem ser adaptadas para IFigure. Isto aplica-se a tudo, incluindo as classes com testes unitários, quando e se as houver. Quaisquer métodos das antigas subclasses de Figure que estejam anotados terão de ter as anotações removidas. Excepção é qualquer método que a classe continua a herdar, mas de Object, tais como clone e tostring. Caso existam, essas anotações podem ficar. 52. Ao longo deste processo de adaptação, sempre que não haja erros de compilador deve correr todos os testes unitários que porventura já existam no pacote. Para isso, no Package Explorer seleccione o pacote poo e, via menu de contexto que surge clicando no botão direito do rato, mande executar todos os testes unitários do pacote poo: Run As > JUnit Test. Se vir a barra verde, é sinal de que provavelmente não foram introduzidos erros durante o processo de adaptação. 53. Testes de regressão. Caso veja a barra vermelha (à partida, não é provável), consulte o diagnóstico do JUnit para ver o que falhou e proceda às devidas correcções. Esta é uma das principais utilidades dos testes unitários: alertar cedo para a eventual introdução de novos defeitos nos processos de manutenção do software. A isto chamamos uma regressão. Os testes de unidade são muito úteis também porque actuam como testes de regressão. Se postos a correr com POO, Guião 2 11

12 frequência, permitem expor e identificar os defeitos muito cedo, e quanto mais cedo os erros são expostos e identificados, mais fácil e menos penoso estes são de corrigir. Ao fim de os usar durante algum tempo, decerto notará que o mero facto dos testes estarem disponíveis torna as tarefas de adaptação e manutenção dum sistema menos arriscadas e causadoras de ansiedade. Por isso, não se esqueça de correr todos os testes em cada fase, como sugerido acima. 54. Execute a nova versão do programa. Deverá ter o mesmo comportamento que a versão anterior. Assim que esteja, o seu programa deverá estar apto para ser submetido para a tarefa D. 55. FIM Ou não Os nossos guiões são um bocado como os CDs de música de bandas de rock, que oferecem um disco extra com mais algumas músicas, ou os jogos de computador, que são reeditados na sua Gold Edition, contendo packs de expansão: por vezes, oferecemos um bónus para os alunos que consigam resolver o guião relativamente depressa! Aceite, então, o nosso desafio. Tente resolver esta tarefa extra (convém criar um projecto novo para a dita). A submissão correcta vale um ponto extra, na nota final deste guião. Tarefa E Campo de Tiro de Alcochete 57. O nosso pack de expansão é dedicado ao Campo de Tiro de Alcochete. Antes de prosseguir, note bem que a história que lhe vamos contar daqui até ao final deste guião é, obviamente, falsa 58. Como sabe, o novo Aeroporto Internacional de Lisboa vai ser construído em Alcochete. Aqui vai uma vista aérea do local. POO, Guião 2 12

13 59. Uma das características interessantes do terreno é que ele é bastante plano. Outra, menos interessante, é que ele era usado como um campo de tiro. Desses onde se largam bombas de diferentes calibres. Ora bem, quando uma bomba explode, fica uma enorme cratera. Como as bombas utilizadas no campo de tiro eram inteligentes, as crateras ficaram todas com uma forma perfeitamente circular. No entanto, acontecia com alguma frequência uma bomba cair dentro de uma cratera já existente. Dirão os mais cépticos que, na imagem de satélite acima reproduzida, não se notam as crateras. Claro que não! É um segredo bem guardado. Ou uma teoria de conspiração convenientemente inventada para este guião. 60. Um cuidadoso estudo financeiro sobre a construção do novo aeroporto concluiu que construir a pista passando por cima de uma dessas crateras seria caríssimo. Seria necessário encher a cratera com betão. É muito caro. Para mais, procurando bem, conseguem-se encontrar no terreno zonas onde dá perfeitamente para construir a pista de aterragem. 61. Felizmente, a superfície do campo de tiro já está bem estudada e existem mapas muito detalhados. Para este projecto, você vai usar um mapa de uma secção rectangular do campo de tiro, onde estão claramente assinaladas as crateras. Repare que, neste mapa, há crateras dentro de crateras e até há crateras que se intersectam. O mapa está dividido em quadrículas cujo lado é uma unidade de comprimento, e isso determina um referencial cuja origem está no canto inferior esquerdo do rectângulo (o canto mais a sudoeste), com o semi-eixo positivo dos x para a direita (isto é, para leste) e o semi-eixo positivo dos y para cima (isto é, para norte). O centro de cada cratera é um ponto de coordenadas inteiras neste referencial, mas pode haver crateras cujo centro esteja fora do mapa ou cujo centro esteja no mapa mas em que a circunferência da cratera esteja parcialmente (ou totalmente) fora do mapa. 62. A figura representa um mapa onde vemos duas crateras inteiras e parte de outras três. 63. O problema é descobrir as localizações que permitam construir as pistas de aterragem mais compridas que for possível, na direcção este-oeste e na direcção norte-sul. No exemplo, as pistas a encontrar seriam as representadas a amarelo. 64. A ideia é tão boa que, por todo o mundo, há planos para converter campos de tiro em aeroportos. Isto representa uma oportunidade de negócio excelente para um jovem programador. Portanto, inspirados no problema de Alcochete, vamos resolver este desafio para qualquer mapa com este tipo de características. 65. A sua tarefa é escrever um programa para calcular as coordenadas e o comprimento das pistas mais compridas, na horizontal e na vertical, que se POO, Guião 2 13

14 podem construir na superfície representada num mapa com as características indicadas. As pistas têm de estar fora das crateras e serão formadas por conjuntos de quadrículas justapostas na mesma direcção (horizontal ou vertical). Para efeitos dos cálculos, considera-se que uma quadrícula está fora de uma a cratera se nenhum dos quatro vértices estiver no interior da cratera. Note bem: a circunferência da cratera não faz parte do interior da cratera. 66. O mapa da superfície vem representado num ficheiro, no qual primeira linha do ficheiro tem dois números inteiros H e L e H, 0 < H <= 256, 0 < L <= 256 representado a altura e a largura do mapa. Na segunda linha vem um número inteiro N, representando o número de crateras, 0 <= N <= Seguem-se N linhas cada uma com três números inteiros X, Y e R, onde X e Y representam as coordenadas do centro da cada uma das N crateras e R o respectivo raio. 67. Note que as coordenadas dos centros das crateras podem estar fora do mapa. O raio é um número inteiro positivo. 68. O ficheiro de saída contém duas linhas, cada uma com três números inteiros separados por um espaço. Em cada linha, os dois primeiros números representam as coordenadas do canto inferior esquerdo da quadrícula onde a maior pista possível começa e o terceiro representa o comprimento dessa pista. Cada pista possível tem duas extremidades, mas dizemos que a pista começa na extremidade mais próxima do canto inferior esquerdo do mapa. A primeira linha diz respeito à maior pista na direcção este-oeste e a segunda à maior pista na direcção norte-sul. Em caso de empate, isto é, se houver várias pistas possíveis com o mesmo comprimento máximo, numa dada direcção, prefere-se a que começa mais a sul e se houver duas ou mais que comecem igualmente a sul, prefere-se a que começa mais a oeste. Se não houver pistas, ambas as linhas do resultado terão três zeros. 69. Veja aqui um exemplo de ficheiro de dados: E veja aqui um exemplo de ficheiro de resultados: Literalmente, mãos à obra! Implemente um programa que resolva este problema de forma eficiente. Soluções lentas demais poderão originar o temível Time Limit Exceeded, no mooshak, mesmo que produzam uma resposta correcta. 72. Fim. (E sim, desta vez, é mesmo o fim da Gold Edition deste guião). POO, Guião 2 14