{"id":946,"date":"2026-02-25T10:32:36","date_gmt":"2026-02-25T10:32:36","guid":{"rendered":"https:\/\/skills.visual-paradigm.com\/pt\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-case-study\/crc-uml-example-project-library-system\/"},"modified":"2026-02-25T10:32:36","modified_gmt":"2026-02-25T10:32:36","slug":"crc-uml-example-project-library-system","status":"publish","type":"docs","link":"https:\/\/skills.visual-paradigm.com\/pt\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-case-study\/crc-uml-example-project-library-system\/","title":{"rendered":"Case Study: Modeling a Library System from CRC to UML"},"content":{"rendered":"<p>When translating CRC cards into UML, the real value isn\u2019t in the syntax\u2014it\u2019s in preserving the intent behind the design. I\u2019ve led dozens of modeling sessions where teams rushed to draw boxes and lines before fully understanding collaboration patterns. The result? Over-engineered models full of unnecessary associations and ambiguous responsibilities.<\/p>\n<p>My advice? Let the CRC cards teach you. They\u2019re not just a brainstorming aid\u2014they\u2019re a behavioral blueprint. In this CRC UML example project, we\u2019ll walk through building a robust library system from scratch, using real CRC sample modeling to guide each decision in the class diagram.<\/p>\n<p>By the end, you\u2019ll know how to extract attributes, model associations with proper cardinality, and validate design completeness\u2014all rooted in the natural language of team collaboration. This isn\u2019t theory. It\u2019s what I\u2019ve used in production environments to align developers, analysts, and product owners around a single source of truth.<\/p>\n<h2>Step 1: Begin with CRC Cards \u2013 The Library System Brainstorm<\/h2>\n<p>I\u2019ve worked with teams where the first step was sketching a single class called \u201cLibrary.\u201d That\u2019s a red flag. It\u2019s too early to name the system. Start with the roles users interact with.<\/p>\n<p>During a joint workshop, we asked: <em>Who or what handles the lending process?<\/em> The answers came fast: <strong>Librarian<\/strong>, <strong>Book<\/strong>, <strong>Member<\/strong>, and <strong>Loan<\/strong>.<\/p>\n<p>Each of these became a CRC card. Here\u2019s a snapshot of the initial set:<\/p>\n<ul>\n<li><strong>Class:<\/strong> Librarian<\/li>\n<li><strong>Responsibilities:<\/strong> Issue a loan, Return a book, Check member eligibility<\/li>\n<li><strong>Collaborators:<\/strong> Member, Book, Loan<\/li>\n<\/ul>\n<ul>\n<li><strong>Class:<\/strong> Book<\/li>\n<li><strong>Responsibilities:<\/strong> Track availability, Store ISBN, Update loan status<\/li>\n<li><strong>Collaborators:<\/strong> Loan, Librarian<\/li>\n<\/ul>\n<ul>\n<li><strong>Class:<\/strong> Member<\/li>\n<li><strong>Responsibilities:<\/strong> Register, Borrow a book, Pay fines<\/li>\n<li><strong>Collaborators:<\/strong> Librarian, Loan<\/li>\n<\/ul>\n<ul>\n<li><strong>Class:<\/strong> Loan<\/li>\n<li><strong>Responsibilities:<\/strong> Track due date, Record return status, Calculate fine<\/li>\n<li><strong>Collaborators:<\/strong> Book, Member, Librarian<\/li>\n<\/ul>\n<p>These aren\u2019t just names\u2014they\u2019re design triggers. Every responsibility implies a method. Every collaboration implies a relationship.<\/p>\n<h3>Why This Order Matters<\/h3>\n<p>Observation: Most teams start with \u201cLibrary\u201d as a central class. But that\u2019s a symptom of premature structuring. The domain should drive the model, not the system\u2019s name.<\/p>\n<p>Instead, I always ask: <em>What are the key actors and artifacts?<\/em> That question keeps us grounded in behavior, not hierarchy.<\/p>\n<h2>Step 2: Convert CRC Classes to UML Class Nodes<\/h2>\n<p>Now, translate each CRC card into a UML class. The class name becomes the class box.<\/p>\n<p>Start with clear naming. Avoid \u201cBookManager\u201d or \u201cMemberHandler.\u201d The class should reflect the <em>role<\/em>, not the function. \u201cBook\u201d is better than \u201cBookRepository\u201d at this stage.<\/p>\n<p>Here\u2019s how the first few classes look in UML:<\/p>\n<pre><code>\n+------------------+\n|     Book         |\n+------------------+\n| - title: String  |\n| - author: String  |\n| - isbn: String     |\n| - available: bool |\n+------------------+\n| + checkOut()     |\n| + returnBook()   |\n| + isAvailable()  |\n+------------------+\n<\/code><\/pre>\n<p>Notice: The attributes are derived from what the book <em>holds<\/em>. The methods come from its <em>responsibilities<\/em>.<\/p>\n<p>When I first taught this process, a junior developer asked: <em>Shouldn\u2019t \u201cdue date\u201d be in Book?<\/em> That\u2019s a sign we need to dig deeper. The due date belongs to the <strong>Loan<\/strong>, not the book.<\/p>\n<h3>Key Decision: What Belongs in Which Class?<\/h3>\n<p>Use this rule: <em>Only data that directly belongs to the entity should be in its attributes.<\/em><\/p>\n<p>So: <strong>Book<\/strong> holds ISBN, title, author, availability. But not due dates or fines.<\/p>\n<p>That\u2019s why the <strong>Loan<\/strong> class is critical. It owns the temporal behavior.<\/p>\n<h2>Step 3: Map Responsibilities to Methods and Attributes<\/h2>\n<p>Each CRC responsibility becomes a method or attribute in the class diagram.<\/p>\n<p>For example:<\/p>\n<ul>\n<li><strong>\u201cTrack availability\u201d<\/strong> \u2192 <code>available: boolean<\/code> (attribute)<\/li>\n<li><strong>\u201cUpdate loan status\u201d<\/strong> \u2192 <code>updateStatus(status: String)<\/code> (method)<\/li>\n<li><strong>\u201cRecord return status\u201d<\/strong> \u2192 <code>recordReturn()<\/code> (method)<\/li>\n<\/ul>\n<p>But not all responsibilities are methods. Some are state.<\/p>\n<p>Example: <em>\u201cCheck member eligibility\u201d<\/em> \u2192 this is a method, but it doesn\u2019t belong in <strong>Librarian<\/strong>\u2014it should be in <strong>Member<\/strong> as <code>isEligible(): boolean<\/code>.<\/p>\n<p>This is where CRC sample modeling shines. The language of the card reveals intent. \u201cCheck\u201d implies a query. \u201cIssue\u201d implies an action.<\/p>\n<h3>Patterns to Watch<\/h3>\n<ul>\n<li><strong>Verbs like \u201cissue\u201d, \u201creturn\u201d, \u201ccheck\u201d<\/strong> \u2192 usually <strong>operations<\/strong><\/li>\n<li><strong>Nouns like \u201cavailability\u201d, \u201cdue date\u201d<\/strong> \u2192 usually <strong>attributes<\/strong><\/li>\n<li><strong>Questions like \u201cis eligible?\u201d<\/strong> \u2192 <strong>boolean-returning methods<\/strong><\/li>\n<\/ul>\n<p>These patterns help you avoid overloading classes with unnecessary methods.<\/p>\n<h2>Step 4: Model Collaborations as UML Associations<\/h2>\n<p>Now, turn collaborations into associations. Each collaboration in a CRC card maps to a line in the UML diagram.<\/p>\n<p>For example, \u201cLibrarian collaborates with Member, Book, Loan\u201d becomes:<\/p>\n<ul>\n<li>Librarian \u2014\u2014 Member (1 to many)<\/li>\n<li>Librarian \u2014\u2014 Book (1 to many)<\/li>\n<li>Librarian \u2014\u2014 Loan (1 to many)<\/li>\n<\/ul>\n<p>But wait\u2014this is too simplistic. Let\u2019s look deeper.<\/p>\n<p>Who <em>creates<\/em> a Loan? The Librarian. So, the association should be <strong>directed<\/strong> from Librarian to Loan.<\/p>\n<p>Now, who <em>owns<\/em> the Loan? The system. But the <strong>Member<\/strong> is the one who <em>initiates<\/em> the loan. So, <strong>Member<\/strong> <em>creates<\/em> a <strong>Loan<\/strong>, and the <strong>Librarian<\/strong> approves it.<\/p>\n<p>Here\u2019s how we refine the associations:<\/p>\n<table>\n<tbody>\n<tr>\n<th>Association<\/th>\n<th>Cardinality<\/th>\n<th>Direction<\/th>\n<th>Justification<\/th>\n<\/tr>\n<tr>\n<td>Member \u2014\u2014 Loan<\/td>\n<td>1 to many<\/td>\n<td>Member \u2192 Loan<\/td>\n<td>Member creates multiple loans<\/td>\n<\/tr>\n<tr>\n<td>Book \u2014\u2014 Loan<\/td>\n<td>1 to many<\/td>\n<td>Loan \u2192 Book<\/td>\n<td>A loan is for one book<\/td>\n<\/tr>\n<tr>\n<td>Librarian \u2014\u2014 Loan<\/td>\n<td>1 to many<\/td>\n<td>Librarian \u2192 Loan<\/td>\n<td>Librarian issues loans<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Notice the direction matters. The arrow shows who <em>controls<\/em> the relationship.<\/p>\n<h3>Why Navigation Matters<\/h3>\n<p>Always ask: <em>Can I navigate from A to B?<\/em> If yes, draw the arrow.<\/p>\n<p>For example: From <strong>Loan<\/strong>, can you go to <strong>Book<\/strong>? Yes, because a loan refers to a book.<\/p>\n<p>From <strong>Book<\/strong> to <strong>Loan<\/strong>? Only if you\u2019re tracking active loans. But a book doesn\u2019t own the loan\u2014it&#8217;s referenced.<\/p>\n<p>So: <strong>Loan<\/strong> \u2192 <strong>Book<\/strong> is correct. The reverse is optional, unless you have a <code>getLoans()<\/code> method in Book.<\/p>\n<h2>Step 5: Add Attributes and Constraints<\/h2>\n<p>Now, identify attributes that represent state.<\/p>\n<p>For <strong>Loan<\/strong>:<\/p>\n<ul>\n<li><code>dueDate: Date<\/code><\/li>\n<li><code>returnDate: Date<\/code><\/li>\n<li><code>status: String<\/code> (e.g., \u201cactive\u201d, \u201creturned\u201d, \u201coverdue\u201d)<\/li>\n<li><code>fineAmount: double<\/code><\/li>\n<\/ul>\n<p>These aren\u2019t just random fields. They emerge from responsibilities: \u201cCalculate fine\u201d needs a <code>fineAmount<\/code> attribute.<\/p>\n<p>Also, add constraints where needed:<\/p>\n<ul>\n<li><code>dueDate &gt; currentDate<\/code><\/li>\n<li><code>status \u2208 {\u201cactive\u201d, \u201creturned\u201d, \u201coverdue\u201d}<\/code><\/li>\n<\/ul>\n<p>Constraints clarify behavior. They\u2019re the guardrails of the model.<\/p>\n<h2>Step 6: Identify Inheritance and Interfaces<\/h2>\n<p>Now, ask: <em>Do any classes share common behavior?<\/em><\/p>\n<p>For example, both <strong>Member<\/strong> and <strong>Librarian<\/strong> can \u201ccheck\u201d something. But \u201ccheck eligibility\u201d and \u201ccheck availability\u201d are different.<\/p>\n<p>But what if we introduce <strong>Person<\/strong> as a superclass?<\/p>\n<ul>\n<li><strong>Person<\/strong> \u2192 <strong>Member<\/strong>, <strong>Librarian<\/strong><\/li>\n<li>Attributes: <code>name: String<\/code>, <code>address: String<\/code><\/li>\n<li>Methods: <code>getName(): String<\/code>, <code>getAddress(): String<\/code><\/li>\n<\/ul>\n<p>But stop. Is \u201cPerson\u201d the right abstraction?<\/p>\n<p>Yes\u2014but only if both have shared identity, address, and name. If not, avoid forcing inheritance.<\/p>\n<p>Instead, extract a <strong>Person<\/strong> class only if it adds clarity. Otherwise, keep them separate.<\/p>\n<h3>When to Use Inheritance<\/h3>\n<ul>\n<li>When two classes share &gt;70% of behavior and state<\/li>\n<li>When you can define a <em>is-a<\/em> relationship<\/li>\n<li>When you need polymorphic behavior<\/li>\n<\/ul>\n<p>For a library system, <strong>Member<\/strong> and <strong>Librarian<\/strong> are roles, not types. So inheritance isn\u2019t needed.<\/p>\n<h2>Step 7: Validate the Model<\/h2>\n<p>Now, step back. Is the model complete? Cohesive? Free of ambiguity?<\/p>\n<p>Use this checklist:<\/p>\n<ul>\n<li>Every CRC responsibility is mapped to a method or attribute<\/li>\n<li>Every collaboration is represented as an association with correct cardinality<\/li>\n<li>Classes have clear, distinct responsibilities<\/li>\n<li>No class has more than 5\u20137 methods<\/li>\n<li>Associations are navigable only where needed<\/li>\n<\/ul>\n<p>If any of these fail, go back to the CRC cards and re-clarify.<\/p>\n<p>I once worked on a library system where \u201cLoan\u201d had 15 methods. The team didn\u2019t realize it was handling payment, return, fine, and status tracking\u2014too many responsibilities. The fix? Split into <strong>Loan<\/strong> and <strong>FineCalculator<\/strong>.<\/p>\n<h2>Frequently Asked Questions<\/h2>\n<h3>How do I know when my CRC UML example project is ready?<\/h3>\n<p>When every responsibility is accounted for, every collaboration is linked, and no class has more than five methods. Ask: <em>Can this class be understood without reading the code?<\/em> If yes, you\u2019re good.<\/p>\n<h3>Why use CRC sample modeling instead of jumping straight to UML?<\/h3>\n<p>Because CRC cards are language-driven. They reflect how teams think. UML formalizes that. Skipping CRC leads to models that are technically correct but miss behavioral intent.<\/p>\n<h3>Can I use this library system UML for software development?<\/h3>\n<p>Absolutely. This model directly maps to real classes in Java, Python, or C#. The attributes become fields, methods become functions, and associations become relationships in your database or ORM.<\/p>\n<h3>What if two people have different interpretations of a CRC card?<\/h3>\n<p>That\u2019s expected. Use the CRC cards as discussion prompts. The goal isn\u2019t consensus\u2014it\u2019s to surface ambiguity. Then refine the model together.<\/p>\n<h3>How do I handle time-based behavior like due dates?<\/h3>\n<p>Model it in the class that controls it. <strong>Loan<\/strong> manages the due date. Use a <code>calculateFine()<\/code> method that compares <code>returnDate<\/code> and <code>dueDate<\/code>.<\/p>\n<h3>Should I include the Library class in the diagram?<\/h3>\n<p>Only if it has behavior. If it\u2019s a container, consider it an <em>aggregate root<\/em>. But avoid over-engineering\u2014it can be a collection of <strong>Loan<\/strong> objects.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>When translating CRC cards into UML, the real value isn\u2019t in the syntax\u2014it\u2019s in preserving the intent behind the design. I\u2019ve led dozens of modeling sessions where teams rushed to draw boxes and lines before fully understanding collaboration patterns. The result? Over-engineered models full of unnecessary associations and ambiguous responsibilities. My advice? Let the CRC [&hellip;]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":945,"menu_order":0,"template":"","meta":{"_acf_changed":false,"inline_featured_image":false,"site-sidebar-layout":"default","site-content-layout":"","ast-site-content-layout":"default","site-content-style":"default","site-sidebar-style":"default","ast-global-header-display":"","ast-banner-title-visibility":"","ast-main-header-display":"","ast-hfb-above-header-display":"","ast-hfb-below-header-display":"","ast-hfb-mobile-header-display":"","site-post-title":"","ast-breadcrumbs-content":"","ast-featured-img":"","footer-sml-layout":"","ast-disable-related-posts":"","theme-transparent-header-meta":"","adv-header-id-meta":"","stick-header-meta":"","header-above-stick-meta":"","header-main-stick-meta":"","header-below-stick-meta":"","astra-migrate-meta-layouts":"default","ast-page-background-enabled":"default","ast-page-background-meta":{"desktop":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"ast-content-background-meta":{"desktop":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"footnotes":""},"doc_tag":[],"class_list":["post-946","docs","type-docs","status-publish","hentry"],"acf":[],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v27.2 - https:\/\/yoast.com\/product\/yoast-seo-wordpress\/ -->\n<title>CRC UML Example Project: Library System<\/title>\n<meta name=\"description\" content=\"Transform CRC card modeling into a formal UML class diagram with this practical CRC UML example project. Learn step-by-step how to model a library system using CRC sample modeling and practical class diagramming techniques.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/skills.visual-paradigm.com\/pt\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-case-study\/crc-uml-example-project-library-system\/\" \/>\n<meta property=\"og:locale\" content=\"pt_PT\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"CRC UML Example Project: Library System\" \/>\n<meta property=\"og:description\" content=\"Transform CRC card modeling into a formal UML class diagram with this practical CRC UML example project. Learn step-by-step how to model a library system using CRC sample modeling and practical class diagramming techniques.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/skills.visual-paradigm.com\/pt\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-case-study\/crc-uml-example-project-library-system\/\" \/>\n<meta property=\"og:site_name\" content=\"Visual Paradigm Skills Portugu\u00eas\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Tempo estimado de leitura\" \/>\n\t<meta name=\"twitter:data1\" content=\"7 minutos\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/pt\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-case-study\/crc-uml-example-project-library-system\/\",\"url\":\"https:\/\/skills.visual-paradigm.com\/pt\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-case-study\/crc-uml-example-project-library-system\/\",\"name\":\"CRC UML Example Project: Library System\",\"isPartOf\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/pt\/#website\"},\"datePublished\":\"2026-02-25T10:32:36+00:00\",\"description\":\"Transform CRC card modeling into a formal UML class diagram with this practical CRC UML example project. Learn step-by-step how to model a library system using CRC sample modeling and practical class diagramming techniques.\",\"breadcrumb\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/pt\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-case-study\/crc-uml-example-project-library-system\/#breadcrumb\"},\"inLanguage\":\"pt-PT\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/skills.visual-paradigm.com\/pt\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-case-study\/crc-uml-example-project-library-system\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/pt\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-case-study\/crc-uml-example-project-library-system\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/skills.visual-paradigm.com\/pt\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"From CRC Cards to Class Diagrams\",\"item\":\"https:\/\/skills.visual-paradigm.com\/pt\/docs\/crc-cards-to-class-diagrams\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Practical Application Scenarios\",\"item\":\"https:\/\/skills.visual-paradigm.com\/pt\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-case-study\/\"},{\"@type\":\"ListItem\",\"position\":4,\"name\":\"Case Study: Modeling a Library System from CRC to UML\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/pt\/#website\",\"url\":\"https:\/\/skills.visual-paradigm.com\/pt\/\",\"name\":\"Visual Paradigm Skills Portugu\u00eas\",\"description\":\"\",\"publisher\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/pt\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/skills.visual-paradigm.com\/pt\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"pt-PT\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/pt\/#organization\",\"name\":\"Visual Paradigm Skills Portugu\u00eas\",\"url\":\"https:\/\/skills.visual-paradigm.com\/pt\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"pt-PT\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/pt\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/skills.visual-paradigm.com\/pt\/wp-content\/uploads\/sites\/9\/2026\/02\/favicon.svg\",\"contentUrl\":\"https:\/\/skills.visual-paradigm.com\/pt\/wp-content\/uploads\/sites\/9\/2026\/02\/favicon.svg\",\"width\":70,\"height\":70,\"caption\":\"Visual Paradigm Skills Portugu\u00eas\"},\"image\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/pt\/#\/schema\/logo\/image\/\"}}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"CRC UML Example Project: Library System","description":"Transform CRC card modeling into a formal UML class diagram with this practical CRC UML example project. Learn step-by-step how to model a library system using CRC sample modeling and practical class diagramming techniques.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/skills.visual-paradigm.com\/pt\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-case-study\/crc-uml-example-project-library-system\/","og_locale":"pt_PT","og_type":"article","og_title":"CRC UML Example Project: Library System","og_description":"Transform CRC card modeling into a formal UML class diagram with this practical CRC UML example project. Learn step-by-step how to model a library system using CRC sample modeling and practical class diagramming techniques.","og_url":"https:\/\/skills.visual-paradigm.com\/pt\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-case-study\/crc-uml-example-project-library-system\/","og_site_name":"Visual Paradigm Skills Portugu\u00eas","twitter_card":"summary_large_image","twitter_misc":{"Tempo estimado de leitura":"7 minutos"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/skills.visual-paradigm.com\/pt\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-case-study\/crc-uml-example-project-library-system\/","url":"https:\/\/skills.visual-paradigm.com\/pt\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-case-study\/crc-uml-example-project-library-system\/","name":"CRC UML Example Project: Library System","isPartOf":{"@id":"https:\/\/skills.visual-paradigm.com\/pt\/#website"},"datePublished":"2026-02-25T10:32:36+00:00","description":"Transform CRC card modeling into a formal UML class diagram with this practical CRC UML example project. Learn step-by-step how to model a library system using CRC sample modeling and practical class diagramming techniques.","breadcrumb":{"@id":"https:\/\/skills.visual-paradigm.com\/pt\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-case-study\/crc-uml-example-project-library-system\/#breadcrumb"},"inLanguage":"pt-PT","potentialAction":[{"@type":"ReadAction","target":["https:\/\/skills.visual-paradigm.com\/pt\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-case-study\/crc-uml-example-project-library-system\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/skills.visual-paradigm.com\/pt\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-case-study\/crc-uml-example-project-library-system\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/skills.visual-paradigm.com\/pt\/"},{"@type":"ListItem","position":2,"name":"From CRC Cards to Class Diagrams","item":"https:\/\/skills.visual-paradigm.com\/pt\/docs\/crc-cards-to-class-diagrams\/"},{"@type":"ListItem","position":3,"name":"Practical Application Scenarios","item":"https:\/\/skills.visual-paradigm.com\/pt\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-case-study\/"},{"@type":"ListItem","position":4,"name":"Case Study: Modeling a Library System from CRC to UML"}]},{"@type":"WebSite","@id":"https:\/\/skills.visual-paradigm.com\/pt\/#website","url":"https:\/\/skills.visual-paradigm.com\/pt\/","name":"Visual Paradigm Skills Portugu\u00eas","description":"","publisher":{"@id":"https:\/\/skills.visual-paradigm.com\/pt\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/skills.visual-paradigm.com\/pt\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"pt-PT"},{"@type":"Organization","@id":"https:\/\/skills.visual-paradigm.com\/pt\/#organization","name":"Visual Paradigm Skills Portugu\u00eas","url":"https:\/\/skills.visual-paradigm.com\/pt\/","logo":{"@type":"ImageObject","inLanguage":"pt-PT","@id":"https:\/\/skills.visual-paradigm.com\/pt\/#\/schema\/logo\/image\/","url":"https:\/\/skills.visual-paradigm.com\/pt\/wp-content\/uploads\/sites\/9\/2026\/02\/favicon.svg","contentUrl":"https:\/\/skills.visual-paradigm.com\/pt\/wp-content\/uploads\/sites\/9\/2026\/02\/favicon.svg","width":70,"height":70,"caption":"Visual Paradigm Skills Portugu\u00eas"},"image":{"@id":"https:\/\/skills.visual-paradigm.com\/pt\/#\/schema\/logo\/image\/"}}]}},"_links":{"self":[{"href":"https:\/\/skills.visual-paradigm.com\/pt\/wp-json\/wp\/v2\/docs\/946","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/skills.visual-paradigm.com\/pt\/wp-json\/wp\/v2\/docs"}],"about":[{"href":"https:\/\/skills.visual-paradigm.com\/pt\/wp-json\/wp\/v2\/types\/docs"}],"author":[{"embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/pt\/wp-json\/wp\/v2\/users\/1"}],"version-history":[{"count":0,"href":"https:\/\/skills.visual-paradigm.com\/pt\/wp-json\/wp\/v2\/docs\/946\/revisions"}],"up":[{"embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/pt\/wp-json\/wp\/v2\/docs\/945"}],"wp:attachment":[{"href":"https:\/\/skills.visual-paradigm.com\/pt\/wp-json\/wp\/v2\/media?parent=946"}],"wp:term":[{"taxonomy":"doc_tag","embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/pt\/wp-json\/wp\/v2\/doc_tag?post=946"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}