[ Pobierz całość w formacie PDF ]
IDZ DO
PRZYK£ADOW
Zrozumieæ UML 2.0.
SPIS TREŒCI
Metody modelowania
KATALOG KSI¥¯EK
obiektowego
KATALOG ONLINE
Autor: Micha³ œmia³ek
ISBN: 83-7361-918-6
Format: B5, stron: 296
ZAMÓW DRUKOWANY KATALOG
TWÓJ KOSZYK
Usprawnij proces tworzenia oprogramowania, stosuj¹c modelowanie w jêzyku UML
Poznaj podstawy modelowania obiektowego
Zamodeluj œrodowisko, wymagania i architekturê systemu
Zaprojektuj system w oparciu o model UML
Tworzenie z³o¿onego systemu informatycznego wymaga przygotowania projektu.
Nale¿y okreœliæ w nim œrodowisko dzia³ania systemu, wymagania u¿ytkowników,
procesy realizowane przez system i jego elementy sk³adowe. Opis s³owny, przydatny
w trakcie zbierania za³o¿eñ funkcjonalnych, mo¿e okazaæ siê zbyt skomplikowany
i niejednoznaczny na pozosta³ych etapach opisywania powstaj¹cego systemu.
Niezbêdny jest taki sposób opisu, który by³by jednakowo interpretowany i zrozumia³y
dla wszystkich cz³onków zespo³u projektowego. W tym celu opracowano jêzyk UML
— notacjê umo¿liwiaj¹c¹ zamodelowanie systemu w sposób graficzny, w postaci
diagramów. Modele zapisane w jêzyku UML s¹ jednakowo interpretowane przez
wszystkie osoby zaanga¿owane w dany projekt. S¹ te¿ niezwykle uniwersalne.
Mo¿na je stosowaæ we wszystkich fazach projektowania i budowy oprogramowania.
Ksi¹¿ka „Zrozumieæ UML 2.0. Metody modelowania obiektowego” to podrêcznik
modelowania systemów informatycznych z wykorzystaniem notacji UML 2.0.
Przedstawia podstawy modelowania obiektowego i najwa¿niejsze pojêcia zwi¹zane
z obiektowoœci¹. Opisuje sposoby modelowania otoczenia systemu, jego zakresu
funkcjonalnego oraz struktury. W ksi¹¿ce opisano równie¿ proces przejœcia z modelu
do kodu Ÿród³owego systemu oraz metodyki projektowe oparte na jêzyku UML.
Ka¿dy, kto bierze udzia³ w procesie wytwarzania oprogramowania, znajdzie w tej
ksi¹¿ce przydatne dla siebie informacje.
Zasady modelowania obiektowego
Formu³owanie i realizacja wymagañ
Modelowanie otoczenia systemu oraz jego funkcjonalnoœci
Projektowanie architektury systemu
Realizacja systemu w oparciu o projekt
Metodyki wytwarzania oprogramowania
Przekonaj siê, jak bardzo UML mo¿e u³atwiæ proces tworzenia oprogramowania
DODAJ DO KOSZYKA
CENNIK I INFORMACJE
ZAMÓW INFORMACJE
ONOWOŒCIACH
ZAMÓW CENNIK
CZYTELNIA
FRAGMENTY KSI¥¯EK ONLINE
Wydawnictwo Helion
ul. Chopina 6
44-100 Gliwice
tel. (32)230-98-63
e-mail: helion@helion.pl
Spis treści
Rozdział 1. Wstęp .............................................................................................. 5
1.1. Czym jest ta książka? ................................................................................................ 5
1.2. Dla kogo jest ta książka? ........................................................................................... 6
1.3. Dlaczego modelowanie? ............................................................................................ 7
1.4. Dlaczego język UML? ............................................................................................... 8
1.5. Co dalej w książce? ................................................................................................... 9
1.6. Oznaczenia typograficzne ........................................................................................ 12
1.7. Podziękowania ........................................................................................................ 13
Rozdział 2. Wprowadzenie do modelowania ....................................................... 15
2.1. Trudna sztuka modelowania .................................................................................... 15
2.2. Złożoność oprogramowania. Jak ją pokonać? ......................................................... 17
2.3. Metodyka wytwarzania oprogramowania ................................................................ 20
Rozdział 3. Podstawy modelowania obiektowego .............................................. 25
3.1. Jak modelować świat obiektowo? ........................................................................... 25
3.2. Obiekty .................................................................................................................... 27
3.3. Klasy obiektów ........................................................................................................ 32
3.4. Modelowanie struktury ............................................................................................ 37
3.5. Modelowanie dynamiki ........................................................................................... 43
3.6. Które modele muszę dobrze poznać? ..................................................................... 50
Rozdział 4. Od opisu środowiska do kodu .......................................................... 53
4.1. Jak zapewnić zgodność kodu ze środowiskiem? ..................................................... 53
4.2. Ścieżka od opisu środowiska do kodu ..................................................................... 57
4.3. Tworzenie systemów sterowane modelami ........................................................... 60
4.4. Formułowanie wymagań ......................................................................................... 63
4.5. Realizacja wymagań ................................................................................................ 65
4.6. Modele, narzędzia, jakość ....................................................................................... 67
Rozdział 5. Modelowanie środowiska ................................................................ 71
5.1. Jak opisać środowisko? ........................................................................................... 71
5.2. Struktura — aktorzy, jednostki organizacyjne i pojęcia .......................................... 77
5.3. Dynamika — procesy, czynności i stany ................................................................. 87
5.4. Spójność modeli środowiska ................................................................................. 100
5.5. Przykładowe problemy .......................................................................................... 102
4
Zrozumieć UML 2.0. Metody modelowania obiektowego
Rozdział 6. Modelowanie wymagań ................................................................. 105
6.1. Jak określić zakres funkcjonalny systemu oprogramowania? ................................ 105
6.2. Struktura — aktorzy, klasy .................................................................................... 108
6.3. Dynamika — przypadki użycia, scenariusze, czynności, stany ............................. 124
6.4. Spójność modelu wymagań i zgodność ze środowiskiem ..................................... 145
6.5. Przykładowe problemy .......................................................................................... 148
Rozdział 7. Tworzenie architektury .................................................................. 151
7.1. Co to jest i z czego się składa architektura systemu oprogramowania? ................. 151
7.2. Struktura — komponenty, interfejsy, klasy, węzły ................................................ 155
7.3. Dynamika — interakcje, czynności ....................................................................... 177
7.4. Spójność architektury i zgodność z wymaganiami ................................................ 189
7.5. Przykładowe problemy .......................................................................................... 193
Rozdział 8. Projektowanie i realizacja systemu ................................................ 195
8.1. Jak stworzyć szczegółowy projekt systemu? ......................................................... 195
8.2. Struktura — interfejsy, klasy ................................................................................. 197
8.3. Dynamika — interakcje, czynności ....................................................................... 205
8.4. Spójność projektu i zgodność z architekturą ......................................................... 219
8.5. Przykładowe problemy .......................................................................................... 222
Rozdział 9. Modelowanie w procesie wytwórczym ........................................... 225
9.1. Nowoczesne metodyki wytwarzania oprogramowania .......................................... 225
9.2. Proces techniczny oparty na modelach w języku UML ......................................... 232
9.3. Podsumowanie: czy modelowanie to „srebrna kula”? ........................................... 239
Dodatek A Podsumowanie składni języka UML 2.0 ......................................... 241
Dodatek B Organizacja modeli w narzędziu CASE ............................................ 259
Dodatek C Krótki słownik metod obiektowych i języka UML ............................ 267
Literatura ..................................................................................... 287
Skorowidz ..................................................................................... 295
Rozdział 3.
Podstawy modelowania
obiektowego
3.1. Jak modelować świat obiektowo?
Z poprzedniego rozdziału wiemy, że system oprogramowania powinien być jak naj-
wierniejszym modelem otaczającego świata. Powstaje zatem pytanie, w jaki sposób
skonstruować ten model, aby spełniał to podstawowe wymaganie wierności? Mamy
bowiem do czynienia z dwoma różnymi punktami widzenia na oprogramowanie. Z jednej
strony stoją zamawiający, którzy mają pewne wymagania w stosunku do systemu. Z dru-
giej strony mamy programistów, którzy wiedzą, jak konstruować systemy. Zamawiający
znają dziedzinę problemu i potrafią o niej opowiadać za pomocą specjalistycznego
słownictwa. Nie są to zazwyczaj osoby skłonne do czytania, a tym bardziej tworzenia,
technicznych opisów systemu. Zamawiający chcą opisać system w sposób jak najprostszy
i jak najbardziej zrozumiały w kontekście swoich codziennych obowiązków. Wynika
to oczywiście z tego, że system powinien im pomagać w pracy, którą wykonują. Z drugiej
strony programiści tworzą system z bardzo precyzyjnych konstrukcji odpowiedniego
języka programowania. Są oni najczęściej dokładnie zorientowani w szczegółach plat-
formy sprzętowej lub programowej, czy też w niuansach określonej biblioteki kodu.
Nie są natomiast zazwyczaj ekspertami w dziedzinie, dla której tworzą system. Ich
słownictwo jest zasadniczo różne od słownictwa zamawiających. Wymagają zatem
bardzo dokładnego opisu sposobu konstrukcji systemu.
Żeby było jeszcze trudniej, zarówno zamawiający, jak i programiści muszą panować
nad systemem, który zwykle składa się z tysięcy różnych wymagań, dziesiątków mo-
dułów czy setek tysięcy wierszy kodu. Podkreślaliśmy to już w poprzednim rozdziale.
Jak zatem pogodzić sprzeczne spojrzenia zamawiających i programistów? Jak zapano-
wać nad złożonością problemu? Czy istnieje jakaś możliwość porozumienia? Czytelnik
zapewne już się domyśla, że sposobem na wzajemne zrozumienie, który będziemy chcieli
zaproponować w tej książce, jest modelowanie za pomocą technik obiektowych.
26
Zrozumieć UML 2.0. Metody modelowania obiektowego
Elementem, który w modelowaniu obiektowym pozwala pogodzić język użytkownika
z językiem programisty oraz pokonać problem złożoności systemu, jest obiekt. Obiekty
znajdujące się w środowisku ustalają wspólny język w zespole odpowiedzialnym za
powstanie systemu oprogramowania (rysunek 3.1). Z jednej strony obiekty odpowiadają
pojęciom z modelowanej dziedziny problemu. Z drugiej strony są podstawą imple-
mentacji realizowanego systemu. Jest to możliwe dzięki istnieniu obiektowych języków
programowania. Obiekty umożliwiają realizację zasady abstrakcji, gdyż mogą repre-
zentować skomplikowane struktury (składające się z wielu elementów, które znowu
składają się z wielu elementów itd.). Dzięki temu obiekty na danym poziomie abstrakcji
ukrywają informacje nieistotne dla czytelnika modelu. Obiekty są zatem pewnego rodzaju
czarnymi skrzynkami (rysunek 3.7). Dopiero po otwarciu takiej czarnej skrzynki i wejściu
w głąb odkrywamy dalsze szczegóły.
Rysunek 3.1.
Obiekty — wspólny
język dla różnych
ról projektowych
„modelarz”
zamawiający
programista
Na bazie obiektów powstają obiektowe →
modele
(ang.
model
), czyli — tak jak już
mówiliśmy w poprzednim rozdziale — kopie rzeczywistych systemów. →
Modelowanie
obiektowe
(ang.
object modeling
) polega zatem na:
znajdowaniu obiektów w otoczeniu,
opisywaniu struktury i dynamiki działania obiektów,
klasyfikacji obiektów,
opisywaniu struktury powiązań klas obiektów oraz
opisywaniu dynamiki współpracy obiektów podczas funkcjonowania systemu.
Możemy też powiedzieć, że modelowanie obiektowe polega na rysowaniu diagramów
opisujących strukturę i dynamikę systemu składającego się z obiektów. Diagramy ukazują
system na różnym poziomie abstrakcji.
Modele obiektowe będziemy tworzyć za pomocą jednolitej notacji. Będzie nią graficzny
język UML. W rozdziale przedstawimy podstawowe pojęcia modelowania obiektowego
i ich notację w języku UML: obiekty, klasy, diagramy opisu struktury i diagramy opisu
dynamiki. Będzie to podstawowy język porozumiewania się. Zostanie on wykorzystany
i rozbudowany w następnych rozdziałach do ustanowienia ścieżki od wymagań do kodu.
[ Pobierz całość w formacie PDF ]