Implementação de Classe e Auto-Relacionamento em Java · UTFPR – DAELN - Disciplina de...

Implementação de Classe e Auto-Relacionamento em Java

1) Introdução

Um modelo de Diagrama de Classes representa a estrutura definida para o

armazenamento das informações dos elementos ou classes que irão trabalhar em

conjunto para solucionar um problema ou desafio. Sendo esse diagrama um modelo

conceitual, existe a necessidade de verificar a validade e completude desse modelo. Uma

das formas de se fazer isso é por meio de implementação, ou geração de códigos em

uma linguagem de programação Orientada a Objetos e realizações de testes de seu uso.

Neste material, será analisado um modelo de uma classe que possui um

relacionamento com ela mesmo. Quando isso ocorre, diz-se que há um Auto-

Relacionamento.

Como objeto de estudo, definine-se uma classe que representa o conceito

Disciplina. Considera-se, neste exemplo, que uma Disciplina possa possuir ou não como

pré-requisitos outras instâncias da Disciplina.

Ou seja, ela se relaciona com ela mesmo por meio do conceito “pré-requisito”. Por

exemplo, na Figura 1 a seguir, a disciplina EL65E possui como pré-requisito as disciplinas

EL64E, EL64F e EL64G. A disciplina EL64E, por sua vez, possui como pré-requisito a

disciplina FI64A.

Como essa estrutura poderia ser representada em um Modelo Orientado a

Objetos? Para responder a essa questão, este documento está divido em 5 Seções. Na

Segunda Seção, apresenta-se o cartão CRC da classe Disciplina. Na Seção 3, a partir do

cartão CRC, o modelo UML da classe é definido e apresentado. Nesse instante, destaca-

se que novas responsabilidades que não foram definidas no cartão CRC foram criadas

com a finalidade de orientar o programador de computador e também facilitar ou permitir o

(re)uso da classe. A Seção 4 apresenta a implementação da classe Disciplina. Encerrando

este documento, na Seção 5 um exercício é deixado para o aluno resolver.

De maneira similar ao apresentado anteriormente, o programador de computador

deve ter a liberdade de definir ou personalizar a implementação. Ou seja, o programador

UTFPR – DAELN - Disciplina de Fundamentos de Programação II ( IF62C ). 1Prof. Robinson Vida Noronha e Danillo BelmonteTema: Implementação de Classe e Auto-Relacionamentos em Java----------------------------------------------------------------------------------------------------------------------------------------------

de computador implementa além dos métodos e atributos definidos no Diagrama de

Classes UML, novos métodos e atributos que ele/ela achar necessário.

Figura 1 - Grade parcial do Curso de Engenharia Industrial Elétrica da UTFPR, campus Curitiba adaptada para o exemplo investigado.

2)Representação Classe Disciplina O Cartão CRC apresentado na Figura 2, define os atributos ou “conhecimentos”

que um elemento da classe Disciplina deve possuir.

Figura 2 - CRC da Classe Disciplina


O cartão CRC representado na Figura 2 possui na área de Colaboradores, uma

própria instância da classe Disciplina. O Auto-Relacionamento ocorre quando é definido

como colaborador para uma classe, um exemplar da própria classe. Nesse caso, no canto

à direita do cartão CRC existe uma referência à própria classe do cartão, a classe

Disciplina. Isso acontece pois uma disciplina pode possuir nenhum, um ou vários pré-

requisitos e esse pré-requisito é uma outra instância da classe Disciplina.

3)Diagrama UML da Classe Disciplina A Figura 3, a seguir, apresenta o Diagrama de Classe da Classe Disciplina definida

no cartão CRC ilustrado na Figura 2. Alguns detalhes e considerações utilizadas nessa

representação merecem destaque, a saber:

• No diagrama UML, cada responsabilidade indicada no CRC, pode ser um atributo ou

um método.

• As responsabilidades Codigo, Nome, Quantidade de Aulas Teóricas, Quantidade de

Aulas Práticas e Quantidade de Aulas a Distância definidas no cartão CRC da Figura

2 foram representadas no diagrama da Figura 3. Os Anexos 6a), 6b), 6c) e 6d)

ilustram a associação entre as responsabilidades do cartão CRC e o Diagrama de

Classe.

• Cada atributo foi definido com o modificador de acesso private ou privado. Isso é

apenas uma recomendação: “atributos devem ser definidos com acesso private ou

protected”. Essa representação é indicada pelo sinal “-” que precede o atributo.

• Para cada atributo, métodos de acesso “geters” e “seters” de visibilidade pública

foram definidos. Por exemplo, os métodos públicos “+setNome(v: String) : void” e

“+getNome() : String” estão associados ao atributo Nome.

• A responsabilidade “pre-requisito”, por sua vez não foi representada de maneira

explícita no diagrama. De acordo com o diagrama, esse auto-relacionamento possui

a multiplicidade “0..*”. Essa multiplicidade significa que a quantidade de pré-

requisitos pode variar de instância de classe para instância de classe. O Anexo 6e)

ilustra a associação entre a representação do Auto-Relacionamento do Diagrama

UML e o cartão CRC.

• Cada linguagem de programação fornece ao programador um conjunto de opções

para representar o Auto-Relacionamento. Por exemplo, na linguagem C++, poder-se-

ia representar, por exemplo, com listas, vetores ou arrays esse conjunto de


elementos. Por outro lado, na linguagem Java, outras opções também estão

disponíveis. Para deixar o programador livre para definir qual será a forma de

implementação desse grupo de elementos, optou-se apenas por definir um método

de inclusão e outro de remoção de pré-requisito. Os métodos são

“addPreRequesitoNecessario(Disciplina)” e “removePreRequisitoNecessario

(Disciplina)”.

• As duas últimas responsabilidades definidas no cartão CRC “lista de quem sou pré-

requisito” e “lista pré-requisitos necessários” foram definidas como dois métodos no

diagrama de classes. Esses métodos são: listaPreRequisitosNecessarios() e

listaDeQuemSouPreRequisito( ).

• Três outros métodos foram definidos no diagrama de classes e que não foram

previstos no cartão CRC. Esses métodos são: i) “print( )”, ii) “equals(Disciplina)” e iii)

“clone( )”. O método “print( )” imprime as informações consideradas importantes do

conceito Disciplina. Por sua vez, o método “equals(Disciplina)”, verifica se duas

instâncias da classe disciplina podem ser consideradas iguais. O método “clone( )”

fornece uma cópia da instância.

• Dois construtores também foram definidos. Um deles, não recebe argumento algum

e o outro, recebe o código da disciplina e o seu respectivo nome.

• O Auto-Relacionamento denominado por “preRequisito” é representado por uma

linha que inicia e termina na própria classe. A multiplicidade desse relacionamento é

“0..*”. Essa multiplicidade informa que uma determinada instância da classe

Disciplina pode possuir nenhum, um pré-requisito ou vários.


Figura 3 - UML - Diagrama de Classe da Classe Disciplina

4.Implementação em Java

A definição da assinatura da classe é apresentada no arquivo Disciplina.h a seguir.

Algumas decisões realizadas necessitam ser exclarecidas, a saber:

• os atributos Nome e Codigo da Figura 3 foram definidos como elementos String.

• o Auto-Relacionamento é representado por elementos Vector ou ArrayList. Nesse

exemplo definiu-se as duas opções para armazenar as disciplinas que são pre-

requisitos e também de quais disciplinas a classe é pre-requisito.

• Alguns métodos que não foram definidos no Diagrama de Classes da Figura 3 foram

definidos durante a programação. Esses métodos são:

• java.util.Vector getPreRequisitos(); > definida com a finalidade de

mostrar como um método pode ter uma instância da classe vector de retorno.


• boolean tenhoPreRequisitoNecessario(Disciplina v); > definido

apenas como método auxiliar para os outros métodos. Por não ter sido definido no

Diagrama de Classes, poderia ter sua visibilidade privada.

• boolean souPreRequisito(Disciplina v); > definido apenas como método

auxiliar para os outros métodos. Por não ter sido definido no Diagrama de Classes,

poderia ter sua visibilidade privada.

4.1 Arquivo Disciplina.java

package autorelacionamento;

/**

*

* @author robinsonnoronha

*/

import java.util.Vector;

public class Disciplina {

private! ! String Codigo;

private! ! String Nome;

private! ! int QuantidadeAulasTeoricas;

private! ! int QuantidadeDeAulasPraticas;

private ! int QuantidadeDeAulasDistancia;

private ! Vector preRequisitoNecessarios = new Vector( );

private ! java.util.ArrayList<Disciplina> deQuemSoupreRequisito =

new java.util.ArrayList<Disciplina>();

public ! Disciplina(String v_codigo, String v_nome)

{ this();// chamada para o contrutor sem parâmetros.

! ! ! setNome(v_nome);

! ! ! setCodigo(v_codigo);

}

public Disciplina()

{ QuantidadeAulasTeoricas=0; QuantidadeDeAulasDistancia=0;

QuantidadeDeAulasPraticas=0;

}


public void setQuantidadeAulasTeoricas(int v)

{ if (v>=0) QuantidadeAulasTeoricas = v;}

public void setQuantidadeAulasPraticas(int v)

{ if (v>=0 ) QuantidadeDeAulasPraticas = v;}

public void setQuantidadeAulasDistancia(int v)

{ if (v>=0 ) QuantidadeDeAulasDistancia = v;}

public int getQuantidadeAulasTeoricas(){return QuantidadeAulasTeoricas;}

public int getQuantidadeAulasPraticas(){return QuantidadeDeAulasPraticas;}

public int getQuantidadeAulasDistancia(){return QuantidadeDeAulasDistancia;}

public void setNome(String v){Nome = v.toUpperCase();}

public String getNome(){return Nome;}

public void setCodigo(String v){Codigo=v;}

public String getCodigo(){return Codigo;}

public void addPreRequisitoNecessario(Disciplina v)

{ if (tenhoPreRequisitoNecessario(v) == false)

{

preRequisitoNecessarios.add(v);

v.souPreRequisito(this);

}

}

public void removePreRequisitoNecessario(Disciplina v)

{

preRequisitoNecessarios.remove(v);

v.deQuemSoupreRequisito.remove(this);

}

public Vector getPreRequisitos(){return preRequisitoNecessarios;}

public boolean tenhoPreRequisitoNecessario(Disciplina v)

{ return preRequisitoNecessarios.contains(v);}

public boolean souPreRequisito(Disciplina v)

{ return deQuemSoupreRequisito.contains(this);}

public void listaPreRequisitosNecessarios()

{ int i=0;

System.out.println("\nQuantidade de Pre-Requisitos Necessarios:"

+preRequisitoNecessarios.size() +"\n");

for ( i = 0; i < preRequisitoNecessarios.size(); i++)

{ System.out.println("\n Codigo: "

+ ((Disciplina)this.preRequisitoNecessarios.get(i)).getCodigo()


+ "\t Nome: "

+ ((Disciplina)this.preRequisitoNecessarios.get(i)).getNome()

);

}

}

public void listaDeQuemSouPreRequisito()

{

int i=0;

System.out.println("Quantidade de Disciplinas em que sou Pre-Requisito: "

+ this.deQuemSoupreRequisito.size() + "\n"

);

for ( i = 0; i < this.deQuemSoupreRequisito.size(); i++)

{ System.out.println("\n Codigo: "

+ ((Disciplina)this.deQuemSoupreRequisito.get(i)).getCodigo()

+ "\t Nome: "

+ ((Disciplina)this.deQuemSoupreRequisito.get(i)).getNome()

);

}

}

public boolean equals(Disciplina v)

{boolean saida=false;

if (v.getCodigo().equals(Codigo))

if (v.getNome().equals(Nome))

if (v.QuantidadeAulasTeoricas == this.QuantidadeAulasTeoricas)

if (v.QuantidadeDeAulasDistancia == this.getQuantidadeAulasDistancia())

if (v.QuantidadeDeAulasPraticas == this.QuantidadeDeAulasPraticas)

saida = true;

return saida;

}

public void print()

{ System.out.print("\n");

for (int i = 0; i < 70; i++) System.out.print( "=");

System.out.print("\n");

System.out.println( "Disciplina Codigo: " + this.Codigo + "\n"

+ "Disciplina Nome: " + this.Nome + "\n"


+ "Disciplina Quantidade de Aulas Teoricas: "

+ this.QuantidadeAulasTeoricas + "\n"

+ "Disciplina Quantidade de Aulas Praticas: "

+ this.QuantidadeDeAulasPraticas + "\n"

+ "Disciplina Quantidade de Aulas a Distancia: "

+ this.QuantidadeDeAulasDistancia + "\n"

+ "Total das aulas: " +

(this.QuantidadeAulasTeoricas

+ this.QuantidadeDeAulasDistancia

+ this.QuantidadeDeAulasPraticas) + "\n"

);

listaPreRequisitosNecessarios();

listaDeQuemSouPreRequisito();

}

public Disciplina clone()

{ Disciplina saida = new Disciplina();

saida.setCodigo(Codigo);

saida.setNome(Nome);

saida.setQuantidadeAulasTeoricas(QuantidadeAulasTeoricas);

saida.setQuantidadeAulasPraticas(this.QuantidadeDeAulasPraticas);

saida.setQuantidadeAulasDistancia(this.QuantidadeDeAulasDistancia);

return saida;

}

}

//fim do arquivo java

4.3 O Arquivo de teste Main.java

package autorelacionamento;

/**

*

* @author robinsonnoronha

*/

public class Main {

public static void main(String[] args) {

Disciplina MA61B = new Disciplina("MA61B", "Matematica 1");

MA61B.setQuantidadeAulasTeoricas(90);

Disciplina MA61A= new Disciplina("MA61A","Calculo 1");


MA61A.setQuantidadeAulasTeoricas(90);

Disciplina MA62A= new Disciplina("MA62A","Calculo 2");

MA62A.setQuantidadeAulasTeoricas(60);

Disciplina FI63A= new Disciplina("FI63A","Fisica 3");

FI63A.setQuantidadeAulasTeoricas(45);

FI63A.setQuantidadeAulasPraticas(60);

FI63A.addPreRequisitoNecessario(MA61B);

FI63A.addPreRequisitoNecessario(MA61A);

Disciplina FI64A= new Disciplina("FI64A","Fisica 4");

FI64A.setQuantidadeAulasTeoricas(60);

FI64A.addPreRequisitoNecessario(FI63A);

// recebe os pre-requesitos.

System.out.println( "\n Pre-requesitos da Disciplina FI63A:\n");

java.util.Vector l = FI63A.getPreRequisitos();

System.out.println("\n Quantidade de Pre-Requisitos:" + l.size() + "\n");

for(int i=0; i < l.size(); i++)

{

((Disciplina)l.get(i)).print();

}

System.out.println( "\n Clone:" + "\n");

Disciplina cloneFI63A = FI63A.clone();

if (cloneFI63A.equals(FI63A)==true) System.out.println("\n Iguais \n");

else System.out.println( "\n Diferentes clone e original" );

FI63A.print();

FI63A.removePreRequisitoNecessario(MA61B);

FI63A.print();

}

}

4.3 Resultado da Execução.

Pre-requesitos da Disciplina FI63A:

Quantidade de Pre-Requisitos:2

======================================================================Disciplina Codigo: MA61BDisciplina Nome: MATEMATICA 1


Disciplina Quantidade de Aulas Teoricas: 90Disciplina Quantidade de Aulas Praticas: 0Disciplina Quantidade de Aulas a Distancia: 0Total das aulas: 90

Quantidade de Pre-Requisitos Necessarios:0

Quantidade de Disciplinas em que sou Pre-Requisito: 0

======================================================================Disciplina Codigo: MA61ADisciplina Nome: CALCULO 1Disciplina Quantidade de Aulas Teoricas: 90Disciplina Quantidade de Aulas Praticas: 0Disciplina Quantidade de Aulas a Distancia: 0Total das aulas: 90


Quantidade de Disciplinas em que sou Pre-Requisito: 0

Clone:

Iguais

======================================================================Disciplina Codigo: FI63ADisciplina Nome: FISICA 3Disciplina Quantidade de Aulas Teoricas: 45Disciplina Quantidade de Aulas Praticas: 60Disciplina Quantidade de Aulas a Distancia: 0Total das aulas: 105


Codigo: MA61B Nome: MATEMATICA 1

Codigo: MA61A Nome: CALCULO 1Quantidade de Disciplinas em que sou Pre-Requisito: 0

======================================================================Disciplina Codigo: FI63ADisciplina Nome: FISICA 3Disciplina Quantidade de Aulas Teoricas: 45Disciplina Quantidade de Aulas Praticas: 60Disciplina Quantidade de Aulas a Distancia: 0Total das aulas: 105


Codigo: MA61A Nome: CALCULO 1Quantidade de Disciplinas em que sou Pre-Requisito: 0


BUILD SUCCESSFUL (total time: 0 seconds)

5. Exercício

a) Implementar e testar a classe Pessoa e o Auto-Relacionamento “casada_com”.

b) A Classe Pessoa do exercício 5 foi modificada, para o Exercício 5b)

Além do Auto-relacionamento “cada_com” com multiplicidade “0..1”, um novo Auto-Relacionamento deve ser implementado. Esse novo Auto-Relacionamento é denominado “amizadeCom” e possui multiplicidade “0..*”.

Modificar a classe Pessoa implementada no exercício 5a) de tal forma que ela represente esse novo Diagrama de Classe.


6. Anexos

a)

b)


c)

d)

e)


Implementação de Classe e Auto-Relacionamento em Java · UTFPR – DAELN - Disciplina de...

Documents

Transcript of Implementação de Classe e Auto-Relacionamento em Java · UTFPR – DAELN - Disciplina de...