FAESA – Ciência da Computação - Linguagem de Programação...

Faculdades Integradas Espírito-SantensesUnidade de Computação e SistemasDisciplina: Linguagem de Programação II - 2009/2Prof. Henrique Monteiro Cristovão

Exercícios

Exercício 1: conceitos iniciais da POO

01) Desenhe um diagrama UML de classes para um contexto qualquer. Desenhe ao menos uma relação de especialização (símbolo: triângulo – se lê: “...é um(a)...”), e uma relação de composição (símbolo: losango – se lê: “...faz parte de...”).

Descreva, e cite exemplo se necessário, como ocorrem cada uma das relações: instanciação, generalização, especialização, composição, decomposição.

Exercício 2: revisão de Java e nivelamento

02) Elabore uma classe para representar uma Data do calendário. Represente-a com 3 inteiros: dia, mês e ano.

Use a abstração de encapsulamento de dados para proteger os campos com o modificador de acesso private.

Crie métodos de interface (get..., set...) para os campos. Observe que não possível atualizar somente um dos elementos da data, pois isto poderia a tornar inconsistente, como por exemplo 30/02/2010. Sendo assim construa o método setData com três parâmetros (dia, mês e ano).

A única forma de alterar uma data deve ser através do método setData pois assim aumenta-se o nível de alterabilidade. Sendo assim, faça uma verificação completa quanto a sua consistência neste método. Para o caso de uma tentativa de registrar uma data inválida, coloque a data padrão: 01/01/1900. Para auxiliar o método setData, crie um método (isBissexto) para verificar se um ano é bissexto, recebendo-o como parâmetro e retornando um boolean.Crie também um método (isDataValida) para verificar se uma data passada como argumento é válida, retornando um boolean para indicar a sua validade.

Obs. o um ano é bissexto, cujo mês de fevereiro possui 29 dias, se o resto da divisão do ano por 4

for zero (divisível por 4) e também se o resto da divisão por 100 não for zero (não divisível por 100), ou ainda se o resto da divisão por 400 for zero.

o Os meses com 30 dias são 4, 6, 9 e 11.

o Permita apenas anos a partir de 1582, pois o calendário gregoriano, com a atual regra de cálculo de anos bissextos, só é válido a partir deste ano.

Crie o método toString para formatar e devolver a data no formato “dd/mm/aaaa”

Lista de exercícios para LP II – 2009/2 - pág.: 1/21

Acrescente na classe Data construtores sobrecarregados e métodos de interface para permitir a entrada: (lembre-se que normalmente o código fica no método de interface, set, e o construtor apenas faz a sua chamada, pois desta forma centralizamos o código e aumentamos o nível de alterabilidade)

o de uma data contendo somente o mês e ano (neste caso o dia receberá 1), o de uma data completa (com 3 inteiros),o de uma data completa no formato String “dd/mm/aaaa”, sendo possível dia e mês com dois

ou apenas 1 caractere. Veja as dicas sobre a classe string a seguir.o de uma data completa: dia como inteiro, o nome do mês como String e o ano como inteiro.o de uma data vazia – construtor sem argumentos - (assuma 1/1/1900).

Dicas da classe String: o use o método substring para pegar um pedaço de uma string, por exemplo,

s.substring(0,5), pega os caracteres da posição zero até a posição 4 da string so indexOf para consultar a posição de um caractere numa string, por exemplo,

s.indexOf(“a”), retorna a posição do caractere “a” na string s, e s.indexOf(“a”,3) retorna a posição do caractere “a” a partir da posição 3 da string s.

o Integer.parseInt para converter de String para int.

Consulte a documentação do Java:Para entrar na documentação do Java abra o arquivo index.html que fica na pasta docSelecione o link: API&LANGUAGE DOCUMENTATION – Java 2 Platform API Specification.(ou então entre no link: http://java.sun.com/javase/6/docs/api/index.html) Clique na classe desejada (por exemplo, classe String) no frame da esquerda que organiza todas as classes em ordem alfabética.

Faça uma classe de uso para testar a classe Data. Usando construtores apropriados, crie os seguintes objetos:11-02-2010“12/02/2009”03-200910-fevereiro-20091/1/1900

Usando o método isDataValida, verifique se as seguintes datas são válidas: 29-02-2008 - válida30-02-2008 - inválida29-02-2009 - inválida31-04-2009 - inválida31-03-2009 - válida32-12-2009 - válida31-13-2009 - inválida31-12-1581 - inválida


http://java.sun.com/javase/6/docs/api/index.html

Exercício 3: método equals, classe StringBuffer, tratamento de erros com throw-throws-try-cath.

03) Faça as seguintes alterações na classe Data do exercício anterior: Acrescente o método equals para comparar datas. Modifique o método toString para usar a classe StringBuffer na concatenação dos dados. Implemente um tratamento de erros verificado (classe Exception) para datas inválidas com os

comandos throw e throws. Faça isto dentro do método setData retirando a mudança para a data padrão sugerida (1/1/1900), pois agora quando for detectada uma data inválida deve-se disparar um erro com throw.

Na classe de uso, através dos comandos try e catch, refaça as verificações das datas sugeridas no exercício anterior.

Ainda na classe de uso possibilite que o usuário entre com uma data via teclado. Faça a verificação dela e em caso de erro solicite novamente a sua entrada. Dê três chances de entrada para o usuário. Se mesmo assim a data ainda continuar errada então assuma a data padrão (1/1/1900).

Escreva na classe Data o método incrementa(), que retorna a data incrementada de um dia. Dica: use um tratamento de erros (try-catch) e peça para somar 1 unidade ao dia. Em caso de erro, some então o mês, ou se ainda houver erro incremente o ano. Ou seja, pegue a data atual (dt) e tente adicionar uma unidade no dia: dt.setData(dt.getDia()+1,dt.getMes(), dt.getAno()), em caso de erro significa que o dia ultrapassou o limite, então tente adicionar uma unidade ao mês: dt.setData(1,dt.getMes()+1, dt.getAno()). Use o mesmo raciocínio para o ano.

Sobrecarregue o método incrementa para receber como argumento a quantidade de dias que será incrementada na data.Dica: chame o método incrementa sem argumentos a quantidade de vezes desejada.

Exercícios 4 a 7: membros estáticos.

04) Altere a classe Aluno fornecida nas notas de aula: Para que o limite superior da nota, atualmente 10.0, possa ser modificado através de uma

armazenamento estático, que sirva para todos os objetos da classe. Não esqueça de criar uma constante para inicializar este campo, e criar métodos de interface para acessá-lo. Use este campo também no método de interface que faz a verificação do limite da nota.

Crie um método para verificar se uma determinada nota ultrapassou o limite permitido. Reflita se este método deve ser estático ou não e explique o porquê da sua decisão.

05) Faça uma análise na classe Data e faça as adequações necessárias para a utilização de membros estáticos.Responda os itens para ajudar na análise:

O método isDataValida deve ser estático? Justifique sua resposta. O método isAnoBissexto deve ser estático? Justifique sua resposta. Seria útil uma versão sobrecarregada do isDataValida e do isAnoBissexto ambos sem

argumentos? Neste caso, a informação seria o próprio objeto que fez a chamada do método. Faça um método estático, com o nome de verificaECriaData, para verificar a validade de uma

data passada como argumento (dia, mês e ano como três inteiros) retornando um objeto da classe Data se ok, ou null se a data estiver incorreta. Sugestão: chame o construtor da classe Data para criar o objeto e use try-catch para capturar o erro.


06) Inclua na classe Data o método compareTo que tem como objetivo receber um objeto da classe Data como argumento e retornar 1, 0 ou -1, respectivamente se o objeto usado na chamada é maior, igual ou menor do que o objeto passado como argumento.Este método deve ser estático ou não? Porque?Caso a resposta seja negativa, o que deveria ser feito para torná-lo estático?Normalmente as classes em Java possuem um método compareTo pois ele pode ser usado por classes que organizam uma coleção de objetos ordenados.Crie uma situação de uso para este método.

07) Crie uma classe onde cada objeto deve representar uma conta bancária. As informações importantes para esta classe são: nome do correntista, saldo e taxa de juros. Todos os campos devem ser encapsulados como privados. A taxa de juros é única para todos os correntistas. Crie construtores, interface (métodos get... e set...), toString, equals e compareTo

adequados para esta classe, sendo ainda interessante criar uma interface separada para a taxa de juros já que ela é independente dos objetos.

Crie um tratamento de erros com throw e throws para inibir saldo negativo. Escreva um método para corrigir o saldo a partir da taxa de juros.

Crie uma classe de uso que receba via teclado informações para 2 objetos da classe que representa a conta bancária. Em seguida faça a correção do saldo de um dos dois correntistas (dê a opção de escolha para o usuário). Exiba os 2 objetos criados.

Exercícios 08 a 10: revisão

08) Crie a classe Ponto para representar um ponto no plano cartesiano, isto é, ele deve possuir a coordenada x e a coordenada y do tipo double.Composição e características da classe: Campos privados. Métodos de interface para todos os campos. Construtores sobrecarregados:

o Entrada vazia, nesta caso, atribua (0,0)o Entrada dos dois double (x,y)o Entrada de um objeto String no formato “(x,y)”

Dois campos para armazenar os limites inferior e superior permitido para as coordenadas. Estes campos deverão ser inicializados com os valores 500 e 0 (definidos como constantes - final). Permita também que o usuário possa modificar estes valores através de métodos do tipo set.Desta forma, use estes campos para limitar os valores atribuídos às coordenadas x e y. Use a classe de tratamento de erros verificados Exception para enviar uma mensagem de erro ao programador usuário.

Método equals. Método toString para devolver o objeto no formato “(x,y)”. Método clonar que retorna um novo objeto com os mesmos valores da instância usada na chamada

do método. Método criaSwap que retorna uma nova instância da classe onde os valores dos campos x e y são

trocados. Método temEixoComum que recebe uma outra instância da classe e retorna o valor booleano true

se as coordenadas horizontais e/ou verticais encapsuladas forem iguais às da instância passada como


argumento. Por exemplo, as coordenadas (1,2) e (1,-17) têm eixo comum, as (-9,0) e (-9,0) também têm, mas as (13,-8) e (8,-22) não têm eixo comum.

Método distancia que recebe uma outra instância da classe Ponto e retorna um valor do tipo double correspondente à distância euclidiana entre o ponto encapsulado (usado na chamada do método) e o passado como argumento. Dica: A distância euclidiana d entre um ponto com coordenadas (x1,y1) e outro ponto com coordenadas (x2,y2) é calculada por raiz quadrada de: (x1-x2) ao quadrado mais (y1-y2) ao quadrado. Em Java: d = Math.sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2)), onde Math.sqrt é a chamada do método estático que calcula a raiz quadrada.

Crie versões sobrecarregadas do método anterior para:- receber como argumento as 2 coordenadas do ponto- receber como argumento as 4 coordenadas dos dois pontos- receber como argumento os dois pontos com objetos da classe PontoObs.: decida corretamente quando cada um destes métodos deve ser estático e não esqueça de reaproveitar o código em todos os métodos.

Método distanciaDaOrigem que não recebe nenhum argumento, mas calcula a distância euclidiana entre as coordenadas encapsuladas e a origem do sistema de coordenadas. Dica: dentro do método, crie uma instância da classe Ponto correspondente à origem e passe-a como argumento para o método distância do item anterior.

Método compareTo. Use como critério a distância do ponto até a origem.

Crie uma classe de uso para receber um ponto do usuário e gerar outros 100 pontos de forma aleatória exibindo para cada um a distância entre ele e o primeiro ponto informado.

09) Crie a classe Retangulo, definida por dois pontos (duas agregações da classe Ponto criada no exercício anterior) que correspondem aos seus vértices: esquerdo superior e direito inferior (considerando que este retângulo é paralelo aos eixos).

Construa uma interface (métodos) para acessar os valores dos pontos.

Crie também o método toString para retornar as informações do retângulo no formato “(x,y) – (x,y)”, para isto, use o método toString já definido na classe Ponto.

Crie três construtores: um para receber as 4 coordenadas, outro para receber os dois pontos (instâncias da classe Ponto), e o terceiro, sem argumentos, que inicializa os dois pontos com os valores padrão da classe Ponto.Reaproveite o código sempre.

Crie um método para calcular a área do retângulo e outro para calcular o perímetro. No sentido de modularizar e reaproveitar o código, crie antes métodos para calcular o lado x e o lado y.

Faça um método equals aproveitando o equals já criando na classe agregada Ponto.

Acrescente também os métodos equalsArea e compareTo (use como referência o tamanho da área).

Desenhe o diagrama UML de classes para as classes Ponto e Retangulo.


10) Crie uma classe para representar os números racionais (números que podem ser exibidos como uma fração). A etapa referente ao levantamento dos requisitos para esta classe já foi realizada em entrevista com o futuro usuário programador e, desta forma, o mesmo forneceu um código com alguns casos de uso da futura classe da forma como ele gostaria. Sendo assim crie os elementos básicos para esta classe e inclua as solicitações deste usuário.

Faça um tratamento de erros não verificado (classe RuntimeException) para inibir denominadores iguais a zero.

Atenção: como desafio escreva apenas uma vez o código para a multiplicação. Os outros métodos sobrecarregados devem reaproveitar este código.

class UsaFracao {public static void main(String[] args) {

Fracao w,x,y,z;

// os objetos x,y e w recebem a fração padrão: 0/1x = new Fracao();w = new Fracao(); z = new Fracao();

w.setNumerador(1); w.setDenominador(2); // atribui 1/2 ao objeto w

x.set("3/4"); // atribui 3/4 ao objeto x

System.out.println(x); // exibe 3/4 System.out.println(x.toReal()); // exibe 0.75 System.out.println(z); // exibe 0 (denominador igual a 1 não aparece) System.out.println(w); // exibe 1/2

y = w.multiplica(x); // faz y = w * x System.out.println(y); // exibe 3/8

w.multiplica(x,y); // faz w = x * y System.out.println(w); // exibe 9/32

Fracao a = w.multiplica(1,2); // faz a = w * 1/2 System.out.println(a); // exibe 9/64

x.multiplica(1,2,5,6); // faz x = 1/2 * 5/6 System.out.println(x); // exibe 5/12

a = y.multiplica(x); // faz a = y * x System.out.println(a); // exibe 15/96

z.multiplica(y,"2/5"); // faz z = y * 2/5 System.out.println(z); // exibe 6/40

if( x.compareTo(y) == 1) // verifica se a fração x é maior do que a fração ySystem.out.println(x+” é maior do que “+y);

// as 3 próximas linhas irão imprimir: “9/32 + 1 = 41/32”System.out.println(w + ” + 1 = ” );w.incrementa();System.out.println(w);

Fracao b = new Fracao("4/8");b.simplifica();

System.out.println(b); // exibe 1/2

Fracao d = new Fracao("5"); // cria a fração 5/1


System.out.println(d); // exibe 5 (toString não exibe denominadores iguais a 1)

Fracao c = new Fracao(2,5);c.simplifica();

System.out.println(c); // exibe 2/5 }

}

Para conferência da sua solução, verifique a exibição (exatamente nesta ordem):3/40.7501/23/89/329/645/1215/966/405/12 é maior do que 3/89/32 + 1 = 41/321/252/5

Exercícios 11 a 15: herança, sobreposição e polimorfismo.

11) Organize os elementos abaixo em classes tentando relacioná-los através de composição (“... faz parte de ...”) e herança (“... é um(a) ...”).

Detalhes das classes:

Data: dia, mês, ano.Pessoa: nome, identidade e data de nascimento.Funcionário: nome, identidade, data de nascimento, data de admissão e salário.Paciente de clínica: nome, identidade, data de nascimento e plano de saúde.Chefe: nome, identidade, data de nascimento, data de admissão, salário e departamento.

Obs.: Faça primeiramente o teste com a herança e depois com a agregação. Desenhe o diagrama UML mostrando estas relações. Implemente as classes com construtores e métodos toString. Sempre que possível use métodos de outras classes já criadas (reutilização de código). Configure todos os campos como privados.


12) Acrescente no exercício anterior:

i) A classe Diretor que herda da classe Chefe e possui um campo adicional para representar a data de promoção ao cargo. Havendo necessidade acrescente outros construtores.

ii) Na classe Funcionário, crie um método para reajustar o salário a partir de uma taxa informada como argumento. Este método, depois de implementado, ficará disponível para as classes Chefe e Diretor?Se sim, como deve ser feito seu acesso?Se não, como deve ser feito para que fique acessível? iii) Acrescente métodos sobrepostos (em cada classe) para calcular o valor máximo de um empréstimo para cada indivíduo: (use “super.” sempre que for possível) Para pessoas: o valor é constante e igual a 1 mil. Para funcionários: o valor é igual ao salário. Para chefes: o valor é o dobro do valor máximo do funcionário. Para diretores: o valor é uma vez e meia o valor máximo de chefe. iv) Crie uma classe de uso (com o método main) para (1º) permitir a entrada dos dados de 50 pessoas entre funcionários, chefes e diretores. Fica a cargo do usuário a escolha. (2º) receber o valor correspondente a taxa de reajuste dos salários, e (3º) imprimir o nome de cada indivíduo, o seu salário reajustado e o valor máximo permitido para empréstimo.Faça uso de chamadas polimórficas sempre que possível. Observe atentamente os construtores existentes nas classes.

v) Desenhe o diagrama UML de classes simplificado mostrando as relações de composição e herança.

vi) Considerando as classes já todas implementadas, marque as linhas incorretas no código abaixo. Justifique a resposta. (Responda a questão antes de conferir no Eclipse)

1. public class Uso {2. public static void main(String[] args) {3. Data dat = new Data();4. Pessoa pes = new Pessoa();5. Funcionario fun = new Funcionario();6. Chefe che = new Chefe();7. PacienteClinica pac = new PacienteClinica();8. //...9. dat = pes;10. dat = fun;11. dat = che;12. dat = pac;13. pes = fun;14. pes = che;15. pes = pac;16. pes = dat;17. fun = pes;18. fun = che;19. fun = pac;20. fun = dat;21. che = pes;22. che = fun;23. che = pac;24. che = dat;25. pac = pes;26. pac = fun;27. pac = che; 28. pac = dat;29. } }


13) Responda as questões propostas:

- Cite diferenças e similaridades entre sobrecarregamento e sobreposição. - Qual a diferença de vinculação estática para vinculação dinâmica? - Que relação o polimorfismo tem com a herança, o sobrecarregamento e a vinculação dinâmica? - É verdade que toda relação de herança entre duas classes poderia ser reescrita como uma relação de composição (ou agregação)? Se sim, dê exemplo e explique qual a inconveniência de se fazer isto?

14) Crie as classes descritas abaixo. Empregue, na medida do possível e de forma adequada para atender a orientação a objetos, herança e agregação entre as classes. Todos os campos devem ser privados. Para todas as classes: crie pelo menos dois construtores sobrecarregados, métodos de interface para os campos, toString e equals.

Escreva com comentários: onde ocorreu sobreposição, sobrecarregamento e chamada polimórfica.

EmailCampo: descrição do emailFaça tratamento de erro verificado para não permitir email sem o caracter ‘@’.

Contato Campos: nome e emailAtenção: reflita se é melhor usar a agregação ou herança entre as classes Email e Contato. Melhor ainda: desenvolva as duas soluções para vivenciar as duas situações e construir uma argumentação mais sólida a respeito de cada caso.

ClienteCampos: nome, email, celular, endereço, renda familiar.Método para determinar a categoria do cliente, sendo a renda familiar mais alta do que 2000,00 devolve a categoria ‘top’ senão fica na categoria ‘usual’Faça também uma versão estática deste método.Crie um campo final para armazenar o valor 2000,00. Mas, faça de tal forma que este valor possa ser modificado pelo usuário através de métodos estáticos e de interface apropriados.

UsoPermita um cadastramento simples de até 50 pessoas, entre contatos e clientes, via teclado. Armazene-os num vetor.Ainda no método main, faça a exibição de todos os dados com chamadas polimorficas.


15) A classe Date fornecida pela API da Java representa uma data do calendário. Ela possui alguns inconvenientes, como o número do mês representado de 0 a 11 entre outros. Em função disto, crie a classe Data que herda da classe Date (pertencente ao pacote java.util do Java) com as seguintes alterações/extensões:

Busque as informações necessárias na documentação do Java. Para entrar na documentação do Java abra o arquivo index.html que fica na pasta docSelecione o link: API&LANGUAGE DOCUMENTATION – Java 2 Platform API Specification.(ou então entre no link: http://java.sun.com/javase/6/docs/api/index.html) Clique na classe desejada no frame da esquerda que organiza todas as classes em ordem alfabética.

i) Sobrecarregue o método setMonth() para aceitar também uma string como nome do mês, pois na versão original ele só aceita o valor numérico correspondente ao mês (0 para janeiro e 11 para dezembro).

ii) Sobreponha o método getMonth() para retornar o valor do mês de 1 a 12 (janeiro a dezembro) ao invés de 0 a 11 como é feito na classe pai.

iii) Acrescente uma funcionalidade para retornar a quantidade de dias entre duas datas. Repita o método em vários sobrecarregamentos para oferecer ao usuário diferentes formas de utilização (qtde de argumentos e tipos variados). Lembre-se de usar o modificador static quando achar conveniente.

Dica: use o método getTime para retornar o tempo em milisegundos de uma data. Em seguida subtraia da outra data também transformada em milisegundos. Basta, agora, dividir o resultado por 1000, 60, e 24 para converter milisegundos em dias.

iv) Usando a dica do item anterior faça um método para permitir o incremento de uma quantidade de dias numa determinada data.Dica extra: existe um construtor da classe Date que recebe uma quantidade de milisegundos como argumento.

Obs.: alguns métodos aparecerão com formatação tachado no Eclipse pois são considerados obsoletos. Isto é em função da nova classe Calendar que substitui a Date.


http://java.sun.com/javase/6/docs/api/index.html

Exercícios 16 a 20: classe abstrata, interface, pacotes.

16) Organize as classes a seguir usando herança e agregação. Adicione uma classe abstrata para melhorar a organização

Coordenada (representa uma coordenada, por exemplo, x, y ou z. Tipo: double)Ponto (2 coordenadas)Círculo (2 coordenadas + raio)Retângulo (2 coordenadas + comprimento + largura)Quadrado (2 coordenadas + comprimento)

Todas as formas geométricas (círculo, retângulo e quadrado) possuem a espessura da linha que o contorna e um boolean para indicar se é sólido ou não (preenchido ou não).

Crie métodos para calcular a área e o perímetro destas formas de tal maneira que se possa usá-los polimorficamente depois na classe do usuário.

Crie construtores com e sem argumentos para cada uma das classes.

Escreva métodos de interface para os campos privados, toString e equals para todos as classes.

Escreva uma classe de usuário para testar a estrutura de classes criada através de uma chamada polimórfica para calcular a área e o perímetro.

Observação da POO: como a classe Retângulo herda de Quadrado, que por sua vez já implementou o cálculo da área e do perímetro, então ela não tem como obrigação a implementação destes métodos, uma vez que eles já foram implementados na superclasse.

17) Implemente um programa para satisfazer o diagrama a seguir.

Obs.: o método isEmprestado() é boolean, os métodos empresta() e devolve() são void, os métodos localiza() e apresentaDescricao() são String.


18) Organize, num diagrama UML de classes (pode ser feito somente no papel), as informações descritas abaixo numa hierarquia de classes, criando superclasses abstratas e/ou interfaces quando for adequado.Na falta de alguma informação complete de forma arbitraria usando o bom senso.

Imagem formada por pixels, por exemplo, imagens do Photoshop Imagem vetorial (contém equações matemáticas), por exemplo, imagens do CorelDraw Som Vídeo Texto

Considere os seguintes membros (entre campos e métodos) a serem distribuídos nas classes de acordo com o contexto usado:

nome formato do arquivo quantidade de bytes quantidade de palavras duração do audiovisual apresenta imagem altera brilho play (usado em som e vídeo) pause ( usado em som e vídeo)

19) Transforme a classe ConstantesMatematicas numa interface. Coloque esta interface dentro do pacote Matemática. Crie o pacote Aplicação e, através de uma classe de uso com main, demonstre o uso destas constantes por

meio de um pequeno exemplo.

1. class ConstantesMatematicas {2. final static public double RAIZDE2 = 1.4142135623730950488;3. final static public double RAIZDE3 = 1.7320508075688772935;4. final static public double RAIZDE5 = 2.2360679774997896964;5. final static public double RAIZDE6 = RAIZDE2* RAIZDE3;6. }

20) Faça o que se pede em cada item a partir do código fornecido.

public class Ponto { private double x, y ;public static final double LIMITE_INF_DEFAULT = 0;public static final double LIMITE_SUP_DEFAULT = 500;private static double LIMITE_INF = Ponto.LIMITE_INF_DEFAULT;private static double LIMITE_SUP = Ponto.LIMITE_SUP_DEFAULT;

public Ponto() throws Exception {this(0,0);

}Ponto(double _x, double _y) throws Exception {

this.setX(_x);this.setY(_y);

}public static boolean isLimite(double coordenada) {

return coordenada >= Ponto.LIMITE_INF && coordenada <= Ponto.LIMITE_SUP;}public void setX(double _x)throws Exception{

if(Ponto.isLimite(_x)) this.x = _x;

elsethrow new Exception ("valor de x fora dos limites");

}public void setY(double _y)throws Exception{


if(Ponto.isLimite(_y)) this.y = _y;

elsethrow new Exception ("valor de y fora dos limites");

}public double getX(){

return this.x;}public double getY(){

return this.y;}public static double getLIMITE_INF() {

return Ponto.LIMITE_INF;}public static double getLIMITE_SUP() {

return Ponto.LIMITE_SUP;}public static void setLIMITE_INF(double inferior) {

Ponto.LIMITE_INF = inferior;}public static void setLIMITE_SUP(double superior) {

Ponto.LIMITE_SUP = superior;}public static double getLIMITE_SUP_DEFAULT() {

return LIMITE_SUP_DEFAULT;}public Ponto clonar() throws Exception {

return new Ponto(this.getX(), this.getY());}public Ponto criaSwap() throws Exception {

return new Ponto(this.getY(), this.getX());}public boolean temEixoComum(Ponto _ponto){

return this.getX() == _ponto.getX() || this.getY() == _ponto.getY();}static public double distancia(double x1, double y1, double x2, double y2){

return Math.sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));}public double distancia(Ponto _ponto){

return Ponto.distancia(this.getX(),this.getY(),_ponto.getX(),_ponto.getY());}public double distancia(double _x, double _y){

return Ponto.distancia(this.getX(),this.getY(),_x,_y);}public double distanciaDaOrigem(){

return Ponto.distancia(this.getX(),this.getY(),0,0);}public int compareTo(Ponto _ponto){

if (this.distanciaDaOrigem() > _ponto.distanciaDaOrigem())return 1;

else if(this.distanciaDaOrigem() < _ponto.distanciaDaOrigem())return -1;

elsereturn 0;

}public boolean equals(Object obj) {

if (this == obj)return true;

if (obj == null)return false;

if (getClass() != obj.getClass())return false;

final Ponto other = (Ponto) obj;if (Double.doubleToLongBits(x) != Double.doubleToLongBits(other.x))

return false;if (Double.doubleToLongBits(y) != Double.doubleToLongBits(other.y))

return false;return true;

}public String toString(){

StringBuffer coord = new StringBuffer();coord.append("(");coord.append(this.getX());


coord.append(",");coord.append(+this.getY());coord.append(")");return coord.toString();

}}

/** página 162 do livro de Rafael Santos - versão modificada * * A interface ObjetoGeometrico define que métodos um objeto geométrico genérico * bidimensional deve conter. Esta interface não declara nenhum campo. */interface ObjetoGeometrico {

/** * O método centro retorna o ponto em duas dimensões que corresponde ao centro * do objeto geométrico. * @return uma instância da classe Ponto2D representando o centro do objeto * geométrico. */Ponto centro();

/** * O método calculaÁrea calcula a área do objeto geométrico e retorna a área * como um valor do tipo double. * @return a área deste objeto geométrico. */double calculaÁrea();

/** * O método calculaPerímetro calcula o perímetro do objeto geométrico e retorna o * perímetro como um valor do tipo double. * @return o perímetro deste objeto geométrico. */double calculaPerímetro();

}

/** * A interface Escalavel define que métodos um objeto que seja escalável (isto é, * que pode ter seu tamanho modificado como uma função do tamanho anterior) deve * conter. Esta interface não declara nenhum campo. */interface Escalavel {

/** * O método amplia modifica os campos do objeto para alterar o seu tamanho. * @param escala a escala para modificação do objeto */void amplia(double escala);

/** * O método espelha modifica os campos do objeto para alterar a sua posição (fazendo * com que o objeto fique refletido nas suas coordenadas horizontais) */void espelha();

}

/** * A classe Circulo implementa as interfaces ObjetoGeometrico e Escalavel, e * representa um círculo cujo tamanho pode ser modificado em função do seu tamanho * anterior. Esta classe encapsula o ponto central do círculo e seu raio. Todos os * métodos declarados nas interfaces ObjetoGeometrico e Escalavel são implementados. */public class CirculoEscalavel implements ObjetoGeometrico,Escalavel {

/** * Declaração dos campos da classe */private Ponto centro;private double raio;

/** * O construtor para a classe CirculoEscalavel, que recebe argumentos para


* inicializar todos os campos da classe. Este é o construtor "completo". * @param centro o centro do círculo (uma instância da classe Ponto2D) * @param raio o raio do círculo */public CirculoEscalavel(Ponto _centro,double _raio) {

this.centro = _centro; // Note o uso da palavra-chave this para marcar os camposthis.raio = _raio; // da classe que tem o mesmo nome dos argumentos

}

/** * O método centro retorna o ponto em duas dimensões que corresponde ao centro do * círculo. Neste caso, basta retornar a instância da classe Ponto2D que representa * o próprio centro. * @return uma instância da classe Ponto2D representando o centro do círculo */public Ponto centro() {

return this.centro;}

/** * O método calculaÁrea calcula a área do círculo e retorna a área como um valor do * tipo double. * @return a área deste círculo */public double calculaÁrea() {

return Math.PI*raio*raio; }

/** * O método calculaPerímetro calcula o perímetro do círculo e retorna o perímetro * como um valor do tipo double. * @return o perímetro deste círculo */public double calculaPerímetro() {

return 2.0*Math.PI*this.raio; }

/** * O método amplia modifica o raio do círculo de acordo com o valor passado como * argumento, efetivamente modificando o tamanho do círculo. * @param escala a escala para modificação do círculo */public void amplia(double _escala) {

this.raio *= _escala;}

/** * O método espelha modifica o centro do círculo para alterar a sua posição (fazendo * com que o círculo fique refletido nas suas coordenadas horizontais) */public void espelha() {

this.centro = new Ponto(this.centro.getX()*(-1),this.centro.getY());}/** * O método toString retorna os valores dos campos do círculo formatados em uma * string. * @return uma string contendo uma representação dos campos do círculo */public String toString() {

// Retorna diretamente uma string criada com os valores dos campos. O método // toString da classe Ponto2D é chamado implicitamente.return centro + "-" + this.raio;

}}

/** * A classe DemoCirculoEscalavel demonstra o uso dos métodos da classe * CirculoEscalavel e sua relação com as interfaces ObjetoGeometrico e Escalavel. */public class DemoCirculoEscalavel {

/** * O método main permite a execução desta classe. Este método contém declarações de * uma instância da classe CirculoEscalavel e usa seus métodos.


* @param argumentos os argumentos que podem ser passados para o método via linha * de comando, mas que neste caso serão ignorados. */public static void main(String[] argumentos) {

// Declaramos e alocamos uma instância da classe CirculoEscalavelCirculoEscalavel ce = new CirculoEscalavel(new Ponto(10,10),30); // Imprimimos a posição original do círculo escalávelSystem.out.println(ce); // chamada implícita ao método toString// Modificamos a escala do círculoce.amplia(3);// Imprimimos novamente os dados do círculoSystem.out.println(ce);// Modificamos a posição do círculo (espelhando)ce.espelha();// Imprimimos novamente os dados do círculoSystem.out.println(ce);// É uma instância da classe CirculoEscalavel ?System.out.println(ce instanceof CirculoEscalavel); // true// É uma instância da interface ObjetoGeometrico ?System.out.println(ce instanceof ObjetoGeometrico); // true// É uma instância da interface Escalavel ?System.out.println(ce instanceof Escalavel); // true

} }

a. Faça o diagrama UML de classes do programa fornecido. Acrescente as outras classes e seus relacionamentos na medida que for desenvolvendo os próximos itens.

b. Crie a classe RetanguloEscalavel que implementa simultaneamente as interfaces ObjetoGeometrico e Escalavel. Considere que para representar o retângulo são necessários dois pontos: o vértice superior esquerdo e o vértice inferior direito. Considere também que o retângulo é sempre paralelo aos eixos.

c. Através de herança da classe Ponto, crie a classe Ponto3D adicionando a coordenada z. Faça apenas os ajustes que julgar importantes para adequar as funcionalidades para o plano tridimensional.

d. Usando a interface ObjetoGeometrico como base, crie a interface ObjetoTridimensional que deverá ser implementada por todas as classes que representem objetos tridimensionais. A interface deve declarar os métodos centro que deve retornar uma instância da classe Ponto3D, calculaSuperfície, que calcula e retorna a área de superfície do objeto tridimensional, e calculaVolume, que calcula e retorna o volume do objeto tridimensional.

e. Acrescente nesta hierarquia a classe CilindroEscalável que também implementa as interfaces ObjetoTridimensional e Escalável.

f. Escreva a classe Esfera, que implemente a interface ObjetoTridimensional e represente uma esfera no espaço tridimensional. O volume de uma esfera é igual a 4/3r3, onde r é o raio da esfera, e a área de sua superfície é igual a 4r2

g. Escreva a classe Paralelepipedo, que implemente a interface ObjetoTridimensional e represente um paralelepípedo no espaço tridimensional. O volume de um paralelepípedo é igual a a×b×c, onde a, b e c são o comprimento de seus lados. A área da superfície é dada por 2(ab+bc+ac). A classe deve usar duas instâncias da classe Ponto3D para representar os pontos opostos do paralelepípedo. Os comprimentos dos lados podem ser obtidos a partir das diferenças das coordenadas x, y e z dos cantos opostos.

h. Escreva para a interface ObjetoGeometrico a declaração do método clona, que não recebe argumentos e retorna uma instância de ObjetoGeometrico. Ao criar essa declaração, todas as classes que implementam ObjetoGeometrico deverão implementar esse método. Crie esse método nas classes que implementam a interface. Dica: O método deverá ter o mesmo tipo de retorno do declarado na interface. Por exemplo, a classe Circulo deverá ter um método public ObjetoGeometrico clona, que deve criar e retornar um clone do círculo sendo encapsulado. Não existe problema em declarar um método como devendo retornar ObjetoGeometrico e retornando Circulo, já que, por causa das regras de polimorfismo, Circulo é-um-tipo-de ObjetoGeometrico.

i. Complete o código com comentários para o Javadoc e gere o código em HTML de todas as classes.


Exercícios 21 a 23: enumerações, serialização de objetos, classes wrapper, coleções e aplicações.

21) Para cada situação descrita a seguir, use adequadamente as coleções LinkedList, HashMap, TreeSet e TreeMap para resolver o problema. Crie os três programas diretamente no método main da aplicação.

Em todos os casos cuja entrada for um texto considere-o numa string e sem pontuação.

Colocar todas as palavras de um texto ordenadas alfabeticamente. Não pode haver repetição de palavras. Contar a frequência das palavras de um texto. A partir da leitura de um texto, gerar o mesmo com as palavras embaralhadas. Gerar 20 números sorteados de 1 a 50 sem repetição e depois exibi-los em ordem crescente. Receber uma lista de nomes de pessoas numa ordem qualquer. Manter a coleção de nomes ordenada

alfabeticamente, mesmo enquanto a entrada estiver sendo feita, e também manter um campo com a quantidade de ocorrências.

Dica: use a classe StringTokenizer para capturar cada palavra de uma string:// separa o texto com o delimitador “ “StringTokenizer partes = new StringTokenizer(texto," ");// pega cada uma das partes String pedaco = partes.nextToken();

// para saber quantas partes existem use: partes.countTokens()

22) Crie uma aplicação para simular um jogo de Poker. Desenvolva uma camada de software independente de tal forma que fique fácil de dar continuidade ao projeto para, por exemplo, criar uma camada de rede para permitir vários jogadores online através de uma interface gráfica.

Faça comentários estilo Javadoc e gere o conjunto de arquivos do tipo HTML.Dica:

Para gerar a documentação pelo Eclipse, vá em Project - Generate Javadoc - selecione o seu projeto e marque a visibilidade como private - Finish (para ver o resultado abra o index.html que foi gerado na pasta doc).

Crie as relações entre classes obedecendo POO para que este projeto possa ser reutilizado para outros jogos de baralho.

Sugestão de organização das classes:

As classes Naipe, Carta, Valor, Grupo e Baralhos pertencem ao pacote Baralho.

As classes GrupoPoker, Jogador, JogadorAposta, Rodada, JogoRodadas, JogoCompleto, pertencem

ao pacote Poker

A classe Aplicação pertence ao pacote Usuario


Diagrama UML de classes:

Descrição das classes:Obs.: lembre-se de criar, para cada classe, construtores, métodos de interface, equals, compareTo, toString sempre que achar adequado. Crie outros métodos sempre que achar conveniente.

NaipeÉ uma enumeração que representa os quatro naipes do baralho.Use a seguinte ordem: OURO(1), PAUS(2), COPAS(3), ESPADA(4)

ValorÉ uma enumeração que representa os treze valores do baralho.Use a seguinte ordem: AS(1), REI(2), DAMA(3), VALETE(4), DEZ(5), NOVE(6), OITO(7),

SETE(8), SEIS(9), CINCO(10), QUATRO(11), TRES(12), DOIS(13)

CartaRepresenta uma carta do baralho.Alguns métodos: compareTo completo para valor e naipe. compareToValor somente para valor. isBlase para verificar se a carta contém figura (Rei, Dama e Valete). equals completo equalsValor que verifica a igualdade apenas o valor da carta.


GrupoRepresenta um grupo de cartas do baralho, com pelo menos uma carta.Usa a coleção LinkedList para agregar várias cartas.Alguns métodos: qtde - para retornar a quantidade de cartas do grupo. adiciona - de forma sobrecarregada para incluir um grupo de cartas ou uma carta apenas. retira – retirar e retornar uma carta de uma determinada posição.

De forma sobrecarregada, outra versão para retirar uma determinada carta e retornar um valor lógico que representa a existência ou não da carta.Outra versão para retirar as cartas, na sequencia, de uma posição até uma outra posição.

retiraInicio – retira uma carta do início da lista. retiraFinal – retira uma carta do final da lista. ordena – põe as cartas em ordem crescente. embaralha – embaralha as cartas.

Dica: consulte os seguintes métodos.- add, addAll, remove da classe LinkedList.- sort e shuffle da classe Collections.

BaralhosRepresenta um conjunto de cartas formado por baralhos completos, pelo menos um.Alguns métodos: o construtor vazio deve criar um objeto contendo um baralho completo. outro construtor sobrecarregado para criar a quantidade de baralhos passada como argumento. distribui – retorna um grupo de cartas cuja quantidade é passada como argumento. Retorna null se não houver

mais cartas suficientes. Esta ação equivale a distribuição de cartas que se faz para um jogador. repõe – aceita um grupo de cartas para repor no baralho, na última posição.

Versão sobrecarregada para repor apenas uma carta.

GrupoPokerRepresenta um grupo de cartas usado no jogo do Poker.Contém o número de cartas padrão que será usado no jogo. No início este número deve ser cinco.Contém um vetor de strings contante para armazenar o nome dos jogos na ordem de sua importância. Veja a tabela:

n. Nome Explicação1 um par 2 cartas de mesmo valor2 four blase 4 cartas com figuras (podem ser diferentes)3 four straight seqüência de 4 cartas de qualquer naipe4 four flush 4 cartas de mesmo naipe5 dois pares 2 pares6 blaze 5 cartas com figuras7 trio 3 cartas de mesmo valor8 round the corner straight seqüência de 5 cartas com o A no meio9 straight seqüência de 5 cartas10 flush 5 cartas de mesmo naipe11 four straigh flush seqüência de 4 cartas de mesmo naipe12 full hand um par + um trio13 poker 4 cartas de mesmo valor14 straight flush 5 cartas em seqüência e mesmo naipe15 royal flush straight flush iniciado no A

Alguns métodos: troca – troca uma quantidade de cartas determinada por outras do baralho. Por isso deve receber como argumento

um objeto Baralhos (para fornecer as cartas novas) e receber as cartas velhas (da mão). Crie este método para permitir que sejam escolhidas as posições das cartas para a troca: com 1 argumento inteiro (posição da carta) para trocar 1 carta, até 4 argumentos para trocar 4 cartas. Sem argumentos troca todas as cartas.

verificaJogo01 – verifica se há ocorrência de um parLista de exercícios para LP II – 2009/2 - pág.: 19/21

verificaJogo05 – verifica se há ocorrência de dois pares verificaJogo06 – verifica se há ocorrência de um blase verificaJogo07 – verifica se há ocorrência de um trio verificaJogo13 – verifica se há ocorrência de um pokerObs.: após ter completado todo o exercício, retorne a esta classe e desenvolva o algoritmo dos outros jogos (de 1 a 15 pela tabela fornecida). verificaMaiorJogoNumero – retorna o número do maior jogo. Retorna zero se não houver jogo válido. verificaMaiorJogoNome – retorna o nome do maior jogo. Retorna null se não houver jogo válido.

JogadorRepresenta um jogador do jogo. Possui o nick e o total de dinheiro do jogador.

JogadorApostaRepresenta a participação de um jogador numa rodada.Possui o valor apostado.Possui também um flag para indicar se o jogador é o primeiro a apostar. O primeiro a apostar deve ser sempre o jogador que ganhou o Jogo de Rodadas passada.

RodadaRepresenta uma rodada de apostas do jogo de Poker.Possui o total de dinheiro apostado por todos os jogadores que entraram na rodada.Usa a coleção LinkedList para agregar objetos da classe JogadorAposta na ordem em que eles irão jogar. A ordem nunca muda durante todo o jogo já que os jogadores ficam em círculo, o que varia é o jogador que irá iniciar as apostas.

JogoRodadasRepresenta um conjunto de rodadas até decidir o ganhador das apostas.Usa a coleção LinkedList para agregar objetos da classe Rodada.Alguns métodos: determina o jogador que ganhou a sequencia de rodadas.

JogoCompletoRepresenta o conjunto de todas as rodadas que decidirão o ganhador final. Ou até que se decida parar o jogo.Usa a coleção LinkedList para agregar objetos da classe JogoRodadas.Usa novamente a coleção LinkedList para agregar objetos da classe Jogador.Alguns métodos: retorna o nome do jogador que tem mais dinheiro. retorna o nome do jogador que mais ganhou rodadas.

AplicacaoRepresenta pelo menos um jogo de Poker completo. Crie um método estático para simular um jogo completo de forma automática. Exiba o passo-a-passo do jogo. Para isto, defina alguns critérios para realizar trocas de cartas, por exemplo, se só houver um par, então troque as outras três cartas. Quanto a aposta defina um valor constante para todas as apostas. E para terminar, por exemplo, defina sempre duas rodadas para cada jogo, com uma quantidade determinada Jogos. Vende quem tiver a maior quantia. Exiba também quem ganhou mais jogos.


23) Estude o código do exemplo 2 do item 19 (Coleções) das notas de aula e faça o que se pede a seguir:

I) Modifique o programa para ele trabalhar com a classe Sorteio, ao invés de Amigo. A classe Sorteio representa uma data (use a classe do exercício 2) seguida de uma seqüência de números sorteados que não se repetem. Mantenha os números sorteados em ordem crescente.Dê condições ao usuário para que ele configure a quantidade de números que será sorteado e a faixa de valores, que, por default, deve ser de 1 a 99.

Crie uma classe para armazenar vários objetos da classe Sorteio. Use, por exemplo, a coleção LinkedList. Acrescente um método para receber uma data e a quantidade de sorteios que deve ser realizada, e ele deve preencher a coleção com os sorteios e datas sucessivas a partir da informada.Por exemplo, se a classe Sorteio estiver configurada para 4 números e se informado 25/04/2007 e 8 sorteios, então ele deve preencher a coleção com os seguintes valores: 25/04/2007 23 45 78 9826/04/2007 01 05 45 7627/04/2007 27 35 56 8728/04/2007 04 12 78 9829/04/2007 01 19 28 8130/04/2007 09 56 57 9001/05/2007 19 32 39 4002/05/2007 34 65 87 88

Crie uma classe de uso para gravar, de forma serializada, as informações num arquivo de objetos. Em seguida faça a leitura deste arquivo recolocando todas as informações de volta numa outra coleção.

Além do arquivo criado pela serialização, crie também um arquivo texto para armazenar as informações no mesmo formato mostrado no quadro anterior.Para gravar no formato texto use a classe BufferedWriter. Observe o exemplo abaixo:

BufferedWriter arqSaida;

arqSaida = new BufferedWriter(new FileWriter("arquivo_de_saida.txt"));

// O método write grava a string no arquivo texto. // Deve ser chamado para cada objeto, com o seu respectivo toString(). // Normalmente aparece dentro de um laço que percorre toda coleção // que contém os objetos que serão gravados.

// O "\r\n" é necessário para colocar os objetos um em cada linha // (o WordPad, Word, InternetExplorer também aceitam "\n" ou "\r", mas // O Bloco de Notas, por exemplo, só aceita "\r\n")this.arqSaida.write(_amigo.toString()+"\r\n");

this.arqSaida.close();

II) Comente o código novo com o estilo Javadoc e gere todos os arquivos HTML da documentação.


FAESA – Ciência da Computação - Linguagem de Programação...

Documents

Transcript of FAESA – Ciência da Computação - Linguagem de Programação...