summaryrefslogtreecommitdiffstats
path: root/tde-i18n-pt_BR/docs/kdesdk/umbrello/uml_basics.docbook
blob: bba8624bafe6bcf3016b630fafa81e765aec328c (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
<chapter id="uml-basics">
<title
>Fundamentos do &UML;</title>
<sect1 id="about-uml">
<title
>Sobre o &UML;</title>
<para
>Este capítulo lhe fornecerá uma visão rápida dos fundamentos da &UML;. Tenha em mente que isto não é um tutorial detalhado sobre &UML;, mas apenas uma rápida introdução a &UML; que pode ser lida como um tutorial &UML;. Se você gostaria de aprender mais sobre a Linguagem de Modelagem Unificada, ou generalidades sobre análise e desenho de software, consulte um dos muitos livros disponíveis sobre o tópico. Existem também muitos tutoriais na Internet os quais você pode usar como ponto de partida. </para>

<para
>A Linguagem de Modelagem Unificada (Unified Modelling Language - &UML;) é uma linguagem de diagramação ou notação para especificar, visualizar e documentar modelos de sistemas de software Orientados à Objeto. A &UML; não é um método de desenvolvimento, o que significa que ela não diz para você o que fazer primeiro e em seguida ou como desenhar seu sistema, mas ele lhe auxilia a visualizar seu desenho e a comunicação entre objetos. A &UML; é controlada pelo Grupo de Gerenciamento de Objeto (Object Management Group - <acronym
>OMG</acronym
>) e é um padrão da indústria para descrever graficamente software. </para>
<para
>A &UML; é voltada para o desenho de software Orientado à Objeto e tem um uso limitado para outros paradigmas de programação. </para>
<para
>A &UML; é composta por muitos elementos de modelo que representam as diferentes partes de um sistema de software. Os elementos &UML; são usados para criar diagramas, que representam um determinada parte, ou um ponto de vista do sistema. Os seguintes tipos de diagramas são suportados pelo &umbrello;: </para>

<itemizedlist>

<listitem
><para
><emphasis
><link linkend="use-case-diagram"
>Diagrama de Caso de Uso</link
></emphasis
> mostra atores (pessoas ou outros usuários do sistema), casos de uso (os cenários onde eles usam o sistema), e seus relacionamentos</para
> </listitem>

<listitem
><para
><emphasis
><link linkend="class-diagram"
>Diagrama de Classe</link
></emphasis
> mostra classes e os relacionamentos entre elas</para
> </listitem>

<listitem
><para
><emphasis
><link linkend="sequence-diagram"
>Diagrama de Seqüência</link
></emphasis
> mostra objetos e uma seqüência das chamadas do método feitas para outros objetos.</para
> </listitem>

<listitem
><para
><emphasis
><link linkend="collaboration-diagram"
>Diagrama de Colaboração</link
></emphasis
> mostra objetos e seus relacionamentos, colocando ênfase nos objetos que participam na troca de mensagens</para>
</listitem>

<listitem
><para
><emphasis
><link linkend="state-diagram"
>Diagrama de Estado</link
></emphasis
> mostra estados, mudanças de estado e eventos num objeto ou uma parte do sistema</para
> </listitem>

<listitem
><para
><emphasis
><link linkend="activity-diagram"
>Diagrama de Atividade</link
></emphasis
> mostra atividades e as mudanças de uma atividade para outra com os eventos ocorridos em alguma parte do sistema</para
></listitem>

<listitem
><para
><emphasis
><link linkend="component-diagram"
>Diagrama de Componente</link
></emphasis
> mostra os componentes de programação de alto nível (como KParts ou Java Beans).</para
></listitem>

<listitem
><para
><emphasis
><link linkend="deployment-diagram"
>Diagrama de Distribuição</link
></emphasis
> mostra as instâncias dos componentes e seus relacionamentos.</para
></listitem
> 

</itemizedlist>

</sect1
>   <!-- about-uml -->

<sect1 id="uml-elements"
>  
<title
>Elementos &UML;</title>
<sect2 id="use-case-diagram">
<title
>Diagrama de Caso de Uso</title>
<para
>Diagramas de Caso de Uso descrevem relacionamentos e dependências entre um grupo de <emphasis
>Caso de Uso</emphasis
> e os Atores participantes no processo.</para>
<para
>É importante observar que Diagramas de Caso de Uso não são adequados para representar o desenho, e não podem descrever os mecanismos internos de um sistema. Diagramas de Caso de Uso são feitos para facilitar a comunicação com os futuros usuários do sistema, e com o cliente, e são especialmente úteis para determinar os recursos necessários que o sistema deve ter. Diagramas de Caso de Uso dizem <emphasis
>o quê</emphasis
> o sistema deve fazer, mas não fazem &mdash; e não podem &mdash; especificar <emphasis
>como</emphasis
> isto será conseguido.</para>
<para>
<screenshot>
<screeninfo
>Um exemplo de Diagrama de Caso de Uso.</screeninfo>
	<mediaobject>
	  <imageobject>
	    <imagedata fileref="use-case-diagram.png" format="PNG"/>
	  </imageobject>
	  <textobject>
	    <phrase
>O &umbrello; mostrando um Diagrama de Caso de Uso</phrase>
	  </textobject>
	  <caption>
	    <para
>O &umbrello; mostrando um Diagrama de Caso de Uso </para>
	  </caption>
	</mediaobject>
</screenshot>
</para>
<sect3 id="use-case">
<title
>Caso de Uso</title>
<para
>Um <emphasis
>Caso de Uso</emphasis
> descreve &mdash; do ponto de vista dos atores &mdash; um grupo de atividades num sistema que produz um resultado concreto e tangível.</para>
<para
>Casos de Uso são descrições de interações típicas entre os usuários de um sistema e o sistema propriamente dito. Eles representam a interface externa do sistema e especificam um conjunto de exigências do que o sistema deve fazer (lembre-se: somente o quê, não como). </para>
<para
>Quando trabalhar com Casos de Uso, é importante lembrar-se de algumas regras simples: <itemizedlist>
 <listitem
><para
>Cada Caso de Uso está relacionado com no mínimo um ator</para
></listitem>
 <listitem
><para
>Cada Caso de Uso possui um iniciador (&ie; um ator)</para
></listitem>
 <listitem
><para
>Cada Caso de Uso liga-se a um resultado relevante (um resultado com <quote
>valor de negócio</quote
>)</para>
 </listitem>
 </itemizedlist>
</para>
<para
>Casos de Uso também podem ter relacionamentos com outros Casos de Uso. Os três tipos mais comuns de relacionamento entre Casos de Uso são:</para>
<itemizedlist>
<listitem
><para
><emphasis
>&lt;&lt;inclui-se&gt;&gt;</emphasis
> que especifica que um Caso de Uso toma lugar <emphasis
>dentro</emphasis
> de outro Caso de Uso</para
></listitem>
<listitem
><para
><emphasis
>&lt;&lt;estende&gt;&gt;</emphasis
> que especifica que em determinadas situações, ou em algum ponto (chamado um ponto de extensão) um Caso de Uso será estendido por outro.</para
></listitem>
<listitem
><para
><emphasis
>Generalização</emphasis
> especifica que um Caso de Uso herda as características do <quote
>Super</quote
> Caso de Uso, e pode sobrepor algumas delas ou adicionar novas de maneira semelhante a herança entre classes. </para>
</listitem>
</itemizedlist>
</sect3>
<sect3 id="actor">
<title
>Ator</title>
<para
>Um ator é uma entidade externa (fora do sistema) que interage com o sistema participando (e freqüentemente iniciando) um Caso de Uso. Atores podem ser pessoas reais (por exemplo usuários do sistema), outro sistema de computador ou eventos externos. </para>
<para
>Atores não representam as pessoa <emphasis
>física</emphasis
> ou sistemas, mas sua <emphasis
>regra</emphasis
>. Isto significa que quando uma pessoa interage com o sistema de diferentes maneiras (assumindo diferentes regras) ela será representada por diversos atores. Por exemplo um pessoa que fornece suporte ao cliente por telefone e recebe ordens do cliente para o sistema pode ser representado por um ator da <quote
>Equipe de Suporte</quote
> e um ator <quote
>Representante de Vendas</quote
> </para>
</sect3>
<sect3 id="use-case-description">
<title
>Descrição do Caso de Uso</title>
<para
>Descrição do Caso de Uso são narrativas de texto do Caso de Uso. Elas usualmente tomam a forma de uma nota ou um documento que é de alguma maneira ligado ao Caso de Uso, e explana o processo ou atividades que tomarão lugar no Caso de Uso. </para>
</sect3>
</sect2
> <!-- use-case-diagram -->

<sect2 id="class-diagram">
<title
>Diagrama de Classe</title>
<para
>Diagramas de Classe mostram as diferentes classes que fazem um sistema e como elas se relacionam. Os Diagramas de Classe são chamados diagramas <quote
>estáticos</quote
> porque mostram as classes, com seus métodos e atributos bem como os relacionamentos estáticos entre elas: quais classes <quote
>conhecem</quote
> quais classes ou quais classes <quote
>são parte</quote
> de outras classes, mas não mostram a troca de mensagens entre elas. </para>
<para>
<screenshot>
<screeninfo
>Um exemplo de um Diagrama de Classe</screeninfo>
	<mediaobject>
	  <imageobject>
	    <imagedata fileref="class-diagram.png" format="PNG"/>
	  </imageobject>
	  <textobject>
	    <phrase
>O &umbrello; mostrando um Diagrama de Classe</phrase>
	  </textobject>
	  <caption>
	    <para
>O &umbrello; mostrando um Diagrama de Classe </para>
	  </caption>
	</mediaobject>
</screenshot>
</para>
<sect3 id="class">
<title
>Classe</title>
<para
>Um Classe define os atributos e os métodos de um conjunto de objetos. Todos os objetos desta classe (instâncias desta classe) compartilham o mesmo comportamento, e possuem o mesmo conjunto de atributos (cada objeto possui seu próprio conjunto). O termo <quote
>Tipo</quote
> é algumas vezes usado ao invés de Classe, mas é importante mencionar que estes dois termos não são a mesma coisa, e Tipo é um termo mais genérico. </para>
<para
>Em &UML; Classes são representadas por retângulos, com o nome da classe, e podem também mostrar os atributos e operações da classe em dois outros <quote
>compartimentos</quote
> dentro do retângulo. </para>
<para>
<screenshot>
<screeninfo
>Uma Classe em &UML;</screeninfo>
	<mediaobject>
	  <imageobject>
	    <imagedata fileref="class.png" format="PNG"/>
	  </imageobject>
	  <textobject>
	    <phrase
>Representação visual de uma Classe em &UML;</phrase>
	  </textobject>
	  <caption>
	    <para
>Representação visual de uma Classe em &UML; </para>
	  </caption>
	</mediaobject>
</screenshot>
</para>
<sect4 id="attribute">
<title
>Atributos</title>
<para
>Na &UML;, atributos são mostrados com pelo menos seu nome, e podem também mostrar seu tipo, valor inicial e outras propriedades. Atributos podem também ser exibidos com sua visibilidade: </para>
<itemizedlist>
<listitem
><para
><literal
>+</literal
> indica atributos <emphasis
>públicos</emphasis
></para
></listitem>
<listitem
><para
><literal
>#</literal
> indica atributos <emphasis
>protegidos</emphasis
></para
></listitem>
<listitem
><para
><literal
>-</literal
> indica atributos <emphasis
>privados</emphasis
></para
></listitem>
</itemizedlist>
</sect4>
<sect4 id="operation">
<title
>Operações</title>
<para
>Operações (métodos) também são exibidos com pelo menos seu nome, e podem também mostrar seus parâmetros e valores de retorno. Operações podem, como os Atributos, mostras sua visibilidade: <itemizedlist>
<listitem
><para
><literal
>+</literal
> indica operações <emphasis
>públicas</emphasis
></para
></listitem>
<listitem
><para
><literal
>#</literal
> indica operações <emphasis
>protegidas</emphasis
></para
></listitem>
<listitem
><para
><literal
>-</literal
> indica operações <emphasis
>privadas</emphasis
></para
></listitem>
</itemizedlist>
</para>
</sect4>

<sect4 id="templates">
<title
>Modelos</title>
<para
>Classes podem ter modelos, um valor que é usado para uma classe ou tipo não especificado. O tipo de modelo é especificado quando uma classe é iniciada (&ie; um objeto é criado). Modelos existem no C++ moderno e foram introduzidos no Java 1.5 onde eles são chamados de Genéricos. </para>
</sect4>
</sect3>

<sect3 id="class-associations">
<title
>Associações de Classe</title>
<para
>Classes podem relacionar-se (ser associada com) com outras de diferentes maneiras:</para>
<sect4 id="generalization">
<title
>Generalização</title>
<para
>Herança é um dos conceitos fundamentais da programação Orientada à Objeto, na qual uma classe <quote
>herda</quote
> todos os atributos e operações da classe da qual deriva, e pode sobrescrever/modificar alguns deles, bem como adicionar mais atributos e operações próprios.</para>
<para
>EM &UML;, uma associação <emphasis
>Generalização</emphasis
> entre duas classes coloca-as numa hierarquia representando o conceito de herança de uma classe derivada de uma classe base. Em &UML;, Generalizações são representadas por uma linha conectando duas classes, com uma seta no lado da classe base. <screenshot>
<screeninfo
>Generalização</screeninfo>
	<mediaobject>
	  <imageobject>
	    <imagedata fileref="generalization.png" format="PNG"/>
	  </imageobject>
	  <textobject>
	    <phrase
>Representação visual de uma generalização em &UML;</phrase>
	  </textobject>
	  <caption>
	    <para
>Representação visual de uma generalização em &UML; </para>
	  </caption>
	</mediaobject>
</screenshot>
</para>
</sect4>

<sect4 id="uml-associations">
<title
>Associações</title>
<para
>Um associação representa um relacionamento entre classes, e fornece a semântica comum e a estrutura para muitos tipos de <quote
>conexões</quote
> entre objetos.</para>
<para
>Associações são o mecanismo que permite objetos comunicarem-se entre si. Elas descrevem a conexão entre diferentes classes (a conexão entre os objetos atuais é chamada conexão do objeto, ou <emphasis
>link</emphasis
>. </para>
<para
>Associações podem ter um regra que especifica o propósito da associação e pode ser uni ou bidirecional (indicadando se os dois objetos participantes do relacionamento podem mandar mensagens para o outro, ou se apenas um deles sabe sobre o outro). Cada ponta da associação também possui uma valor de multiplicidade, que dita como muitos objetos neste lado da associação pode relacionar-se com o outro lado. </para>
<para
>Em &UML;, associações são representadas como linhas conectando as classes participantes do relacionamento, e podem também mostrar a regra e a multiplicidade de cada um dos participantes. A multiplicidade é exibida como um intervalo [min...máx] de valores não negativos, com uma estrela (<literal
>*</literal
>) no lado máximo representando infinito. <screenshot>
<screeninfo
>Associação &UML;</screeninfo>
	<mediaobject>
	  <imageobject>
	    <imagedata fileref="association.png" format="PNG"/>
	  </imageobject>
	  <textobject>
	    <phrase
>Representação visual de uma Associação em &UML;</phrase>
	  </textobject>
	  <caption>
	    <para
>Representação visual de uma Associação em &UML; </para>
	  </caption>
	</mediaobject>
</screenshot>
</para>
</sect4>

<sect4 id="aggregation">
<title
>Agregação</title>
<para
>Agregações são um tipo especial de associação no qual as duas classes participantes não possuem em nível igual, mas fazem um relacionamento <quote
>todo-parte</quote
>. Uma Agregação descreve como a classe que possui a regra do todo, é composta (tem) de outras classes, que possuem a regra das partes. Para Agregações, a classe que age como o todo sempre tem uma multiplicidade de um. </para>
<para
>Em &UML;, Agregações são representadas por uma associação que mostra um rombóide no lado do todo. <screenshot>
<screeninfo
>Agregação</screeninfo>
	<mediaobject>
	  <imageobject>
	    <imagedata fileref="aggregation.png" format="PNG"/>
	  </imageobject>
	  <textobject>
	    <phrase
>Representação visual de um relacionamento Agregação em &UML;</phrase>
	  </textobject>
	  <caption>
	    <para
>Representação visual de um relacionamento Agregação em &UML; </para>
	  </caption>
	</mediaobject>
</screenshot>
</para>
</sect4>
<sect4 id="composition">
<title
>Composição</title>
<para
>Composições são associações que representam agregações <emphasis
>muito fortes</emphasis
>. Isto significa que Composições formam relacionamentos todo-parte também, mas o relacionamento é tão forte que as partes não pode existir independentes. Elas existem somente dentro do todo, e se o todo é destruído as partes morrem também.</para>
<para
>Em &UML;, Composições são representadas por um rombóide sólido no lado do todo. </para>
<para
><screenshot>
<screeninfo
>Composição</screeninfo>
	<mediaobject>
	  <imageobject>
	    <imagedata fileref="composition.png" format="PNG"/>
	  </imageobject>
	  <textobject>
	    <phrase
>Representação visual de um relacionamento Composição em &UML;</phrase>
	  </textobject>
	</mediaobject>
</screenshot
></para>
</sect4>
</sect3
> <!--class-associations-->

<sect3 id="other-class-diagram-items">
<title
>Outros Ítens do Diagrama de Classe</title>
<para
>Diagramas de Classe podem conter diversos outros ítens além das classes.</para>
<sect4 id="interfaces">
<title
>Interfaces</title>
<para
>Interfaces são classes abstratas que significam instâncias que não podem ser diretamente criadas delas. Elas podem conter operações mas não podem conter atributos. Classes podem derivar de interfaces (através da realização de uma associação) e instâncias podem então ser feitas destes diagramas.</para>
<!-- FIXME screenshot -->
</sect4>
<sect4 id="datatype">
<title
>Tipos de dados</title>
<para
>Tipos de dados são primitivos uma vez que são tipicamente construídos numa linguagem de programação. Exemplos comuns são inteiros e lógicos. Eles não podem ser relacionados à classes mas classes pode se relacionar com eles.</para>
<!-- FIXME screenshot -->
</sect4>
<sect4 id="enum">
<title
>Enumerações</title>
<para
>Enumerações são uma lista simples de valores. Um exemplo típico é uma enumeração para dias da semana. As opções de uma enumeração são chamadas Literais de Enumeração. Como tipos de dados, elas não podem ter relacionamentos para classes mas classes podem relacionar-se com elas.</para>
<!-- FIXME screenshot -->
</sect4>
<sect4 id="package">
<title
>Pacotes</title>
<para
>Pacotes representam um espaço de nomes numa linguagem de programação. Num diagrama eles são usados para representar partes de um sistema que contém mais de uma classe, talvez centenas de classes.</para>
<!-- FIXME screenshot -->
</sect4>
</sect3>

</sect2
> <!-- class diagram -->

<sect2 id="sequence-diagram">
<title
>Diagramas de Seqüência</title>

<para
>Diagramas de Seqüência mostram a troca de mensagens (&ie; chamada de método) entre diversos Objetos, numa situação específica e delimitada no tempo. Objetos são instâncias de classes. Diagramas de Seqüência colocam ênfase especial na ordem e nos momentos nos quais mensagens para os objetos são enviadas.</para>

<para
>Em Diagramas de Seqüência objetos são representados através de linhas verticais tracejadas, com o nome do Objeto no topo. O eixo do tempo é também vertical, aumentando para baixo, de modo que as mensagens são enviadas de um Objeto para outro na forma de setas com a operação e os nomes dos parâmetros. </para>

<!-- FIXME update screenshot to show synchronous messages -->
<screenshot>
<screeninfo
>Diagrama de Seqüência</screeninfo>
	<mediaobject>
	  <imageobject>
	    <imagedata fileref="sequence-diagram.png" format="PNG"/>
	  </imageobject>
	  <textobject>
	    <phrase
>O &umbrello; mostrando um Diagrama de Seqüência</phrase>
	  </textobject>
	  <caption>
	    <para
>O &umbrello; mostrando um Diagrama de Seqüência </para>
	  </caption>
	</mediaobject>
</screenshot>

<para
>Mensagens pode ser síncronas, o tipo normal de mensagem de chamada onde o controle é passado para o objeto chamado até o método ter terminado sua execução, ou assíncronas onde o controle é passado diretamente para o objeto chamado. Mensagens síncronas possui uma caixa vertical no lado do objeto chamado para mostrar o controle do fluxo do programa.</para>
</sect2
> <!-- sequence diagrams -->

<sect2 id="collaboration-diagram">
<title
>Diagramas de Colaboração</title>

<para
>Diagramas de Colaboração mostram as interações que ocorrem entre os objetos participantes numa situação específica. Isto é mais ou menos a mesma informação mostrada pelos Diagramas de Seqüência, mas neste a ênfase é colocada em como as interações ocorrem no tempo, enquanto os Diagramas de Colaboração colocam os relacionamentos entre os objetos e sua topologia em destaque.</para>

<para
>Em Diagramas de Colaboração as mensagens enviadas de um objeto para outro são representadas por setas, mostrando o nome da mensagem, parâmetros, e a seqüência da mensagem. Diagramas de Colaboração são especialmente indicados para mostrar um fluxo ou situação específica do programa e são um dos melhores tipos de diagrama para rapidamente demonstrar ou explanar um processo na lógica do programa. </para>

<screenshot>
<screeninfo
>Colaboração</screeninfo>
	<mediaobject>
	  <imageobject>
	    <imagedata fileref="collaboration-diagram.png" format="PNG"/>
	  </imageobject>
	  <textobject>
	    <phrase
>O &umbrello; mostrando um Diagrama de Colaboração</phrase>
	  </textobject>
	  <caption>
	    <para
>O &umbrello; mostrando um Diagrama de Colaboração </para>
	  </caption>
	</mediaobject>
</screenshot>

</sect2
> <!-- collaboration diagrams -->

<sect2 id="state-diagram">
<title
>Diagrama de Estado</title>
<para
>Diagramas de Estado mostram os diferentes estados de um Objeto durante sua vida, e o estímulo que faz com que o Objeto mude seu estado. </para
>                              
<para
>Diagramas de Estado vêem Objetos como <emphasis
>máquinas de estado</emphasis
> ou automatismos finitos que podem ser um de um conjunto de estados finitos e que podem mudar seu estado através de um de um conjunto finito de estímulos. Por exemplo um tipo de Objeto <emphasis
>ServidorRede</emphasis
> pode estar em um dos seguintes estados durante sua vida: </para>
<itemizedlist>
<listitem
><para
>Pronto</para
></listitem>
<listitem
><para
>Ouvindo</para
></listitem>
<listitem
><para
>Trabalhando</para
></listitem>
<listitem
><para
>Parado</para
></listitem>
</itemizedlist>
<para
>e os eventos que podem fazer com que o Objeto mude de estado são</para>
<itemizedlist>
<listitem
><para
>Objeto é criado</para
></listitem>
<listitem
><para
>Objeto recebe mensagem ouvir</para
></listitem>
<listitem
><para
>Um Cliente solicita uma conexão através da rede</para
></listitem>
<listitem
><para
>Um Cliente termina um pedido</para
></listitem>
<listitem
><para
>O pedido é executado e terminado</para
></listitem>
<listitem
><para
>Objeto recebe mensagem parar</para
></listitem>
<listitem
><para
>etc</para
></listitem>
</itemizedlist>
<para>
<screenshot>
<screeninfo
>Diagrama de Estado</screeninfo>
	<mediaobject>
	  <imageobject>
	    <imagedata fileref="state-diagram.png" format="PNG"/>
	  </imageobject>
	  <textobject>
	    <phrase
>O &umbrello; mostrando um Diagrama de Estado</phrase>
	  </textobject>
	  <caption>
	    <para
>O &umbrello; mostrando um Diagrama de Estado </para>
	  </caption>
	</mediaobject>
</screenshot>
</para>
<sect3 id="state">
<title
>Estado</title>
<para
>Estados são os blocos construídos dos Diagramas de Estado. Um Estado pertence a exatamente uma classe e representa um resumo dos valores dos atributos que uma classe pode tomar. Um Estado &UML; descreve o estado interno de um objeto para uma classe em particular </para
>                       
<para
>Observe que nem toda mudança em um dos atributos de um objeto pode ser representada por um Estado mas somente aquelas mudanças que podem afetar significativamente o trabalho do objeto</para>
<para
>Existem dois tipos especiais de Estados: Inicial e Final. Eles são especiais porque nenhum evento pode fazer com que um Objeto retorne para seu estado Inicial, e da mesma maneira nenhum evento pode tirar um Objeto de seu estado Final uma vez que ele já o tenha alcançado. </para>
</sect3>

</sect2
> <!-- state diagrams -->

<sect2 id="activity-diagram">
<title
>Diagrama de Atividade</title>
<para
>O Diagrama de Atividade descreve a seqüência de atividades num sistema com a ajuda as Atividades. Diagramas de Atividade são uma forma especial de Diagramas de Estado, que somente (ou principalmente) contém Atividades. </para>
<para>
<screenshot>
<screeninfo
>Um exemplo de um Diagrama de Atividade.</screeninfo>
	<mediaobject>
	  <imageobject>
	    <imagedata fileref="activity-diagram.png" format="PNG"/>
	  </imageobject>
	  <textobject>
	    <phrase
>O &umbrello; mostrando um Diagrama de Atividade</phrase>
	  </textobject>
	  <caption>
	    <para
>O &umbrello; mostrando um Diagrama de Atividade </para>
	  </caption>
	</mediaobject>
</screenshot>
</para>
<para
>Diagramas de Atividade são similares as Diagramas de Fluxo de procedimentos, com a diferença de que todas as Atividades são claramente anexas aos Objetos.</para>

<para
>Diagramas de Atividade são sempre associados a um <emphasis
>Classe</emphasis
>, uma <emphasis
>Operação</emphasis
> ou um <emphasis
>Caso de Uso</emphasis
>.</para>

<para
>Diagramas de Atividade suportam Atividades seqüenciais bem como paralelas. A execução paralela é representada pelos ícones Forquilha/Esperar, e para as Atividades executadas em paralelo, não é importante a ordem na qual elas se executam (elas podem ser executadas ao mesmo tempo ou uma após a outra).</para>
<sect3 id="activity">
<title
>Atividade</title>
<para
>Uma Atividade é um passo simples num processo. Uma Atividade é um estado no sistema com atividade interna e, pelo menos, uma transição de saída. Atividades podem também ter mais de uma transição de saída se elas possuem condições diferentes. </para
> 
<para
>Atividades podem formar hierarquias, isto significa que uma Atividade pode ser composta por diversas Atividades em <quote
>detalhe</quote
>, na qual as transições de entrada e saída devem corresponder às transições de entrada e saída do diagrama de detalhe. </para>

</sect3>
</sect2
> <!-- activity diagram -->

<sect2 id="helper-elements">
<title
>Elementos Auxiliares</title>
<para
>Existem dois elementos em &UML; que não possuem nenhum valor real semântico para o modelo, mas auxiliam a elucidar partes do diagrama. Estes elementos são </para>
<itemizedlist>
<listitem
><para
>Linhas de texto</para
></listitem>
<listitem
><para
>Notas de Texto e âncoras</para
></listitem>
<listitem
><para
>Caixas</para
></listitem>
</itemizedlist
>   
<para
>Linhas de texto são úteis para adicionar informações curtas de texto ao diagrama. São textos livres e não possuem nenhum significado para o Modelo propriamente dito. </para
>           

<para
>Notas são úteis para adicionar informações mais detalhadas sobre um objeto ou situação específica. Elas possuem a grande vantagem de poderem ser ancoradas a Elementos &UML; para mostrar que a nota <quote
>pertence</quote
> a um objeto específico ou situação. </para>

<para
>Caixas são retângulos de forma livre que podem ser usados para agrupar ítens tornando os diagramas mais legíveis. Eles não possuem nenhum significado lógico no modelo.</para>

<!-- FIXME, screenshot -->
</sect2
> <!-- helper elements -->

<sect2 id="component-diagram">
<title
>Diagramas de Componente</title>
<para
>Diagramas de Componente mostram os componentes do software (sejam componentes de tecnologias como KParts, componentes CORBA ou Java Beans ou apenas seções do sistema que são claramente distintas) e os artefatos de que eles são feitos como arquivos de código fonte, bibliotecas de programação ou tabelas de bancos de dados relacionais.</para>

<para
>Componentes pode possui interfaces (&ie; classes abstratas com operações) que permitem associações entre componentes.</para>
</sect2>

<sect2 id="deployment-diagram">
<title
>Diagramas de Distribuição</title>

<para
>Diagramas de distribuição mostram as instâncias dos componentes de tempo de execução e suas associações. Eles incluem Nós que são recursos físicos, tipicamente um computador simples. Eles também mostram interfaces e objetos (instâncias da classe).</para>

</sect2>

</sect1
> 
</chapter>