Os diagramas de interação da UML representam graficamente sequências de chamadas de método e podem ser visualizados de duas maneiras: através dos diagramas de sequência e diagramas de colaboração. Este artigo apresenta os diagramas de interação da UML. Para isso, apresentará fragmentos do projeto de um sistema de vendas e controle de pagamentos.

Projeto de software é uma atividade essencial no desenvolvimento de aplicações profissionais. Neste sentido, este artigo contribui com o entendimento sobre como modelar aspectos dinâmicos de um projeto baseado no paradigma orientado a objetos. Este artigo destaca a modelagem dinâmica em projetos de software. Para isso, apresenta conceitualmente os diagramas de interação da UML, apresenta alguns exemplos práticos e demonstra como eles podem ser mapeados para código utilizando a linguagem Java.

Neste artigo iremos analisar os diagramas de interação da UML. Diagramas de interação mostram um conjunto específico de interações entre um conjunto de objetos. Neste sentido, buscaremos responder à seguinte questão: "Com o que uma chamada de método se parece na UML?"

Para isso, usaremos um sistema simples de vendas e rastreamento de pagamentos parcialmente completo para ilustrar o uso dos diagramas de sequência e colaboração. Basicamente, o sistema consiste de seis classes Java com os seguintes métodos principais:

Sale

  • calcPayments: calcula o total de todos os pagamentos feitos para a venda;
  • calcTotal: totaliza o custo de todos os itens adquiridos como parte da venda;
  • complete: marca a operação de venda como concluído.

A classe Sale apresentada na Listagem 1 é composta pelos atributos status, total e paymentsTotal, e pelos métodos calcPayments, calcTotal e complete. O construtor da classe é definido entre as linhas 5 e 15. Na sequência temos a implementação do método calcTotal entre as linhas 16 e 25. Entre as linhas 26 e 32 criamos um método de acesso para o atributo total. Já entre as linhas 33 e 42 definimos que o status da compra é igual a complete caso o valor do pagamento seja igual ao valor da compra. Feito isto, definimos entre as linhas 65 e 71 o relacionamento de agregação entre a classe Sale e a classe SaleItem. Já o relacionamento de associação entre as classes Sale e Payment é definido entre as linhas 72 e 79.

 
1.       /**
2.       One user transaction consisting of purchases of potentially many kinds of product
3.       @stereotype moment-interval
4.       */
5.        public class Sale {
6.           /**
7.           calculates the total of the sale from the lineItem subtotals
8.           @return total of the sale
9.           */
10.       public double calcPayments() {
11.          paymentsTotal = 0.0;
12.          Iterator i = payments.iterator();
13.          while (i.hasNext()) paymentsTotal += ((Payment)i.next()).getAmount();
14.          return total;
15.       }
 
16.       /**
17.       calculates the total of the sale from the lineItem subtotals
18.       @return total of the sale
19.       */
20.       public double calcTotal() {
21.         total = 0.0;
22.         Iterator i = lineItems.iterator();
23.         while (i.hasNext()) total += ((LineItem)i.next()).calcTotal();
24.         return total;
25.       }
 
26.       /**
27.       retrieves the cached total of the sale
28.       @return total of sale, 0.0 if calcTotal() has not yet been called
29.       */
30.       public double getTotal() {
31.         return total;
32.       }
 
33.       /**
34.      sets the status of the sale to complete if payments equal price
35.      @exception Exce[tion thrown if payments do not equal price
36.      */
37.       public void complete() throws Exception {
38.         if (calcTotal() != calcPayments()) {
39.         throw new Exception("Payments do not equal total price");
40.       }
41.       status = "Complete";
42.     }
 
43.     /**
44.     adds a line item for a quantity of a type of item
45.     @param product the type of item being sold
46.     @param qty the quantity of the item being sold
47.     */
48.     public void addLineItem(Product product, int qty) throws Exception {
49.       if (status.equals("Incomplete")) {
50.         lineItems.add(new LineItem(product, qty));
51.       }
52.       else {
53.        throw new Exception("Cannot add items to a completed sale");
54.       }
55.     }
 
56.     /** status of sale */
57.     private String status = "Incomplete";
 
58.     /**
59.     the cost of this quantity of the item the Product is responsible for
60.     handling quantity discounting or time based special deals, etc
61.     */
62.     private double total;
 
63.     /** the total of all the payments made for this sale */
64.     private double paymentsTotal;
 
65.     /**
66.     @link aggregation
67.     @associates <>
68.     @supplierCardinality 1..*
69.     @clientCardinality 1
70.     */
71.     private Vector lineItems = new Vector();
 
72.     /**
73.     payments of various kinds
74.     @associates <>
75.     @supplierCardinality 0..*
76.     @clientCardinality 1
77.     */
78.     private Vector payments = new Vector();
79.   }
...
Quer ler esse conteúdo completo? Seja um assinante e descubra as vantagens.
  • 473 Cursos
  • 10K Artigos
  • 100 DevCasts
  • 30 Projetos
  • 80 Guias
Tenha acesso completo