💻 Comparison of Object-Oriented Programming in Java, C++, and D

Welcome to a comprehensive comparison of Object-Oriented Programming (OOP) across three distinct programming languages: Java, C++, and D. This document explores how each language approaches the fundamental concepts of OOP and provides practical examples using the GNU D Compiler (gdc). By understanding these comparisons, you'll develop a deeper appreciation for language design decisions and be better equipped to choose the right tool for your projects.

❓ What is Object-Oriented Programming?

Object-Oriented Programming is a paradigm that organizes code around "objects" that contain both data (variables) and functions (methods). Think of an object like a blueprint: a Drink class defines what properties all drinks have and what operations can be performed on them.

The core principles of OOP are:

• Encapsulation: Bundling data and methods together, hiding internal details
• Inheritance: Creating new classes based on existing ones
• Polymorphism: Objects of different classes responding to the same message in different ways
• Abstraction: Showing only essential features while hiding complexity

📊 Language Feature Comparison Table

✏️ Example 1: Basic Class Definition

Let's compare how to define a basic class in all three languages:

public class Drink {
    final int MAXIMUM = 10;
    private String name;
    
    public Drink(String brandName) {
        name = brandName;
    }
    
    public String getName() {
        return name;
    }
}

class Drink {
private:
    static const int MAXIMUM = 10;
    string name;
    
public:
    Drink(string brandName) {
        name = brandName;
    }
    
    string getName() {
        return name;
    }
}

class Drink {
    immutable int MAXIMUM = 10;
    private string name;
    
    this(string brandName) {
        name = brandName;
    }
    
    string getName() {
        return name;
    }
}

Key Observations:

• Java: Requires access modifiers on each method; uses `final` for constants
• C++: Uses separate `private:` and `public:` sections; uses `static const` for class constants
• D: Similar to Java but uses `immutable` instead of `final`, and `this()` instead of the class name

✏️ Example 2: Constructor Overloading

All three languages support multiple constructors with different parameter lists:

public Drink(String name) {
    this.name = name;
    this.cost = 1.75;
}

public Drink(String name, 
             double cost) {
    this.name = name;
    this.cost = cost;
}

Drink(string name) {
    this->name = name;
    this->cost = 1.75;
}

Drink(string name, 
      double cost) {
    this->name = name;
    this->cost = cost;
}

this(string name) {
    this.name = name;
    this.cost = 1.75;
}

this(string name, 
     double cost) {
    this.name = name;
    this.cost = cost;
}

Key Observations:

• Java: Uses `this.variable` to reference instance variables
• C++: Uses `this->variable` pointer notation
• D: Uses `this.variable` like Java, but constructors start with `this()`

✏️ Example 3: Methods and Encapsulation

Here's how methods work in each language, using the vending machine example:

public void vend() {
    if (available > 0) {
        available -= 1;
        consumed += 1;
        moneyMade += cost;
        System.out.println(
            name + " Purchased.");
    }
}

public double profit() {
    return moneyMade;
}

void vend() {
    if (available > 0) {
        available -= 1;
        consumed += 1;
        moneyMade += cost;
        cout << name << 
            " Purchased." << endl;
    }
}

double profit() {
    return moneyMade;
}

void vend() {
    if (available > 0) {
        available -= 1;
        consumed += 1;
        moneyMade += cost;
        writeln(name ~ 
            " Purchased.");
    }
}

double profit() {
    return moneyMade;
}

Key Observations:

• Java: Uses `System.out.println()` for output
• C++: Uses `cout` and `endl` from iostream
• D: Uses `writeln()` (requires `import std.stdio;`) and `~` for string concatenation

🔧 The Complete Vending Machine Example

Now let's look at a complete, working example using the D language and the GNU D Compiler (gdc). This program implements a simple vending machine that tracks drink sales and profits using separate class and driver files.

Important: Selective Module Imports in D

When using D with separate files, the key to successful compilation is using selective imports with the syntax import Module : Symbol;. This explicitly tells the gdc compiler which specific symbol (like a class) you want to import from a module, eliminating namespace ambiguity.

Why Selective Imports Are Essential for gdc

The syntax import Module : Symbol; is crucial because:

• Eliminates Ambiguity: When you write import Drink; (regular import), the compiler can't tell if "Drink" refers to a module or a class. With import Drink : Drink;, it's unambiguous—you want the Drink class.
• Direct Namespace Access: The selected symbol is brought directly into your namespace, making it accessible as just `Drink`, not `Drink.Drink`
• Clear Intent: Your code explicitly shows what you're importing, making it easier to understand and maintain
• Prevents "import is used as a type" Error: This specific gdc error occurs when the compiler misinterprets an import statement as a type declaration—selective imports prevent this

Drink.d - The Drink Class Module

module Drink;

import std.stdio;
import std.math;

class Drink {
    
    // Class constants
    immutable int MAXIMUM_CAPACITY = 10;
    immutable double DEFAULT_DRINK_COST = 1.75;
    
    // Instance variables
    private int available;
    private int consumed;
    private int useDefaultCost;
    private int useSuppliedCost;
    private double drinkCost;
    private double moneyMade;
    private string name;
    
    // Constructor 1: Sets the name of the drink only
    this(string brandName) {
        name = brandName;
        consumed = 0;
        available = 0;
        moneyMade = 0.0;
        drinkCost = DEFAULT_DRINK_COST;
        useDefaultCost = 1;
        useSuppliedCost = 0;
    }
    
    // Constructor 2: Sets name and custom cost
    this(string brandName, double cost) {
        name = brandName;
        consumed = 0;
        available = 0;
        moneyMade = 0.0;
        drinkCost = cost;
        useDefaultCost = 0;
        useSuppliedCost = 1;
    }
    
    // Vend method - dispense a drink if available
    void vend() {
        if (available > 0) {
            available -= 1;
            consumed += 1;
            moneyMade += (useDefaultCost * DEFAULT_DRINK_COST +
                         useSuppliedCost * drinkCost);
            writeln(name ~ " Purchased.");
        } else {
            writeln("************");
            writeln("* SOLD OUT  *");
            writeln("************");
        }
    }
    
    // Refill drinks to maximum capacity
    void refill() {
        available = MAXIMUM_CAPACITY;
    }
    
    // Calculate and return rounded profit
    double profit() {
        return round(moneyMade * 100.0) / 100.0;
    }
    
    // Return number of drinks sold
    int drinksSold() {
        return consumed;
    }
    
    // Get the drink name
    string getDrinkName() {
        return name;
    }
    
    // Return amount needed to restock
    int restockAmount() {
        return MAXIMUM_CAPACITY - available;
    }
}

Machine.d - The Driver Program Module

module Machine;

import std.stdio;
import Drink : Drink;

void main() {
    
    // Create drinks using different constructors
    Drink drink1 = new Drink("Coke");
    Drink drink2 = new Drink("Sprite");
    Drink drink3 = new Drink("Doctor Pepper");
    Drink drink4 = new Drink("V8 Splash", 4.25);
    
    // Refill all drinks
    drink1.refill();
    drink2.refill();
    drink3.refill();
    drink4.refill();
    
    // Purchase 8 Cokes
    drink1.vend();
    drink1.vend();
    drink1.vend();
    drink1.vend();
    drink1.vend();
    drink1.vend();
    drink1.vend();
    drink1.vend();
    
    // Purchase 6 Sprites
    drink2.vend();
    drink2.vend();
    drink2.vend();
    drink2.vend();
    drink2.vend();
    drink2.vend();
    
    // Purchase 2 Doctor Peppers
    drink3.vend();
    drink3.vend();
    
    // Purchase 11 V8 Splash (will exceed capacity)
    drink4.vend();
    drink4.vend();
    drink4.vend();
    drink4.vend();
    drink4.vend();
    drink4.vend();
    drink4.vend();
    drink4.vend();
    drink4.vend();
    drink4.vend();
    drink4.vend();
    
    // Calculate totals
    int totalSold = drink1.drinksSold() + drink2.drinksSold() +
                    drink3.drinksSold() + drink4.drinksSold();
    
    double totalProfit = drink1.profit() + drink2.profit() +
                         drink3.profit() + drink4.profit();
    
    // Display results
    writeln("A Total of ", totalSold, " drinks were sold for a profit of $", totalProfit);
    writeln();
    writeln(drink1.restockAmount(), " ", drink1.getDrinkName(), " needed to restock machine");
    writeln(drink2.restockAmount(), " ", drink2.getDrinkName(), " needed to restock machine");
    writeln(drink3.restockAmount(), " ", drink3.getDrinkName(), " needed to restock machine");
    writeln(drink4.restockAmount(), " ", drink4.getDrinkName(), " needed to restock machine");
}

⚡ Compilation and Execution Instructions

Step-by-Step: Two-File Compilation with gdc (Correct Method)

1. Create Drink.d with the Drink class code (shown above)
2. Create Machine.d with the main() function code (shown above)
3. Save both files in the same directory
4. Open a terminal and navigate to that directory
5. Compile both files together in one command:

   gdc Drink.d Machine.d -o machine

6. Run the program:

   ./machine

The Difference Between Import Styles in D

Sample Output:

🎯 Understanding the Code

Module Declarations and Selective Imports

In D, when you split code into multiple files, you use module declarations and can control exactly what you import:

Why Selective Import Prevents the Error

The error "import 'Machine.Drink' is used as a type" occurred because the compiler was interpreting the Drink symbol as a module import rather than a class. By using selective import syntax import Drink : Drink;, you explicitly tell the compiler:

• "Go to the Drink module"
• "Find the Drink symbol (which is a class)"
• "Make that class available in my namespace as 'Drink'"

This removes all ambiguity about what "Drink" refers to—it's clearly the class, not the module.

Class Variables vs. Instance Variables

Encapsulation in Action

Notice that in the Drink class, all data members are declared private. This means they cannot be accessed directly from outside the class. Instead, users must use the public methods:

• vend() - handles selling a drink
• refill() - restocks the drinks
• profit() - calculates earnings
• drinksSold() - returns sales count

❌ Common Mistakes and Solutions

Mistake 1: Using Module Import Instead of Selective Import

module Machine;

import Drink;  // Regular module import - causes ambiguity!

void main() {
    Drink drink1 = new Drink("Coke");  // ERROR: "import is used as a type"
}

module Machine;

import Drink : Drink;  // Selective import - resolves ambiguity!

void main() {
    Drink drink1 = new Drink("Coke");  // Works correctly
}

Mistake 2: Forgetting the Module Declaration

import std.stdio;

class Drink {
    // Class code...
}

module Drink;

import std.stdio;

class Drink {
    // Class code...
}

Mistake 3: Forgetting to Import the Class in Main

module Machine;

import std.stdio;

void main() {
    Drink drink1 = new Drink("Coke");  // ERROR! Drink not found
}

module Machine;

import std.stdio;
import Drink : Drink;  // Must import the Drink class!

void main() {
    Drink drink1 = new Drink("Coke");
}

Mistake 4: Compiling Only One File

gdc Machine.d -o machine  // ERROR! Missing Drink.d

gdc Drink.d Machine.d -o machine  // Include ALL source files

Mistake 5: Module Name Not Matching File Name

module beverage;  // ERROR! Module name should match filename

class Drink {
    // ...
}

module Drink;  // Module name matches filename

class Drink {
    // ...
}

Mistake 6: Understanding the "import is used as a type" Error

Machine.d:9:11: error: import 'Machine.Drink' is used as a type
    9 |     Drink drink1 = new Drink("Coke");
      |           ^

✏️ Your Programming Exercise

Objective: Modify the vending machine program to replace the V8 Splash drink with a new beverage of your choice.

Assignment:

The current program includes V8 Splash at $4.25 as the fourth drink. Your task is to:

1. Replace V8 Splash: Change the drink name to something different (e.g., "Orange Juice", "Apple Cider", "Iced Tea", "Lemonade", etc.) and choose a new price (different from $4.25)
2. Modify the vending operations: Change how many times each drink is purchased by modifying the number of vend() method calls for each drink
3. Update the output display: Ensure all the drink names and restock amounts are printed correctly
4. Test your program: Compile with gdc and run it to ensure it works properly

Specific Changes to Make:

• In Machine.d, change the line:

  Drink drink4 = new Drink("V8 Splash", 4.25);

  to your new drink with a new price, for example:

  Drink drink4 = new Drink("Orange Juice", 3.50);

• Keep all four drinks in the program
• Keep all the vend() calls (you can change the numbers of times each is called)
• Keep the final output section that displays totals and restocking information

Testing Your Solution:

1. Make your changes to Machine.d (or Drink.d if needed)
2. Save both files
3. Compile both files together:

   gdc Drink.d Machine.d -o machine

4. Run:

   ./machine

5. Verify the output shows your new drink name and the correct profit calculations

⭐ Key Takeaways About Object-Oriented Programming

• ✓ Classes bundle data (variables) and behavior (methods) together
• ✓ Constructors initialize objects when they are created
• ✓ Access modifiers (private, public) control what can be accessed
• ✓ Encapsulation hides internal details and prevents misuse
• ✓ Methods provide the interface for interacting with objects
• ✓ D uses this() for constructors instead of the class name
• ✓ D uses immutable for constants instead of final
• ✓ Use selective import syntax: import Module : Symbol; to avoid namespace ambiguity
• ✓ Always compile all source files together: gdc Drink.d Machine.d -o machine
• ✓ Module names should match file names (Drink.d contains module Drink)
• ✓ String concatenation in D uses the ~ operator, not +
• ✓ D uses writeln() for output (requires `import std.stdio;`)

🏆 Language Strengths Summary