Table of Contents

Class Diagram in BlueJ IDE

Creating a class diagram in BlueJ IDE is an essential step in visualizing the structure of a Java program, including the relationships between different classes.

A class diagram is a type of diagram in the Unified Modeling Language (UML) that describes the structure of a system by showing its classes, attributes, operations, and the relationships among the objects. It is a blueprint for the system, providing a visual representation that can help understand and design the system.

Example

Let’s understand with an example. To illustrate the UML diagram, we’ll create a basic hierarchy of shapes. The system has an interface, parent, and one child class.

Interface
Drawable – This interface will define a method that all drawable shapes
must implement.
Parent Class – Shape
The Shape class is an abstract class with some common properties for shapes.
Child Class – Circle
The Child class extends the Shape class and implements the Drawable interface.

Create these artifacts in the BlueJ IDE. Use the tutorials on the page below to create the classes and interface in the IDE.

Interface

// Define the Drawable interface

interface Drawable {

void draw();

}

Interface Drawable defines a method draw(). Any class that implements this interface must provide an implementation for this method.

Parent Class

// Define the Shape class as an abstract class
abstract class Shape {
 private String color;

 // Constructor
 public Shape(String color) {
 this.color = color;
 }

 // Getter for color
 public String getColor() {
 return color;
 }

 // Abstract method to be implemented by subclasses
 public abstract double area();
}

Abstract Class Shape has a property color and an abstract method area(), which any subclass must implement. The Shape class also provides a constructor and a getter for the color.

Child class

// Define the Circle class that extends Shape and implements Drawable
class Circle extends Shape implements Drawable {
 private double radius;

 // Constructor
 public Circle(String color, double radius) {
 super(color);
 this.radius = radius;
 }

 // Implement the area method
 @Override
 public double area() {
 return Math.PI * radius * radius;
 }

 // Implement the draw method from the Drawable interface
 @Override
 public void draw() {
 System.out.println("Drawing a circle with color " + getColor() 
+ " and radius " + radius);
 }
}

The Concrete class Circle extends the Shape class and implements the Drawable interface. It provides specific implementations for the area() and draw() methods.

Class Diagram in BlueJ IDE

As you build the entities in the system and relate them, the workspace will display the diagram.

BlueJ Class Diagram

Name	Arrow Symbols
Inheritance
Implementation/ Realization
Dependency

Main Program

This class has the main() method to run the program. The Main program creates an instance of a Circle, prints its area, and calls the draw() method.

// Main class to run the example
public class Main {
 public static void main(String[] args) {
 // Create a Circle object
 Circle myCircle = new Circle("red", 5.0);

 // Display the area
 System.out.println("Area of the circle: " + myCircle.area());

 // Draw the circle
 myCircle.draw();
 }
}

Interfaces define a contract for what methods a class must implement.
Abstract Classes can contain both complete (implemented) and incomplete (abstract) methods and fields shared among subclasses.
Concrete Classes inherit from abstract classes and implement interfaces, providing specific functionality.

The workspace will display the system’s UML class diagram, showing the classes, interfaces, and their relationships. Notice how the classes in the diagram are related to others in the system using the UML class diagram.

—