{"id":1679,"date":"2026-02-25T10:44:48","date_gmt":"2026-02-25T10:44:48","guid":{"rendered":"https:\/\/skills.visual-paradigm.com\/cn\/docs\/uml-basics-diagrams-for-beginners\/mastering-class-diagrams-beginner\/uml-class-relationships-draw-with-confidence\/"},"modified":"2026-02-25T10:44:48","modified_gmt":"2026-02-25T10:44:48","slug":"uml-class-relationships-draw-with-confidence","status":"publish","type":"docs","link":"https:\/\/skills.visual-paradigm.com\/cn\/docs\/uml-basics-diagrams-for-beginners\/mastering-class-diagrams-beginner\/uml-class-relationships-draw-with-confidence\/","title":{"rendered":"How to Draw Basic Class Relationships"},"content":{"rendered":"<p>When you\u2019re building a class diagram, how do you decide whether to connect two classes with a solid line, a line with a triangle, or a filled diamond? This is the question that trips up countless beginners.<\/p>\n<p>My 20+ years working with teams on real software projects have taught me: clarity in relationships comes not from memorizing symbols, but from understanding their meaning in context.<\/p>\n<p>Here, you\u2019ll learn how to draw and interpret the four foundational UML class relationships\u2014association, inheritance, aggregation, and composition\u2014using real-world examples you can apply immediately.<\/p>\n<h2>Understanding the Core Relationships<\/h2>\n<p>UML class relationships are the backbone of structural modeling. They clarify how objects interact, share data, and depend on one another.<\/p>\n<p>Each relationship has a specific purpose and notation. Getting them right means your diagrams become tools for communication, not just visual clutter.<\/p>\n<h3>1. Association: A Connection Between Classes<\/h3>\n<p>An association represents a structural link between two classes. It shows that one class uses or interacts with another.<\/p>\n<p>Use solid lines with open arrowheads to indicate direction. The arrow points to the class being referenced.<\/p>\n<p>Example: A <code>Student<\/code> enrolls in a <code>Course<\/code>. The <code>Student<\/code> class has a reference to <code>Course<\/code>.<\/p>\n<pre><code>Student  ----&gt; Course\n<\/code><\/pre>\n<p>Always label the association with a role name (e.g., &#8220;enrolls in&#8221;) or a navigability indicator if the relationship is one-way.<\/p>\n<h3>2. Generalization (Inheritance): &#8220;Is-a&#8221; Relationship<\/h3>\n<p>Generalization represents inheritance\u2014when one class is a specialized version of another.<\/p>\n<p>Draw it with a solid line and a hollow triangle pointing to the parent class.<\/p>\n<p>Example: A <code>Car<\/code> is a <code>Vehicle<\/code>. The <code>Car<\/code> class inherits from <code>Vehicle<\/code>.<\/p>\n<pre><code>Vehicle\n   \u25b2\n   |\n   |\n  Car\n<\/code><\/pre>\n<p>Use generalization only when you\u2019re modeling a true &#8220;is-a&#8221; hierarchy. Avoid using it just because two classes share methods.<\/p>\n<p>\ud83d\udca1 Note: In UML, inheritance is also called &#8220;generalization.&#8221; The arrow always points to the generalized (parent) class.<\/p>\n<h3>3. Aggregation: &#8220;Has-a&#8221; (Whole-Part, Loose Coupling)<\/h3>\n<p>Aggregation models a &#8220;has-a&#8221; relationship where one class contains another, but the contained object can exist independently.<\/p>\n<p>Use a hollow diamond at the whole (container) end of a line.<\/p>\n<p>Example: A <code>University<\/code> has a <code>Department<\/code>. If the university closes, the department can still exist elsewhere.<\/p>\n<pre><code>University (\u25cb) ----&gt; Department\n<\/code><\/pre>\n<p>Aggregation is passive. The container doesn\u2019t manage the lifetime of the part.<\/p>\n<h3>4. Composition: &#8220;Has-a&#8221; (Whole-Part, Strong Coupling)<\/h3>\n<p>Composition is a stronger form of aggregation. The part cannot exist independently of the whole.<\/p>\n<p>Use a filled diamond at the whole end of the line.<\/p>\n<p>Example: A <code>House<\/code> has a <code>Room<\/code>. If the house is demolished, the room ceases to exist.<\/p>\n<pre><code>House (\u25cf) ----&gt; Room\n<\/code><\/pre>\n<p>Composition implies ownership. The whole controls the part\u2019s lifecycle.<\/p>\n<h2>When to Use Which Relationship: A Decision Flow<\/h2>\n<p>Knowing the symbols isn\u2019t enough. The real skill is choosing the right one based on your intent.<\/p>\n<p>Ask yourself these questions when drawing class relationships:<\/p>\n<ul>\n<li><strong>Is it inheritance?<\/strong> Does the child class logically extend the parent? Use generalization.<\/li>\n<li><strong>Is there ownership or lifecycle control?<\/strong> Does the whole manage the part\u2019s existence? Use composition.<\/li>\n<li><strong>Can the part survive independently?<\/strong> If yes, use aggregation.<\/li>\n<li><strong>Is there no ownership, just a link?<\/strong> Use association.<\/li>\n<\/ul>\n<h3>Quick Reference Table: UML Relationships<\/h3>\n<table border=\"1\" cellpadding=\"5\" cellspacing=\"0\">\n<tbody>\n<tr>\n<th>Relationship<\/th>\n<th>Notation<\/th>\n<th>Meaning<\/th>\n<th>Use Case<\/th>\n<\/tr>\n<tr>\n<td>Association<\/td>\n<td>Line with open arrow<\/td>\n<td>Interaction or reference<\/td>\n<td>Student enrolls in Course<\/td>\n<\/tr>\n<tr>\n<td>Generalization<\/td>\n<td>Hollow triangle<\/td>\n<td>Is-a (inheritance)<\/td>\n<td>Car is a Vehicle<\/td>\n<\/tr>\n<tr>\n<td>Aggregation<\/td>\n<td>Hollow diamond<\/td>\n<td>Has-a (loose)<\/td>\n<td>University has a Department<\/td>\n<\/tr>\n<tr>\n<td>Composition<\/td>\n<td>Filled diamond<\/td>\n<td>Has-a (strong)<\/td>\n<td>House has a Room<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<h2>Common Mistakes to Avoid<\/h2>\n<p>Even experienced modelers make these errors. Here\u2019s how to avoid them:<\/p>\n<ul>\n<li><strong>Overusing inheritance<\/strong>: Don\u2019t model every shared behavior with inheritance. Favor composition over inheritance when possible.<\/li>\n<li><strong>Confusing aggregation with composition<\/strong>: Ask: \u201cCan the part exist without the whole?\u201d If yes, aggregation. If no, composition.<\/li>\n<li><strong>Using generalization for mere similarity<\/strong>: Just because two classes share methods doesn\u2019t mean one is a subtype. Only use generalization when the \u201cis-a\u201d relationship holds.<\/li>\n<li><strong>Ignoring multiplicity<\/strong>: Always define cardinality (e.g., 1..*, 0..1) to clarify how many objects are involved. This prevents ambiguity.<\/li>\n<\/ul>\n<h2>Practical Example: Library Management System<\/h2>\n<p>Let\u2019s walk through a real-world example to see these relationships in action.<\/p>\n<p>Consider a <code>Library<\/code> that holds <code>Books<\/code>. Each <code>Book<\/code> has a <code>Category<\/code>. A <code>Librarian<\/code> manages the <code>Library<\/code>.<\/p>\n<ul>\n<li><code>Library<\/code> <strong>has<\/strong> <code>Book<\/code> \u2192 Composition (if books are destroyed when the library closes)<\/li>\n<li><code>Book<\/code> <strong>has<\/strong> <code>Category<\/code> \u2192 Aggregation (a category can exist without a book)<\/li>\n<li><code>Librarian<\/code> <strong>manages<\/strong> <code>Library<\/code> \u2192 Association (one-way reference)<\/li>\n<li><code>Book<\/code> <strong>is a<\/strong> <code>Publication<\/code> \u2192 Generalization (inheritance)<\/li>\n<\/ul>\n<p>Using these rules ensures your class diagram reflects actual system behavior.<\/p>\n<h2>Best Practices for Clean, Effective Diagrams<\/h2>\n<p>Even the best relationships become useless if the diagram is cluttered or ambiguous.<\/p>\n<p>Follow these principles:<\/p>\n<ol>\n<li><strong>Keep it simple<\/strong>: Start with core classes and relationships. Add complexity only when needed.<\/li>\n<li><strong>Label roles and multiplicities<\/strong>: Always include role names (e.g., &#8220;borrows&#8221;, &#8220;owns&#8221;) and cardinality (e.g., 1..*).<\/li>\n<li><strong>Use consistent layout<\/strong>: Group related classes together. Align lines to reduce crossing.<\/li>\n<li><strong>Review for meaning<\/strong>: Ask: \u201cDoes this diagram tell me what the system really does?\u201d If not, simplify or clarify.<\/li>\n<\/ol>\n<h2>Frequently Asked Questions<\/h2>\n<h3>What\u2019s the difference between aggregation and composition?<\/h3>\n<p>Aggregation is a &#8220;loose&#8221; has-a relationship where the part can survive independently. Composition is &#8220;strong&#8221; has-a: the part cannot outlive the whole. Use composition when the part\u2019s lifecycle is controlled by the whole.<\/p>\n<h3>Can I use both association and composition in the same diagram?<\/h3>\n<p>Yes. Association shows a general relationship. Composition specifies a stronger, ownership-based link. For example, a <code>Bank<\/code> has a <code>Branch<\/code> (composition), and <code>Branch<\/code> has <code>Customer<\/code> (association).<\/p>\n<h3>When should I avoid inheritance in class diagrams?<\/h3>\n<p>Avoid inheritance if the relationship is not truly &#8220;is-a.&#8221; Use composition to combine behaviors instead. It\u2019s safer, more flexible, and easier to maintain.<\/p>\n<h3>How do I draw multiple relationships between the same two classes?<\/h3>\n<p>Use different roles and multiplicities. For example, a <code>Student<\/code> can be enrolled in multiple <code>Course<\/code>s, and a <code>Course<\/code> can have many <code>Student<\/code>s. Use role names like &#8220;enrolls in&#8221; and &#8220;has students&#8221; to clarify direction.<\/p>\n<h3>Is UML inheritance and association the same as dependency?<\/h3>\n<p>No. Dependency is a weaker, temporary relationship (e.g., a method uses a class as a parameter). Association is permanent and structural. Generalization is inheritance. They are distinct and should not be confused.<\/p>\n<h3>How do I know if I need a generalization or just a simple association?<\/h3>\n<p>If one class extends the behavior of another and is a true subtype (e.g., <code>Student<\/code> extends <code>Person<\/code>), use generalization. If it just uses or references another class, use association.<\/p>\n<h2>Final Thoughts<\/h2>\n<p>Mastering UML class relationships isn\u2019t about memorizing symbols\u2014it\u2019s about thinking clearly about how your objects interact.<\/p>\n<p>Start with simple associations. Then, add inheritance only when you have a true &#8220;is-a&#8221; hierarchy. Use composition and aggregation to model ownership and containment accurately.<\/p>\n<p>Remember: a well-drawn class diagram doesn\u2019t just look good\u2014it prevents misunderstandings, guides implementation, and helps teams align on design.<\/p>\n<p>Now, grab a tool like Visual Paradigm and try drawing a basic class diagram for a simple e-commerce system. Focus on the relationships first. You\u2019ll be surprised how much clarity comes from just getting the connections right.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>When you\u2019re building a class diagram, how do you decide [&hellip;]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":1677,"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-1679","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>UML Class Relationships: Draw with Confidence<\/title>\n<meta name=\"description\" content=\"Learn how to draw basic class relationships in UML with clear guidance on association, inheritance, aggregation, and composition. Master drawing class diagram relationships with real examples and avoid common mistakes.\" \/>\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\/cn\/docs\/uml-basics-diagrams-for-beginners\/mastering-class-diagrams-beginner\/uml-class-relationships-draw-with-confidence\/\" \/>\n<meta property=\"og:locale\" content=\"zh_CN\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"UML Class Relationships: Draw with Confidence\" \/>\n<meta property=\"og:description\" content=\"Learn how to draw basic class relationships in UML with clear guidance on association, inheritance, aggregation, and composition. Master drawing class diagram relationships with real examples and avoid common mistakes.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/skills.visual-paradigm.com\/cn\/docs\/uml-basics-diagrams-for-beginners\/mastering-class-diagrams-beginner\/uml-class-relationships-draw-with-confidence\/\" \/>\n<meta property=\"og:site_name\" content=\"Visual Paradigm Skills \u7b80\u4f53\u4e2d\u6587\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"\u9884\u8ba1\u9605\u8bfb\u65f6\u95f4\" \/>\n\t<meta name=\"twitter:data1\" content=\"6 \u5206\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/cn\/docs\/uml-basics-diagrams-for-beginners\/mastering-class-diagrams-beginner\/uml-class-relationships-draw-with-confidence\/\",\"url\":\"https:\/\/skills.visual-paradigm.com\/cn\/docs\/uml-basics-diagrams-for-beginners\/mastering-class-diagrams-beginner\/uml-class-relationships-draw-with-confidence\/\",\"name\":\"UML Class Relationships: Draw with Confidence\",\"isPartOf\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/cn\/#website\"},\"datePublished\":\"2026-02-25T10:44:48+00:00\",\"description\":\"Learn how to draw basic class relationships in UML with clear guidance on association, inheritance, aggregation, and composition. Master drawing class diagram relationships with real examples and avoid common mistakes.\",\"breadcrumb\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/cn\/docs\/uml-basics-diagrams-for-beginners\/mastering-class-diagrams-beginner\/uml-class-relationships-draw-with-confidence\/#breadcrumb\"},\"inLanguage\":\"zh-Hans\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/skills.visual-paradigm.com\/cn\/docs\/uml-basics-diagrams-for-beginners\/mastering-class-diagrams-beginner\/uml-class-relationships-draw-with-confidence\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/cn\/docs\/uml-basics-diagrams-for-beginners\/mastering-class-diagrams-beginner\/uml-class-relationships-draw-with-confidence\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/skills.visual-paradigm.com\/cn\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"UML Basics: Diagrams for Beginners\",\"item\":\"https:\/\/skills.visual-paradigm.com\/cn\/docs\/uml-basics-diagrams-for-beginners\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Mastering Class Diagrams as a Beginner\",\"item\":\"https:\/\/skills.visual-paradigm.com\/cn\/docs\/uml-basics-diagrams-for-beginners\/mastering-class-diagrams-beginner\/\"},{\"@type\":\"ListItem\",\"position\":4,\"name\":\"How to Draw Basic Class Relationships\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/cn\/#website\",\"url\":\"https:\/\/skills.visual-paradigm.com\/cn\/\",\"name\":\"Visual Paradigm Skills \u7b80\u4f53\u4e2d\u6587\",\"description\":\"\",\"publisher\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/cn\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/skills.visual-paradigm.com\/cn\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"zh-Hans\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/cn\/#organization\",\"name\":\"Visual Paradigm Skills \u7b80\u4f53\u4e2d\u6587\",\"url\":\"https:\/\/skills.visual-paradigm.com\/cn\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"zh-Hans\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/cn\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/skills.visual-paradigm.com\/cn\/wp-content\/uploads\/sites\/3\/2026\/02\/favicon.svg\",\"contentUrl\":\"https:\/\/skills.visual-paradigm.com\/cn\/wp-content\/uploads\/sites\/3\/2026\/02\/favicon.svg\",\"width\":70,\"height\":70,\"caption\":\"Visual Paradigm Skills \u7b80\u4f53\u4e2d\u6587\"},\"image\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/cn\/#\/schema\/logo\/image\/\"}}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"UML Class Relationships: Draw with Confidence","description":"Learn how to draw basic class relationships in UML with clear guidance on association, inheritance, aggregation, and composition. Master drawing class diagram relationships with real examples and avoid common mistakes.","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\/cn\/docs\/uml-basics-diagrams-for-beginners\/mastering-class-diagrams-beginner\/uml-class-relationships-draw-with-confidence\/","og_locale":"zh_CN","og_type":"article","og_title":"UML Class Relationships: Draw with Confidence","og_description":"Learn how to draw basic class relationships in UML with clear guidance on association, inheritance, aggregation, and composition. Master drawing class diagram relationships with real examples and avoid common mistakes.","og_url":"https:\/\/skills.visual-paradigm.com\/cn\/docs\/uml-basics-diagrams-for-beginners\/mastering-class-diagrams-beginner\/uml-class-relationships-draw-with-confidence\/","og_site_name":"Visual Paradigm Skills \u7b80\u4f53\u4e2d\u6587","twitter_card":"summary_large_image","twitter_misc":{"\u9884\u8ba1\u9605\u8bfb\u65f6\u95f4":"6 \u5206"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/skills.visual-paradigm.com\/cn\/docs\/uml-basics-diagrams-for-beginners\/mastering-class-diagrams-beginner\/uml-class-relationships-draw-with-confidence\/","url":"https:\/\/skills.visual-paradigm.com\/cn\/docs\/uml-basics-diagrams-for-beginners\/mastering-class-diagrams-beginner\/uml-class-relationships-draw-with-confidence\/","name":"UML Class Relationships: Draw with Confidence","isPartOf":{"@id":"https:\/\/skills.visual-paradigm.com\/cn\/#website"},"datePublished":"2026-02-25T10:44:48+00:00","description":"Learn how to draw basic class relationships in UML with clear guidance on association, inheritance, aggregation, and composition. Master drawing class diagram relationships with real examples and avoid common mistakes.","breadcrumb":{"@id":"https:\/\/skills.visual-paradigm.com\/cn\/docs\/uml-basics-diagrams-for-beginners\/mastering-class-diagrams-beginner\/uml-class-relationships-draw-with-confidence\/#breadcrumb"},"inLanguage":"zh-Hans","potentialAction":[{"@type":"ReadAction","target":["https:\/\/skills.visual-paradigm.com\/cn\/docs\/uml-basics-diagrams-for-beginners\/mastering-class-diagrams-beginner\/uml-class-relationships-draw-with-confidence\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/skills.visual-paradigm.com\/cn\/docs\/uml-basics-diagrams-for-beginners\/mastering-class-diagrams-beginner\/uml-class-relationships-draw-with-confidence\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/skills.visual-paradigm.com\/cn\/"},{"@type":"ListItem","position":2,"name":"UML Basics: Diagrams for Beginners","item":"https:\/\/skills.visual-paradigm.com\/cn\/docs\/uml-basics-diagrams-for-beginners\/"},{"@type":"ListItem","position":3,"name":"Mastering Class Diagrams as a Beginner","item":"https:\/\/skills.visual-paradigm.com\/cn\/docs\/uml-basics-diagrams-for-beginners\/mastering-class-diagrams-beginner\/"},{"@type":"ListItem","position":4,"name":"How to Draw Basic Class Relationships"}]},{"@type":"WebSite","@id":"https:\/\/skills.visual-paradigm.com\/cn\/#website","url":"https:\/\/skills.visual-paradigm.com\/cn\/","name":"Visual Paradigm Skills \u7b80\u4f53\u4e2d\u6587","description":"","publisher":{"@id":"https:\/\/skills.visual-paradigm.com\/cn\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/skills.visual-paradigm.com\/cn\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"zh-Hans"},{"@type":"Organization","@id":"https:\/\/skills.visual-paradigm.com\/cn\/#organization","name":"Visual Paradigm Skills \u7b80\u4f53\u4e2d\u6587","url":"https:\/\/skills.visual-paradigm.com\/cn\/","logo":{"@type":"ImageObject","inLanguage":"zh-Hans","@id":"https:\/\/skills.visual-paradigm.com\/cn\/#\/schema\/logo\/image\/","url":"https:\/\/skills.visual-paradigm.com\/cn\/wp-content\/uploads\/sites\/3\/2026\/02\/favicon.svg","contentUrl":"https:\/\/skills.visual-paradigm.com\/cn\/wp-content\/uploads\/sites\/3\/2026\/02\/favicon.svg","width":70,"height":70,"caption":"Visual Paradigm Skills \u7b80\u4f53\u4e2d\u6587"},"image":{"@id":"https:\/\/skills.visual-paradigm.com\/cn\/#\/schema\/logo\/image\/"}}]}},"_links":{"self":[{"href":"https:\/\/skills.visual-paradigm.com\/cn\/wp-json\/wp\/v2\/docs\/1679","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/skills.visual-paradigm.com\/cn\/wp-json\/wp\/v2\/docs"}],"about":[{"href":"https:\/\/skills.visual-paradigm.com\/cn\/wp-json\/wp\/v2\/types\/docs"}],"author":[{"embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/cn\/wp-json\/wp\/v2\/users\/1"}],"version-history":[{"count":0,"href":"https:\/\/skills.visual-paradigm.com\/cn\/wp-json\/wp\/v2\/docs\/1679\/revisions"}],"up":[{"embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/cn\/wp-json\/wp\/v2\/docs\/1677"}],"wp:attachment":[{"href":"https:\/\/skills.visual-paradigm.com\/cn\/wp-json\/wp\/v2\/media?parent=1679"}],"wp:term":[{"taxonomy":"doc_tag","embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/cn\/wp-json\/wp\/v2\/doc_tag?post=1679"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}