A class diagram is a UML structure diagram that describes the classes in a system, the attributes and methods each class holds, and the relationships between them — inheritance, composition, aggregation, and association. It is the most widely used UML diagram for designing object-oriented software and documenting a domain model.
Diagramming AI turns a plain-English description of your classes into an editable Mermaid or PlantUML class diagram in seconds. Describe the types in your system and how they relate, and the AI generates ready-to-edit code with the correct UML relationship arrows, which you can then refine conversationally.
Each class is drawn as a box with three compartments: the class name, its attributes (fields), and its operations (methods). Visibility markers indicate access level — "+" for public, "-" for private, "#" for protected. This compact notation lets a single diagram capture the full static structure of a codebase or domain model.
Relationships carry specific meanings. A hollow triangle arrow means inheritance (a subclass extends a superclass). A filled diamond means composition (the part cannot exist without the whole), while a hollow diamond means aggregation (a looser "has-a" relationship). A plain line or open arrow represents a general association, often annotated with multiplicity such as "1" or "0..*".
Begin by naming your classes and listing the key attributes and methods of each. Then describe how they relate — which classes inherit from which, which contain others, and which simply reference one another. Diagramming AI converts that into Mermaid or PlantUML class-diagram code with the appropriate UML arrows.
Iterate in the chat to evolve the design: "make Order contain a list of OrderItems", "add an abstract base class Shape with subclasses Circle and Square", or "mark the balance field as private". Each change updates the editable code, and you can export the diagram or copy the syntax into your design docs.
Scenario: An abstract base class with two concrete subclasses, demonstrating UML generalization (inheritance) with overridden methods.
Instruction text for AI
Create a UML class diagram with an abstract class Animal that has a name attribute and an abstract makeSound method, and two subclasses Dog and Cat that each implement makeSound.Generated Diagram (Mermaid)
classDiagram
class Animal {
<<abstract>>
+String name
+int age
+makeSound() void
+move() void
}
class Dog {
+String breed
+makeSound() void
+fetch() void
}
class Cat {
+boolean indoor
+makeSound() void
+scratch() void
}
Animal <|-- Dog
Animal <|-- CatScenario: An order domain model where an order is composed of order items and associated with a customer, showing composition and a one-to-many association with multiplicity.
Instruction text for AI
Draw a class diagram for an ordering system: a Customer can have many Orders, an Order is composed of one or more OrderItems, and each OrderItem references a Product. Include key attributes and methods.Generated Diagram (Mermaid)
classDiagram
class Customer {
+int id
+String name
+String email
+placeOrder() Order
}
class Order {
+int id
+Date createdAt
+String status
+total() double
}
class OrderItem {
+int quantity
+double unitPrice
+subtotal() double
}
class Product {
+int id
+String name
+double price
}
Customer "1" --> "0..*" Order : places
Order "1" *-- "1..*" OrderItem : contains
OrderItem "0..*" --> "1" Product : refers toScenario: A payment system where concrete processors implement a common interface, shown in PlantUML with the realization (implements) relationship.
Instruction text for AI
Generate a PlantUML class diagram with a PaymentProcessor interface that declares a pay method, implemented by StripeProcessor and PaypalProcessor classes, each with its own apiKey field.Generated Diagram (PlantUML)
@startuml
interface PaymentProcessor {
+pay(amount: double): boolean
+refund(txId: string): boolean
}
class StripeProcessor {
-apiKey: string
+pay(amount: double): boolean
+refund(txId: string): boolean
}
class PaypalProcessor {
-clientId: string
-secret: string
+pay(amount: double): boolean
+refund(txId: string): boolean
}
PaymentProcessor <|.. StripeProcessor
PaymentProcessor <|.. PaypalProcessor
@endumlA UML class diagram documents the static structure of an object-oriented system: its classes, their attributes and methods, and the relationships between them such as inheritance, composition, and association. Developers use class diagrams to design software, communicate architecture, and document a domain model.
Yes. Describe your classes and how they relate in plain English, and Diagramming AI generates an editable Mermaid or PlantUML class diagram with the correct UML relationship arrows and visibility markers. You can refine it through follow-up chat and export the result.
A hollow triangle arrow means inheritance (generalization). A filled diamond means composition, where the part cannot exist without the whole. A hollow diamond means aggregation, a looser "has-a" relationship. A dashed arrow with a hollow triangle means a class realizes (implements) an interface, and a plain line or open arrow is a general association.
Both work well. Mermaid is lightweight and renders cleanly in Markdown and GitHub, which suits quick documentation. PlantUML supports more detailed UML features such as interfaces, stereotypes, and richer styling. Diagramming AI supports both, so you can choose what fits your workflow and switch later.
Continue with related guides, browse templates, or start building your own diagram in Diagramming AI.