TO BE TEXT UNDER THIS :
Hi, my name’s Chloe and I’ll be teaching you everything you need to know about UML Use Case diagrams. We’ll start with a high-level overview. Then we’ll talk about Systems, Actors, Use Cases, and Relationships. And finally, we’ll build an entire use case diagram together and go over examples to explain all these concepts in depth. Have you ever had an idea that makes perfect sense in your head, but when you try to explain it to someone else they’re completely lost? Maybe your idea is for a new app, and every time you talk about it people don’t really understand how they’d interact with the app or what it would do. This type of scenario is where a Use Case diagram is very helpful. Here’s a simple description of a Use Case diagram.
First, it shows a system or application; then it shows the people, organizations, or other systems that interact with it; and finally, it shows a basic flow of what the system or application does. It’s a very high-level diagram and typically won’t show a lot of detail, but it’s a great way to communicate complex ideas in a fairly basic way. Before we really get into the tutorial, let’s talk about how you’re going to make a Use Case diagram. You can draw them out with pen and paper, but a diagramming application is going to be much easier. Today I’ll be using Lucidchart.
And you can use it too, for free actually. Just click the link to access Lucidchart’s website, enter your email address, and you’ll have a free Lucidchart account in just a few seconds. It’s easy to use and you can follow along with me as we build a Use Case diagram. (Okay, so) We’re going to break down Use Case diagrams into four different elements: Systems, Actors, Use Cases, and Relationships. Let’s start with systems. A system is whatever you’re developing. It could be a website, a software component, a business process, an app, or any number of other things. You represent a system with a rectangle, and you put the name of the system at the top. We’re going to build a Use Case diagram for a very simple Banking Application. We’ll call our system Banking App. This rectangle helps define the scope of this system. Anything within this rectangle happens within the Banking App. Anything outside this rectangle doesn’t happen in the Banking App.
The next element is an actor, which is depicted by this stick figure. An actor is going to be someone or something that uses our system to achieve a goal. That could be a person, an organization, another system, or an external device. So who or what is going to be using our Banking App? The most obvious actor is a customer. We’re going to have customers that download and use our Banking App. Another actor that we’ll want in our diagram is the Bank. The Bank is going to provide information that feeds into our Banking App, like transactions and account balances. Here are a couple things to keep in mind when dealing with Actors. First, it’s important to note that these actors are external objects. They always need to be placed outside of our system. Second, Actors need to be thought of as types or categories. For our Banking App, an actor isn’t going to be a specific individual or a specific organization. We wouldn’t label our actors as John and Chase Bank. We want to keep things categorical.
So right now we’re saying that both Customers and Banks are going to use our app, and this brings up the topic of primary and secondary actors. A primary actor initiates the use of the system while a secondary actor is more reactionary. So in our example, which actor is primary and which actor is secondary? The primary actor is Customer. The Customer is going to initiate the use of our system. They’re going to pull out their phone, open up our Banking App, and do something with it. Bank, on the other hand, is a secondary actor. The Bank is only going to act once the Customer does something. If the Customer goes on the app to see how much money is in their account, only then does the Bank engage with our system to provide the balance. Primary actors should be to the left of the system, and secondary actors should be to the right.
This just visually reinforces the fact that Customer engages with the Banking App and then the Bank reacts. The next element is a Use Case and this is where you really start to describe what your system does. A Use Case is depicted with this oval shape and it represents an action that accomplishes some sort of task within the system. They’re going to be placed within the rectangle because they’re actions that occur within the Banking App. So what is our Banking App going to do? We’re going to keep things very simple. Our Banking App is going to allow a Customer to log in, check their account balance, transfer funds between accounts, and make payments towards bills. So if this is what our Banking App does, we’re going to have Use Cases that describe each of those actions.
We’ll have a Use Case called Log In, another called Check Balance, another called Transfer Funds, and finally Make Payment. You can see that each of these Use Cases starts with a verb and reinforces an action that takes place. We also want them to be sufficiently descriptive. If this Use Case just said Transfer, that’d be too vague. Finally, it’s good practice to put your Use Cases in a logical order when possible. That’s why we put Log In at the top. That’s the first thing that will happen when a Customer uses our Banking App. The final element in Use Case Diagrams are Relationships. An actor, by definition, is using our system to achieve a goal. So each actor has to interact with at least one of the Use Cases within our system. In our example, a Customer is going to Log In to our Banking App. So we draw a solid line between the Actor and the Use Case to show this relationship.
This type of relationship is called an association and it just signifies a basic communication or interaction. A Customer is going to interact with the rest of these Use Cases as well. They’re going to Check Balance, Transfer Funds, and Make Payment so we’ll draw solid lines out to each of those as well. Secondary Actors will also have relationships. Remember, each actor has to interact with at least one Use Case. So which Use Cases will the bank interact with? When a Customer wants to check their balance on the app, the Bank is going to provide the correct amount. Let’s draw a line between Bank and Check Balance. Similarly, when a Customer wants to transfer funds or make a payment, the Bank is going to follow through with those transactions. We don’t need draw a line to Log In, because that process happens within the Banking App.
There’s no need for the Bank to actually get involved with the login process. There are three other types of relationships in addition to association. There’s Include, Extend, and Generalization. Let’s build out this diagram with additional Use Cases in order to explain these types of relationships. When a Customer types in their login information, our Banking App is going to verify the password before completing the login process. But if the password is incorrect, the Banking App is going display an error message. So let’s create two new Use Cases for Verify Password and Display Login Error. When a Customer wants to transfer funds or make a payment, our Banking App is going to make sure there’s enough money to complete those transactions. So we’ll also create another Use Case called Verify Sufficient Funds.
And finally, when a Customer wants to make a payment, our Banking App is going to give them the option of paying from either their checking account or their savings account. So we’ll create two more Use Cases called Pay From Checking and Pay From Savings. Let’s circle back to this Verify Password use case and talk about relationships again. How does Verify Password relate to the rest of the diagram? Neither of our actors are directly initiating this action. It’s just immediately going to happen within our Banking App every time there’s an attempt to log in. This is an Include relationship. An Include relationship shows dependency between a base use case and an included use case. Every time the base use case is executed, the included use case is executed as well. Another way to think of it is that the base use case requires an included use case in order to be complete.
When you have an include relationship, you draw a dashed line with an arrow that points towards the included use case. So in our example, Log In is the base use case and Verify Password is the included use case. Every time a Customer Logs In, our Banking App will automatically Verify Password. This Log In use case won’t be complete unless Verify Password is complete. So we draw a dashed line with the arrow pointing towards the included use case, and we write “include” in double chevrons. The next type of relationship is the Extend relationship. An extend relationship has a base use case and an extend use case. When the base use case is executed, the extend use case will happen sometimes but not every time. The extend use case will only happen if certain criteria are met. Another way to think of it is that you have the option to extend the behavior of the base use case. When you have an extend relationship, you draw a dashed line with an arrow that points towards the base use case. In our example, Log In is a base use case and Display Login Error is an extended use case.
Our Banking App won’t display a Login Error Message every time a Customer logs in. This will only happen once in a while when a Customer accidently enters an incorrect password. Since this is an extend relationship, we draw a dashed line with an arrow that points to the base use case and write “extend” between double chevrons. Hopefully this thoroughly explains the difference between include and extend relationships. But just in case, here’s a very basic example to help differentiate between the two. If you sneeze, you will close your eyes. That’s an included relationship because it’s going to happen every time. Additionally, if you sneeze, you might say excuse me. That’s an extended relationship because it supplements the sneeze, but isn’t completely necessary in the sneezing process. Just remember that include happens every time, extend happens just sometimes, and don’t forget that the arrows point in opposite directions. One quick thing to note is that multiple base use cases can point to the same included or extended use case. For example, both Transfer Funds and Make Payment are going to point to Verify Sufficient Funds as an included use case.
We want our Banking App to make this check every time either of these base use cases occur. You don’t need to duplicate the Verify Sufficient Funds use case. The simpler your diagram, the better. The last type of relationship we’ll discuss is Generalization, also known as inheritance. When you Make a Payment from our Banking App, you can do so from either your checking account or your savings account. In this scenario, Make a Payment is a general use case and Pay from Savings and Pay from Checking are specialized use cases. You could also use the terms parent and children. Each child shares the common behaviors of the parent, but each child adds something more on its own.
To show that this is a generalization, we draw this type of arrow from the children up to the parent. You can have generalizations on Use Cases, like we have here. You can also have generalizations with Actors. In certain scenarios you might want to distinguish between a New Customer and a Returning Customer. You could make them both children to a general Customer actor, which would allow you to have certain behaviors or qualities unique to each of these children. One last shape that we’ll quickly talk about is a use case with extension points. You can see an example here.
The name of the use case is above the line and then there are extension points below the line. Extension points are just a detailed version of extend relationships. This use case shows us that a Customer can Set Up their Profile in our Banking App. And then these extension points show us that when a Customer is setting up their profile, they’ll have the option to navigate to a couple different screens. If a Customer is confused, they can go to Profile Help and if they want details regarding their private information, they can go to Privacy Info. Those extension points branch off to extended use cases: Go to Profile Help and Show Privacy Info. We can even add a note to show what sort of conditions would lead to these extension points.
Now we have a complete Use Case diagram with various elements that help explain what our Banking App does. This was a very basic example, but remember that even complex systems should be restricted to a simplistic visualization of functionality, behavior, and relationships. Save the details for other diagrams. If you’d like to take a closer look at this example, click on the card. You’ll find this exact Banking App example plus several other examples and resources. Thanks for watching this tutorial on UML Use Case Diagrams. Please subscribe to our channel to see more helpful tutorials. Leave a comment if you have any thoughts or questions. And lastly, click here to try a free Lucidchart account and start making your own UML diagrams.
TRANSLATED
Hai, nama saya Chloe dan saya akan mengajar Anda semua yang perlu Anda ketahui tentang UML Gunakan diagram Case. Kami akan mulai dengan ikhtisar tingkat tinggi. Kemudian kita akan berbicara tentang Sistem, Aktor, Penggunaan Kasus, dan Hubungan. Dan akhirnya, kami akan membangun seluruh kasus penggunaan diagram bersama dan membahas contoh untuk dijelaskan semua konsep ini secara mendalam. Pernahkah Anda memiliki ide yang membuat sempurna masuk akal di kepala Anda, tetapi ketika Anda mencoba untuk menjelaskan kepada orang lain mereka benar-benar hilang? Mungkin ide Anda adalah untuk aplikasi baru, dan setiap saat Anda membicarakannya orang tidak benar-benar mengerti bagaimana mereka berinteraksi dengan aplikasi atau apa yang akan dilakukannya. Jenis skenario ini adalah tempat Use Case diagram sangat membantu. Berikut ini deskripsi sederhana dari Use Case diagram.
Pertama, ini menunjukkan sistem atau aplikasi; kemudian ini menunjukkan orang-orang, organisasi, atau lainnya sistem yang berinteraksi dengannya; dan akhirnya, itu menunjukkan aliran dasar dari apa sistem atau aplikasi tidak. Ini adalah diagram tingkat tinggi dan biasanya tidak akan menunjukkan banyak detail, tapi itu a cara yang bagus untuk mengomunikasikan ide-ide kompleks dalam cara yang cukup mendasar. Sebelum kita benar-benar masuk ke tutorial, mari kita berbicara tentang bagaimana Anda akan membuat Penggunaan Diagram kasus. Anda bisa menggambar dengan pena dan kertas, tetapi aplikasi diagram akan digunakan jauh lebih mudah. Hari ini saya akan menggunakan Lucidchart.
Dan Anda dapat menggunakannya juga, secara gratis sebenarnya. Cukup klik tautan untuk mengakses Lucidchart situs web, masukkan alamat email Anda, dan Anda akan memiliki akun Lucidchart gratis hanya dalam beberapa detik. Sangat mudah digunakan dan Anda bisa mengikutinya dengan saya saat kami membangun diagram Use Case. (Oke, jadi) Kita akan meruntuhkan Gunakan Diagram kasus menjadi empat elemen yang berbeda: Sistem, Aktor, Kasus Penggunaan, dan Hubungan. Mari kita mulai dengan sistem. Suatu sistem adalah apa pun yang Anda kembangkan. Ini bisa berupa situs web, komponen perangkat lunak, proses bisnis, aplikasi, atau nomor apa pun hal-hal lain. Anda mewakili sistem dengan persegi panjang, dan Anda memasukkan nama sistem di bagian atas. Kita akan membangun diagram Use Case untuk Aplikasi Perbankan yang sangat sederhana. Kami akan menghubungi sistem Banking App kami. Persegi panjang ini membantu menentukan ruang lingkup ini sistem. Apa pun dalam persegi panjang ini terjadi di dalam Aplikasi Perbankan. Apa pun di luar persegi panjang ini tidak terjadi di Aplikasi Perbankan.
Elemen selanjutnya adalah aktor, yang digambarkan oleh sosok tongkat ini. Seorang aktor akan menjadi seseorang atau sesuatu yang menggunakan sistem kami untuk mencapai suatu tujuan. Itu bisa jadi orang, organisasi, yang lain sistem, atau perangkat eksternal. Jadi siapa atau apa yang akan menggunakan Perbankan kita Aplikasi? Aktor yang paling jelas adalah pelanggan. Kami akan memiliki pelanggan yang mengunduh dan menggunakan Aplikasi Perbankan kami. Aktor lain yang kami inginkan dalam diagram kami adalah Bank. Bank akan memberikan informasi itu dimasukkan ke dalam Aplikasi Perbankan kami, seperti transaksi dan saldo akun. Berikut adalah beberapa hal yang perlu diingat saat itu berurusan dengan Aktor. Pertama, penting untuk dicatat bahwa ini aktor adalah objek eksternal. Mereka selalu harus ditempatkan di luar kami sistem. Kedua, Aktor harus dianggap sebagai tipe atau kategori. Untuk Aplikasi Perbankan kami, seorang aktor tidak akan hadir menjadi individu atau spesifik tertentu organisasi. Kami tidak akan menyebut aktor kami sebagai John dan Chase Bank. Kami ingin menjaga hal-hal yang kategoris.
Jadi sekarang kami mengatakan bahwa kedua Pelanggan dan Bank akan menggunakan aplikasi kami, dan ini memunculkan topik primer dan sekunder aktor. Aktor utama memulai penggunaan sistem sementara aktor sekunder lebih reaksioner. Jadi dalam contoh kami, aktor mana yang utama dan aktor mana yang sekunder? Aktor utama adalah Pelanggan. Pelanggan akan memulai penggunaan dari sistem kami. Mereka akan mengeluarkan ponsel mereka, terbuka Aplikasi Perbankan kami, dan lakukan sesuatu dengan saya. Bank, di sisi lain, adalah aktor sekunder. Bank hanya akan bertindak sekali Pelanggan melakukan sesuatu. Jika Pelanggan masuk ke aplikasi untuk melihat caranya banyak uang dalam akun mereka, hanya kemudian apakah Bank terlibat dengan sistem kami untuk menyediakan keseimbangan. Aktor utama harus di sebelah kiri sistem, dan aktor sekunder harus hak. Ini hanya secara visual memperkuat fakta itu Pelanggan terlibat dengan Aplikasi Perbankan dan kemudian Bank bereaksi. Elemen selanjutnya adalah Use Case dan ini di mana Anda benar-benar mulai menggambarkan apa yang Anda miliki sistem tidak. Use Case digambarkan dengan bentuk oval ini dan itu merupakan tindakan yang dilakukan semacam tugas dalam sistem. Mereka akan ditempatkan di dalam persegi panjang karena mereka adalah tindakan yang terjadi di dalamnya Aplikasi Perbankan. Jadi apa yang akan dilakukan oleh Aplikasi Perbankan kami? Kami akan menjaga hal-hal yang sangat sederhana. Aplikasi Perbankan kami akan memungkinkan Pelanggan untuk masuk, periksa saldo akun mereka, transfer dana antar rekening, dan melakukan pembayaran menuju tagihan. Jadi, jika ini yang dilakukan oleh Aplikasi Perbankan kami, kami akan memiliki Use Cases yang menggambarkan masing-masing dari tindakan itu. Kami akan memiliki Kasus Penggunaan yang disebut Masuk, lainnya disebut Cek Saldo, yang lain disebut Transfer Dana, dan akhirnya Lakukan Pembayaran. Anda dapat melihat bahwa masing-masing Kasus Penggunaan ini dimulai dengan kata kerja dan memperkuat tindakan itu terjadi. Kami juga ingin mereka menjadi cukup deskriptif. Jika Kasus Penggunaan ini hanya mengatakan Transfer, itu terlalu samar. Akhirnya, itu praktik yang baik untuk menempatkan Anda Gunakan Kasus dalam urutan yang logis bila memungkinkan. Itu sebabnya kami memasukkan Log In di bagian atas. Itu hal pertama yang akan terjadi ketika Pelanggan menggunakan Aplikasi Perbankan kami. Elemen terakhir dalam Use Case Diagrams adalah Hubungan. Seorang aktor, menurut definisi, menggunakan sistem kami untuk mencapai suatu tujuan. Jadi setiap aktor harus berinteraksi setidaknya salah satu Use Cases dalam sistem kami. Dalam contoh kami, Pelanggan akan Masuk Masuk ke Aplikasi Perbankan kami. Jadi kami menarik garis tegas antara Aktor dan Use Case untuk menunjukkan hubungan ini. Jenis hubungan ini disebut asosiasi dan itu hanya menandakan komunikasi dasar atau interaksi. Pelanggan akan berinteraksi dengan yang lain dari Use Cases ini juga. Mereka akan Cek Saldo, Transfer Dana, dan Lakukan Pembayaran jadi kami akan menggambar dengan solid baris ke masing-masing dari mereka juga. Aktor Sekunder juga akan memiliki hubungan. Ingat, setiap aktor harus berinteraksi dengannya setidaknya satu Use Case. Jadi, Use Cases mana yang akan berinteraksi dengan bank dengan? Ketika seorang Pelanggan ingin memeriksa saldo mereka pada aplikasi, Bank akan menyediakan jumlah yang benar. Mari kita tarik garis antara Bank dan Cek Keseimbangan. Demikian pula, ketika Pelanggan ingin mentransfer dana atau melakukan pembayaran, Bank akan untuk menindaklanjuti dengan transaksi tersebut. Kami tidak perlu menarik garis ke Log In, karena proses itu terjadi dalam Aplikasi Perbankan. Tidak perlu bagi Bank untuk benar-benar terlibat dengan proses masuk. Ada tiga jenis hubungan lainnya selain asosiasi. Ada Sertakan, Perpanjangan, dan Generalisasi. Mari kita bangun diagram ini dengan tambahan Gunakan Kasus untuk menjelaskan jenis ini hubungan. Ketika seorang pelanggan mengetikkan informasi login mereka, Aplikasi Perbankan kami akan memverifikasi kata sandi sebelum menyelesaikan proses login. Tetapi jika kata sandi salah, Perbankan Aplikasi akan menampilkan pesan kesalahan. Jadi, mari buat dua Kasus Penggunaan baru untuk Verifikasi Kesalahan Masuk Kata Sandi dan Tampilan. Ketika Pelanggan ingin mentransfer dana atau melakukan pembayaran, Aplikasi Perbankan kami akan pastikan ada cukup uang untuk diselesaikan transaksi tersebut. Jadi kita juga akan membuat Use Case lain yang disebut Verifikasi Dana yang Cukup. Dan akhirnya, ketika seorang pelanggan ingin membuatnya pembayaran, Aplikasi Perbankan kami akan memberi mereka pilihan untuk membayar baik dari mereka rekening giro atau rekening tabungan mereka. Jadi kita akan membuat dua Kasus Penggunaan lain yang disebut Bayar Dari Memeriksa dan Membayar Dari Tabungan. Mari lingkari kembali ke Verify Password ini gunakan case dan bicarakan tentang hubungan lagi. Bagaimana Verifikasi Kata Sandi berhubungan dengan yang lain dari diagram? Tidak satu pun dari aktor kami yang langsung melakukan inisiasi aksi ini. Ini akan segera terjadi Aplikasi Perbankan kami setiap kali ada upaya untuk masuk. Ini adalah hubungan Sertakan. Hubungan Sertakan menunjukkan ketergantungan antara kasus penggunaan dasar dan kasus penggunaan yang disertakan. Setiap kali kasus penggunaan dasar dijalankan, use case yang disertakan juga dieksekusi. Cara lain untuk memikirkannya adalah dasar itu use case membutuhkan use case yang disertakan dalam untuk menjadi lengkap. Ketika Anda memiliki hubungan termasuk, Anda menggambar garis putus-putus dengan panah yang menunjuk terhadap kasus penggunaan yang disertakan. Jadi dalam contoh kami, Log In adalah penggunaan basis case dan Verify Password adalah penggunaan yang termasuk kasus. Setiap kali Pelanggan Masuk, Perbankan kami Aplikasi secara otomatis akan Verifikasi Kata Sandi. Kasus penggunaan Log In ini tidak akan lengkap kecuali Verifikasi kata sandi selesai. Jadi kami menggambar garis putus-putus dengan panah menunjuk terhadap kasus penggunaan yang disertakan, dan kami menulis "Termasuk" dalam chevron ganda. Jenis hubungan selanjutnya adalah Perpanjang hubungan. Hubungan perpanjangan memiliki kasus penggunaan dasar dan kasus penggunaan tambahan. Ketika kasus penggunaan dasar dijalankan, perpanjangan use case kadang-kadang akan terjadi tetapi tidak setiap waktu. Kasus penggunaan perpanjangan hanya akan terjadi jika ada kriteria terpenuhi. Cara lain untuk memikirkannya adalah yang Anda miliki opsi untuk memperluas perilaku pangkalan gunakan case. Ketika Anda memiliki hubungan yang panjang, Anda menggambar garis putus-putus dengan panah yang menunjuk terhadap kasus penggunaan dasar. Dalam contoh kami, Log In adalah kasus penggunaan dasar dan Kesalahan Tampilan Login adalah penggunaan yang diperpanjang kasus. Aplikasi Perbankan kami tidak akan menampilkan Kesalahan Login Pesan setiap kali Pelanggan masuk. Ini hanya akan terjadi sesekali ketika Pelanggan secara tidak sengaja memasukkan yang salah kata sandi. Karena ini adalah hubungan panjang, kita menggambar garis putus-putus dengan panah yang menunjuk ke kasus penggunaan dasar dan tulis "memperpanjang" antara chevron ganda. Semoga ini benar-benar menjelaskan perbedaannya antara menyertakan dan memperpanjang hubungan. Tetapi untuk berjaga-jaga, inilah contoh yang sangat mendasar untuk membantu membedakan keduanya. Jika Anda bersin, Anda akan menutup mata Anda. Itu hubungan yang disertakan karena itu akan terjadi setiap saat. Selain itu, jika Anda bersin, Anda mungkin berkata permisi. Itu hubungan yang panjang karena itu suplemen bersin, tetapi tidak sepenuhnya diperlukan dalam proses bersin. Ingat saja bahwa termasuk yang terjadi setiap waktu, memperpanjang hanya terjadi kadang-kadang, dan tidak lupakan bahwa panah menunjuk ke arah yang berlawanan. Satu hal cepat yang perlu diperhatikan adalah beberapa basis kasus penggunaan dapat menunjuk ke yang sama termasuk atau kasus penggunaan yang diperpanjang. Misalnya, Transfer Dana dan Make Pembayaran akan mengarah ke Verifikasi Cukup Dana sebagai kasus penggunaan yang disertakan. Kami ingin Aplikasi Perbankan kami melakukan pemeriksaan ini setiap kali salah satu dari kasus penggunaan dasar ini terjadi. Anda tidak perlu menduplikasi Verify Sufficient Kasus penggunaan dana. Semakin sederhana diagram Anda, semakin baik. Jenis hubungan terakhir yang akan kita diskusikan adalah Generalisasi, juga dikenal sebagai warisan. Saat Anda Melakukan Pembayaran dari Aplikasi Perbankan kami, Anda dapat melakukannya dari akun cek Anda atau rekening tabungan Anda. Dalam skenario ini, Lakukan Pembayaran adalah umum gunakan case dan Bayar dari Tabungan dan Bayar dari Memeriksa adalah kasus penggunaan khusus. Anda juga bisa menggunakan istilah orang tua dan anak-anak. Setiap anak berbagi perilaku umum orang tua, tetapi setiap anak menambahkan sesuatu lebih banyak dengan sendirinya. Untuk menunjukkan bahwa ini adalah generalisasi, kami gambar panah jenis ini dari anak-anak hingga orang tua. Anda dapat memiliki generalisasi pada Use Cases, seperti yang kita miliki di sini. Anda juga dapat memiliki generalisasi dengan Aktor. Dalam skenario tertentu Anda mungkin ingin membedakan antara Pelanggan Baru dan Pelanggan yang Kembali. Anda bisa menjadikan mereka berdua anak-anak untuk seorang jenderal Aktor pelanggan, yang memungkinkan Anda untuk memilikinya perilaku atau kualitas tertentu yang unik untuk masing-masing anak-anak ini. Satu bentuk terakhir yang akan kita bicarakan dengan cepat adalah kasus penggunaan dengan poin ekstensi. Anda dapat melihat contoh di sini. Nama kasus penggunaannya di atas garis dan kemudian ada poin ekstensi di bawah ini garis. Titik ekstensi hanyalah versi terperinci memperluas hubungan. Kasus penggunaan ini menunjukkan kepada kami bahwa Pelanggan dapat Mengatur Profil mereka di Aplikasi Perbankan kami. Dan kemudian titik ekstensi ini menunjukkan itu pada kami saat Pelanggan menyiapkan profilnya, mereka akan memiliki opsi untuk menavigasi ke beberapa layar yang berbeda. Jika seorang Pelanggan bingung, mereka bisa pergi ke Bantuan Profil dan jika mereka menginginkan detail terkait informasi pribadi mereka, mereka bisa pergi ke Info Privasi. Titik ekstensi tersebut bercabang untuk diperpanjang use cases: Buka Bantuan Profil dan Tampilkan Privasi Info. Kami bahkan dapat menambahkan catatan untuk menunjukkan jenis apa kondisi akan mengarah ke titik ekstensi ini. Sekarang kita memiliki diagram Use Case lengkap dengan berbagai elemen yang membantu menjelaskan apa adanya kami Aplikasi Perbankan. Ini adalah contoh yang sangat mendasar, tetapi ingat bahkan sistem yang rumit pun harus dibatasi untuk visualisasi fungsi yang sederhana, perilaku, dan hubungan. Simpan detail untuk diagram lainnya. Jika Anda ingin melihat lebih dekat ini Misalnya, klik pada kartu. Anda akan menemukan contoh Aplikasi Perbankan yang tepat ini ditambah beberapa contoh dan sumber daya lainnya. Terima kasih telah menonton tutorial tentang Penggunaan UML ini Diagram Kasus. Silakan berlangganan ke saluran kami untuk melihat lebih banyak tutorial yang membantu. Tinggalkan komentar jika Anda memiliki pemikiran atau pertanyaan. Dan terakhir, klik di sini untuk mencoba Lucidchart gratis akun dan mulai membuat diagram UML Anda sendiri.
0 Komentar