{"id":937,"date":"2026-02-25T10:32:32","date_gmt":"2026-02-25T10:32:32","guid":{"rendered":"https:\/\/skills.visual-paradigm.com\/fr\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-mapping\/crc-responsibility-to-method\/"},"modified":"2026-02-25T10:32:32","modified_gmt":"2026-02-25T10:32:32","slug":"crc-responsibility-to-method","status":"publish","type":"docs","link":"https:\/\/skills.visual-paradigm.com\/fr\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-mapping\/crc-responsibility-to-method\/","title":{"rendered":"Responsibilities Become Operations and Attributes"},"content":{"rendered":"<p>Every operation in your class diagram started as a CRC responsibility. That\u2019s the truth. No exceptions.<\/p>\n<p>When you write \u201ccalculate total\u201d on a CRC card, you\u2019re not just brainstorming\u2014you\u2019re defining a method. The trick isn\u2019t just recognizing this, but distinguishing whether that responsibility becomes a method, an attribute, or a constraint. It\u2019s the difference between a sketch and a working design.<\/p>\n<p>Over two decades of guiding teams through CRC-to-UML transitions has taught me this: the most common mistake isn\u2019t over-engineering\u2014it\u2019s misclassifying what a responsibility actually is.<\/p>\n<p>This chapter gives you the tools to turn every CRC responsibility into a precise UML operation or attribute. You\u2019ll learn how to read the intention behind the wording, avoid common pitfalls, and build models that reflect real behavior\u2014not just structure.<\/p>\n<h2>Understanding the Nature of CRC Responsibilities<\/h2>\n<p>Before mapping, you must understand what a CRC responsibility truly is.<\/p>\n<p>It\u2019s not a task. Not a feature. It\u2019s an <strong>action<\/strong> or <strong>state<\/strong> tied to an object\u2019s role in a collaboration.<\/p>\n<p>Think of it as a promise: \u201cThis class will do X\u201d or \u201cThis class will hold Y.\u201d The key is whether it describes behavior (do) or data (hold).<\/p>\n<h3>How to Identify Behavioral vs. Data Responsibilities<\/h3>\n<p>Use this simple rule: if the responsibility involves an action verb, it\u2019s likely a method. If it describes a value or property, it\u2019s likely an attribute.<\/p>\n<ul>\n<li><strong>Behavioral<\/strong>: <em>calculate total<\/em>, <em>validate input<\/em>, <em>send confirmation<\/em> \u2192 Operation<\/li>\n<li><strong>Data-related<\/strong>: <em>store customer details<\/em>, <em>track order status<\/em>, <em>keep payment records<\/em> \u2192 Attribute<\/li>\n<\/ul>\n<p>But don\u2019t stop here. Some responsibilities are subtle. \u201cManage inventory levels\u201d sounds behavioral\u2014but if it refers to a <em>state<\/em>, it might be an attribute like <code>inventoryCount<\/code>.<\/p>\n<h2>From Responsibility to UML Method: The Three-Step Process<\/h2>\n<p>Turning a CRC responsibility into a UML method isn\u2019t just renaming\u2014it\u2019s refining intent into proper syntax.<\/p>\n<h3>Step 1: Extract the Verb and Object<\/h3>\n<p>Look for the action and what it acts on. In \u201ccalculate total for order,\u201d the verb is \u201ccalculate,\u201d and the object is \u201ctotal for order.\u201d<\/p>\n<p>That gives you:<\/p>\n<ul>\n<li>Operation name: <code>calculateTotalForOrder<\/code><\/li>\n<li>Parameters: <code>order: Order<\/code><\/li>\n<li>Return type: <code>double<\/code> or <code>Money<\/code><\/li>\n<\/ul>\n<p>Simple, but often missed when teams rush to code.<\/p>\n<h3>Step 2: Determine Visibility and Return Type<\/h3>\n<p>Use this decision tree:<\/p>\n<ul>\n<li>If the method modifies internal state or affects other objects \u2192 <code>public<\/code> or <code>protected<\/code><\/li>\n<li>If it only retrieves information \u2192 <code>public<\/code> or <code>private<\/code>, depending on access needs<\/li>\n<li>If it returns a value, define the type explicitly. Don\u2019t assume <code>Object<\/code> or <code>String<\/code>.<\/li>\n<\/ul>\n<p>For example, \u201cvalidate input\u201d isn\u2019t just <code>boolean validateInput()<\/code>. It\u2019s better as <code>boolean validateInput(String input)<\/code>, with a clear return meaning.<\/p>\n<h3>Step 3: Avoid Overloading with Vague Concepts<\/h3>\n<p>Weak responsibilities like \u201cdo something\u201d or \u201chandle data\u201d are red flags.<\/p>\n<p>Ask: What exactly is being done? Who is it done to? What\u2019s the outcome?<\/p>\n<p>Instead of:<\/p>\n<pre><code>handle data\n<\/code><\/pre>\n<p>Ask: <em>What kind of data? Who triggers this? What should happen?<\/em><\/p>\n<p>Refine it to:<\/p>\n<ul>\n<li><code>processPayment(Payment payment)<\/code><\/li>\n<li><code>updateInventoryAfterShipment(Shipment shipment)<\/code><\/li>\n<\/ul>\n<p>This isn\u2019t just cleaner\u2014it\u2019s testable and traceable.<\/p>\n<h2>From Responsibility to Attribute: When Data Rules<\/h2>\n<p>Not every responsibility becomes a method. Some are about <strong>state<\/strong>.<\/p>\n<p>These are the ones that describe what the object <em>stores<\/em>, <em>tracks<\/em>, or <em>maintains<\/em>.<\/p>\n<h3>Recognizing Data-Centric Responsibilities<\/h3>\n<p>Look for these keywords:<\/p>\n<ul>\n<li>\u201ckeep\u201d, \u201cmaintain\u201d, \u201ctrack\u201d, \u201cstore\u201d, \u201crecord\u201d, \u201chold\u201d<\/li>\n<li>\u201ctotal\u201d, \u201ccount\u201d, \u201cstatus\u201d, \u201cbalance\u201d, \u201cdate\u201d<\/li>\n<\/ul>\n<p>For example:<\/p>\n<ul>\n<li><em>track order status<\/em> \u2192 <code>status: OrderStatus<\/code><\/li>\n<li><em>store customer details<\/em> \u2192 <code>customerDetails: Map&lt;String, Object&gt;<\/code><\/li>\n<li><em>keep payment records<\/em> \u2192 <code>paymentHistory: List&lt;Payment&gt;<\/code><\/li>\n<\/ul>\n<p>These aren\u2019t methods. They\u2019re <strong>state variables<\/strong>.<\/p>\n<h3>When to Extract Attributes: A Decision Matrix<\/h3>\n<table>\n<tbody>\n<tr>\n<th>Responsibility<\/th>\n<th>Reason to Extract as Attribute<\/th>\n<th>Example<\/th>\n<\/tr>\n<tr>\n<td>track delivery date<\/td>\n<td>State value, not an action<\/td>\n<td><code>deliveryDate: LocalDate<\/code><\/td>\n<\/tr>\n<tr>\n<td>calculate tax<\/td>\n<td>Behavior \u2192 method<\/td>\n<td><code>calculateTax(amount: double): double<\/code><\/td>\n<\/tr>\n<tr>\n<td>store order history<\/td>\n<td>Collection of data<\/td>\n<td><code>orderHistory: List&lt;Order&gt;<\/code><\/td>\n<\/tr>\n<tr>\n<td>manage inventory levels<\/td>\n<td>State tracker<\/td>\n<td><code>inventoryCount: int<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>This table isn\u2019t just for reference\u2014it\u2019s a filter. Use it to avoid misclassifying responsibilities.<\/p>\n<h2>Handling Constraints and Implicit Rules<\/h2>\n<p>Some CRC responsibilities aren\u2019t operations or attributes\u2014they\u2019re <strong>constraints<\/strong>.<\/p>\n<p>They define invariants or business rules. For example:<\/p>\n<ul>\n<li><em>total must be positive<\/em><\/li>\n<li><em>order cannot be shipped if not approved<\/em><\/li>\n<li><em>customer must have valid ID<\/em><\/li>\n<\/ul>\n<p>These don\u2019t become methods or attributes directly. Instead, they become:<\/p>\n<ul>\n<li>Pre-conditions or post-conditions in method contracts<\/li>\n<li>Class-level invariant annotations (e.g., <code>invariant: total &gt; 0<\/code>)<\/li>\n<li>Validation logic in constructors or setters<\/li>\n<\/ul>\n<p>For example:<\/p>\n<pre><code>operation calculateTotal(): Money\n  pre: order.isApproved()\n  post: total &gt; 0\n<\/code><\/pre>\n<p>This preserves the rule without bloating the class with unnecessary methods.<\/p>\n<h2>Best Practices for Consistent Responsibility Mapping<\/h2>\n<p>Here\u2019s what I\u2019ve seen work best across teams\u2014no fluff, just principles.<\/p>\n<ol>\n<li><strong>Use active verbs for operations<\/strong>: \u201csend email,\u201d \u201cupdate status,\u201d \u201ccalculate tax.\u201d Never \u201cis sending\u201d or \u201cdoing.\u201d<\/li>\n<li><strong>Extract attributes only when they represent state<\/strong>: If the object doesn\u2019t store it, don\u2019t make it an attribute.<\/li>\n<li><strong>Be consistent with naming<\/strong>: Use camelCase or PascalCase uniformly. Avoid mixing \u201cgetTotal\u201d and \u201cget_total\u201d.<\/li>\n<li><strong>Group related responsibilities during refinement<\/strong>: Don\u2019t split \u201ccalculate total\u201d and \u201capply discount\u201d unless the logic is modular.<\/li>\n<li><strong>Review for redundancy<\/strong>: If two responsibilities do the same thing, merge them. If one is unused, question it.<\/li>\n<\/ol>\n<p>These aren\u2019t rules. They\u2019re habits. And habits shape code quality more than any diagram.<\/p>\n<h2>Common Mistakes in Responsibility Mapping<\/h2>\n<p>Even experienced teams make these errors. Watch for them:<\/p>\n<ul>\n<li><strong>Overloading methods<\/strong>: \u201chandle data\u201d or \u201cdo something\u201d that leads to long, ambiguous methods.<\/li>\n<li><strong>Creating attributes from behavior<\/strong>: \u201cmanage order\u201d as an attribute instead of a method.<\/li>\n<li><strong>Ignoring return types<\/strong>: Writing methods with no return type, especially when logic should return a value.<\/li>\n<li><strong>Using attributes for complex logic<\/strong>: Storing \u201ctax calculation\u201d as a field instead of computing it on demand.<\/li>\n<li><strong>Misreading collaboration cues<\/strong>: Confusing a responsibility for a class\u2019s role in an interaction with a method.<\/li>\n<\/ul>\n<p>Fix them early. The sooner you spot a mismatch, the less you\u2019ll pay in rework.<\/p>\n<h2>Frequently Asked Questions<\/h2>\n<h3>How do I know if a CRC responsibility should be a method or an attribute?<\/h3>\n<p>Ask: Does it describe an action (do) or a state (have)? If it\u2019s an action, make it a method. If it\u2019s a value the object holds, make it an attribute. Use the decision matrix above to guide you.<\/p>\n<h3>Can a single CRC responsibility become multiple UML operations?<\/h3>\n<p>Yes, but only if it\u2019s ambiguous or covers multiple concerns. For example, \u201cprocess order\u201d should be split into \u201cvalidateOrder,\u201d \u201ccalculateTotal,\u201d and \u201cconfirmShipment\u201d if they\u2019re independent. Keep methods focused.<\/p>\n<h3>What if my CRC responsibility is phrased as a noun, like \u201ccustomer list\u201d?<\/h3>\n<p>That\u2019s a strong signal for an attribute. \u201ccustomerList\u201d \u2192 <code>customerList: List&lt;Customer&gt;<\/code>. But verify it\u2019s not meant to be a method like \u201cretrieveCustomerList()\u201d.<\/p>\n<h3>Should I use the same method name as the CRC responsibility?<\/h3>\n<p>Not necessarily. Use the CRC as a starting point. Refine it into a proper, unambiguous method name. \u201cget data\u201d becomes \u201cfetchOrderHistory()\u201d. Clarity beats literalness.<\/p>\n<h3>Can I treat a constraint as a method?<\/h3>\n<p>Only if it involves behavior. A business rule like \u201ctotal must be positive\u201d should be enforced in a method (e.g., <code>setTotal<\/code>) via a validation check. But the rule itself is not a method\u2014it\u2019s a condition.<\/p>\n<h3>How do I avoid creating unnecessary methods from vague CRC responsibilities?<\/h3>\n<p>Apply the \u201cintent test\u201d: Ask, \u201cWhat must the system do?\u201d and \u201cWho triggers this?\u201d If the answer is vague, refine the responsibility before converting it. Use checklists like the one above to filter out weak concepts.<\/p>\n<p>Remember: Every method should have a clear reason to exist. If you can\u2019t explain its purpose in one sentence, it probably doesn\u2019t belong.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Every operation in your class diagram started as a CRC responsibility. That\u2019s the truth. No exceptions. When you write \u201ccalculate total\u201d on a CRC card, you\u2019re not just brainstorming\u2014you\u2019re defining a method. The trick isn\u2019t just recognizing this, but distinguishing whether that responsibility becomes a method, an attribute, or a constraint. It\u2019s the difference between [&hellip;]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":935,"menu_order":1,"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-937","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 Responsibility to Method: From Ideas to UML Operations<\/title>\n<meta name=\"description\" content=\"Learn how to transform CRC responsibilities into UML operations and attributes. Master the art of responsibility mapping UML with practical guidance, real examples, and consistency rules for robust class design.\" \/>\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\/fr\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-mapping\/crc-responsibility-to-method\/\" \/>\n<meta property=\"og:locale\" content=\"fr_FR\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"CRC Responsibility to Method: From Ideas to UML Operations\" \/>\n<meta property=\"og:description\" content=\"Learn how to transform CRC responsibilities into UML operations and attributes. Master the art of responsibility mapping UML with practical guidance, real examples, and consistency rules for robust class design.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/skills.visual-paradigm.com\/fr\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-mapping\/crc-responsibility-to-method\/\" \/>\n<meta property=\"og:site_name\" content=\"Visual Paradigm Skills Fran\u00e7ais\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Dur\u00e9e de lecture estim\u00e9e\" \/>\n\t<meta name=\"twitter:data1\" content=\"6 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/fr\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-mapping\/crc-responsibility-to-method\/\",\"url\":\"https:\/\/skills.visual-paradigm.com\/fr\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-mapping\/crc-responsibility-to-method\/\",\"name\":\"CRC Responsibility to Method: From Ideas to UML Operations\",\"isPartOf\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/fr\/#website\"},\"datePublished\":\"2026-02-25T10:32:32+00:00\",\"description\":\"Learn how to transform CRC responsibilities into UML operations and attributes. Master the art of responsibility mapping UML with practical guidance, real examples, and consistency rules for robust class design.\",\"breadcrumb\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/fr\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-mapping\/crc-responsibility-to-method\/#breadcrumb\"},\"inLanguage\":\"fr-FR\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/skills.visual-paradigm.com\/fr\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-mapping\/crc-responsibility-to-method\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/fr\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-mapping\/crc-responsibility-to-method\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/skills.visual-paradigm.com\/fr\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"From CRC Cards to Class Diagrams\",\"item\":\"https:\/\/skills.visual-paradigm.com\/fr\/docs\/crc-cards-to-class-diagrams\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Mapping CRC Elements to Class Diagram Components\",\"item\":\"https:\/\/skills.visual-paradigm.com\/fr\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-mapping\/\"},{\"@type\":\"ListItem\",\"position\":4,\"name\":\"Responsibilities Become Operations and Attributes\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/fr\/#website\",\"url\":\"https:\/\/skills.visual-paradigm.com\/fr\/\",\"name\":\"Visual Paradigm Skills Fran\u00e7ais\",\"description\":\"\",\"publisher\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/fr\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/skills.visual-paradigm.com\/fr\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"fr-FR\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/fr\/#organization\",\"name\":\"Visual Paradigm Skills Fran\u00e7ais\",\"url\":\"https:\/\/skills.visual-paradigm.com\/fr\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"fr-FR\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/fr\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/skills.visual-paradigm.com\/fr\/wp-content\/uploads\/sites\/6\/2026\/02\/favicon.svg\",\"contentUrl\":\"https:\/\/skills.visual-paradigm.com\/fr\/wp-content\/uploads\/sites\/6\/2026\/02\/favicon.svg\",\"width\":70,\"height\":70,\"caption\":\"Visual Paradigm Skills Fran\u00e7ais\"},\"image\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/fr\/#\/schema\/logo\/image\/\"}}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"CRC Responsibility to Method: From Ideas to UML Operations","description":"Learn how to transform CRC responsibilities into UML operations and attributes. Master the art of responsibility mapping UML with practical guidance, real examples, and consistency rules for robust class design.","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\/fr\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-mapping\/crc-responsibility-to-method\/","og_locale":"fr_FR","og_type":"article","og_title":"CRC Responsibility to Method: From Ideas to UML Operations","og_description":"Learn how to transform CRC responsibilities into UML operations and attributes. Master the art of responsibility mapping UML with practical guidance, real examples, and consistency rules for robust class design.","og_url":"https:\/\/skills.visual-paradigm.com\/fr\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-mapping\/crc-responsibility-to-method\/","og_site_name":"Visual Paradigm Skills Fran\u00e7ais","twitter_card":"summary_large_image","twitter_misc":{"Dur\u00e9e de lecture estim\u00e9e":"6 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/skills.visual-paradigm.com\/fr\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-mapping\/crc-responsibility-to-method\/","url":"https:\/\/skills.visual-paradigm.com\/fr\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-mapping\/crc-responsibility-to-method\/","name":"CRC Responsibility to Method: From Ideas to UML Operations","isPartOf":{"@id":"https:\/\/skills.visual-paradigm.com\/fr\/#website"},"datePublished":"2026-02-25T10:32:32+00:00","description":"Learn how to transform CRC responsibilities into UML operations and attributes. Master the art of responsibility mapping UML with practical guidance, real examples, and consistency rules for robust class design.","breadcrumb":{"@id":"https:\/\/skills.visual-paradigm.com\/fr\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-mapping\/crc-responsibility-to-method\/#breadcrumb"},"inLanguage":"fr-FR","potentialAction":[{"@type":"ReadAction","target":["https:\/\/skills.visual-paradigm.com\/fr\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-mapping\/crc-responsibility-to-method\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/skills.visual-paradigm.com\/fr\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-mapping\/crc-responsibility-to-method\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/skills.visual-paradigm.com\/fr\/"},{"@type":"ListItem","position":2,"name":"From CRC Cards to Class Diagrams","item":"https:\/\/skills.visual-paradigm.com\/fr\/docs\/crc-cards-to-class-diagrams\/"},{"@type":"ListItem","position":3,"name":"Mapping CRC Elements to Class Diagram Components","item":"https:\/\/skills.visual-paradigm.com\/fr\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-mapping\/"},{"@type":"ListItem","position":4,"name":"Responsibilities Become Operations and Attributes"}]},{"@type":"WebSite","@id":"https:\/\/skills.visual-paradigm.com\/fr\/#website","url":"https:\/\/skills.visual-paradigm.com\/fr\/","name":"Visual Paradigm Skills Fran\u00e7ais","description":"","publisher":{"@id":"https:\/\/skills.visual-paradigm.com\/fr\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/skills.visual-paradigm.com\/fr\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"fr-FR"},{"@type":"Organization","@id":"https:\/\/skills.visual-paradigm.com\/fr\/#organization","name":"Visual Paradigm Skills Fran\u00e7ais","url":"https:\/\/skills.visual-paradigm.com\/fr\/","logo":{"@type":"ImageObject","inLanguage":"fr-FR","@id":"https:\/\/skills.visual-paradigm.com\/fr\/#\/schema\/logo\/image\/","url":"https:\/\/skills.visual-paradigm.com\/fr\/wp-content\/uploads\/sites\/6\/2026\/02\/favicon.svg","contentUrl":"https:\/\/skills.visual-paradigm.com\/fr\/wp-content\/uploads\/sites\/6\/2026\/02\/favicon.svg","width":70,"height":70,"caption":"Visual Paradigm Skills Fran\u00e7ais"},"image":{"@id":"https:\/\/skills.visual-paradigm.com\/fr\/#\/schema\/logo\/image\/"}}]}},"_links":{"self":[{"href":"https:\/\/skills.visual-paradigm.com\/fr\/wp-json\/wp\/v2\/docs\/937","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/skills.visual-paradigm.com\/fr\/wp-json\/wp\/v2\/docs"}],"about":[{"href":"https:\/\/skills.visual-paradigm.com\/fr\/wp-json\/wp\/v2\/types\/docs"}],"author":[{"embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/fr\/wp-json\/wp\/v2\/users\/1"}],"version-history":[{"count":0,"href":"https:\/\/skills.visual-paradigm.com\/fr\/wp-json\/wp\/v2\/docs\/937\/revisions"}],"up":[{"embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/fr\/wp-json\/wp\/v2\/docs\/935"}],"wp:attachment":[{"href":"https:\/\/skills.visual-paradigm.com\/fr\/wp-json\/wp\/v2\/media?parent=937"}],"wp:term":[{"taxonomy":"doc_tag","embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/fr\/wp-json\/wp\/v2\/doc_tag?post=937"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}