Class Diagrams

So here is a small API for Vehicles. This is a really simple diagram to build but the details tell you a lot. You can see the properties and methods for all the interfaces and classes. The plus (+) sign means they are all public. Also, you can see the relationships between the entities via the relationship arrows. Notice the top entity is an interface, so all the classes like Car, Truck, and Motorcycle implement this interface. Also, I try not to repeat the members for each implementing class. The dashed line in the arrows let you know that Vehicle is an interface.

@startuml

skin rose

class Example {
 -privateField
 #protectedField
 ~packagePrivateField
 +publicField
 
 -privateMethod()
 #protectedMethod()
 ~packagePrivateMethod()
 +publicMethod()
}

@enduml

PlantUML:

@startuml

skin rose

skinparam classAttributeIconSize 0

class Vehicle {
  + speed : int
  + start()
  + stop()
}

class Car extends Vehicle {
  + numWheels : int
  + drive()
}

class Truck extends Vehicle {
  + cargoCapacity : int
  + load()
  + unload()
}

@enduml

PlantUML:

@startuml

skin rose

'' skinparam classAttributeIconSize 0

class Vehicle {
  + speed : int
  + start()
  + stop()
}

class Car extends Vehicle {
  + numWheels : int
  + drive()
}

class Truck extends Vehicle {
  + cargoCapacity : int
  + load()
  + unload()
}

@enduml

These are all the accessibility options. Notice the difference between UML and PlantUML.

UML	Fields	Methods	Visibility
-			private
#			protected
~			package private
+			public

And here are the basic relationship options. You can find the full list and more here.

Type	Symbol	Drawing
Extension	<|--
Composition	*--
Aggregation	o--

• Represents the “is-a” relationship
• Subclasses are specializations of the SuperClass
• Dashed line is used when the SuperClass is an abstract class (or Interface)
• A solid line is used with when not abstract
• In C# you just use the implements syntax as in orange below

PlantUML:

@startuml

skin rose

class Vehicle {
  + speed : int
  + start()
  + stop()
}

class Car extends Vehicle {
  + numWheels : int
  + drive()
}

class Truck extends Vehicle {
  + cargoCapacity : int
  + load()
  + unload()
}

@enduml

C#:

public class Vehicle
{
    public int speed;
    public void start(){}
    public void stop(){}
}

public class Car : Vehicle
{
    public int numWheels;
    public void drive(){}
}

public class Truck : Vehicle
{
    public int cargoCapacity;
    public void load(){}
    public void unload(){}
}

• Any structural link between two classes
• Usually directional
• Is a solid line in most cases
• In C# all it takes is to have a public member of the other class type to create this relationship

PlantUML:

@startuml

skin rose

class Person {
  + name : string
  + age : int
}

class Address {
  + street : string
  + city : string
  + state : string
  + zip : string
}

Person --> Address : lives at

@enduml

C#:

public class Person
{
    public string name;
    public int age;
    
    public Address address;
}

public class Address
{
    public string street;
    public string city;
    public string state;
    public string zip;
}

• Represents the “part of” relationship
• One class is a part of another
• Many instances (*) of Faculty can be associated with the (1) of University
• Objects of University and Faculty have separate lifetimes.
• A solid line with an empty diamond at the association end connected to the class
• In C# you see the private list of Faculties and a AddFaculty method to pass them in

PlantUML:

@startuml

skin rose

class University {
  - name : string
  - faculties : Faculty[]
}

class Faculty {
  - name : string
  - departments : Department[]
}

University "1" o-- "Many" Faculty

@enduml

C#:

public class University
{
    private string name;
    private List<Faculty> faculties;

    public University(string name)
    {
        this.name = name;
        this.faculties = new List<Faculty>();
    }

    public void AddFaculty(Faculty faculty)
    {
        this.faculties.Add(faculty);
    }
}

public class Faculty
{
    private string name;
    private List<Department> departments;

    public Faculty(string name)
    {
        this.name = name;
        this.departments = new List<Department>();
    }

    public void AddDepartment(Department department)
    {
        this.departments.Add(department);
    }
}

• Represents the “part of” relationship, but an instance of one class being destroyed, destroys instances of the other class
• The “part” class cannot stand on its own
• If there is a multiplicity again you can use many instances (*) and (1) one the connector
• A solid line with a filled diamond at the association connected to the class
• In C# notice that the deconstructor set the Engine to Null. If the instance of an object is instantiated within the scope of a method, that is composition too (very very common)

PlantUML:

@startuml

skin rose

class Car {
  - engine : Engine
}

class Engine {
  - cylinders : int
  + start() : void
}

Car *- Engine : owns

@enduml

C#:

public class Car
{
    private Engine engine;
    public Car(Engine engine)
    {
        this.engine = engine;
    }

    ~Car()
    {
        Console.WriteLine("Car object destroyed");
        this.engine = null;
    }
}

public class Engine
{
    private int cylinders;
    public Engine(int cylinders)
    {
        this.cylinders = cylinders;
    }

    public void Start()
    {
        Console.WriteLine("Engine started");
    }

    ~Engine()
    {
        Console.WriteLine("Engine object destroyed");
    }
}

• Changes to the definition of one may cause changes to the other (but not the other way around)
• Weaker type of relationship between two classes where one class depends on the other class for some functionality but has no ownership or control over it
• The lifetime of the dependent class is not controlled by the lifetime of the independent class
• Represented in class diagrams by a dashed arrow pointing from the dependent class to the independent class
• In C# notice the orange line that makes the ShoppingCart dependent on the CalculateTotal() method of Order

PlantUML:

@startuml

skin rose

class ShoppingCart {
    +CalculateTotal(): double
}

class Order {
    +CalculateTotal(): double
}

ShoppingCart ..> Order

@enduml

C#:

public class Order
{
    public double CalculateTotal()
    {
        // Calculation logic here
        return 0.0;
    }
}

public class ShoppingCart
{
    public double CalculateTotal()
    {
        Order order = new Order();
        double total = order.CalculateTotal();
        // Other logic here
        return total;
    }
}