OOP Compared: C++, C#, Java, and Python Side by Side

All four languages implement the same four pillars: encapsulation, inheritance, polymorphism, and abstraction. They differ in how strictly they enforce them, who owns object memory, and how much ceremony the syntax demands. This guide puts the same concepts in all four languages so you can see those differences in code.

Quick Takeaways

• C++ gives you manual control: value semantics, RAII, multiple inheritance, and opt-in dynamic dispatch through the virtual keyword.
• Java is class-centric and strict. It has single class inheritance, interfaces, a garbage collector, and dynamic dispatch by default.
• C# is close to Java but adds properties, struct value types, virtual/override keywords, and IDisposable for deterministic cleanup.
• Python enforces nothing by force. It uses duck typing, naming conventions for privacy, and C3 linearization for multiple inheritance.

Classes and Objects: The Same Account in Four Languages

A class bundles state and behavior. Each snippet below defines an Account with a validated deposit operation.

C++

#include <stdexcept>
#include <string>
#include <utility>

class Account {
public:
    Account(std::string owner, double balance)
        : owner_(std::move(owner)), balance_(balance) {}

    void deposit(double amount) {
        if (amount <= 0) throw std::invalid_argument("Amount must be positive");
        balance_ += amount;
    }

    double balance() const { return balance_; }  // const: does not mutate state

private:
    std::string owner_;
    double balance_;
};

The constructor uses a member initializer list, which constructs members directly instead of default-constructing and then assigning. Marking balance() as const lets you call it on const Account& references. Objects live on the stack by default, so Account a("Ada", 100); allocates no heap memory.

C#

public class Account
{
    public string Owner { get; }
    public decimal Balance { get; private set; }

    public Account(string owner, decimal balance)
    {
        Owner = owner;
        Balance = balance;
    }

    public void Deposit(decimal amount)
    {
        if (amount <= 0)
            throw new ArgumentOutOfRangeException(nameof(amount));
        Balance += amount;
    }
}

Auto-properties replace getter/setter boilerplate. { get; private set; } exposes read access publicly while keeping writes internal. Use decimal for money in C#, because binary floating point cannot represent values like 0.10 exactly.

Java

public class Account {
    private final String owner;
    private double balance;

    public Account(String owner, double balance) {
        this.owner = owner;
        this.balance = balance;
    }

    public void deposit(double amount) {
        if (amount <= 0) throw new IllegalArgumentException("Amount must be positive");
        balance += amount;
    }

    public double getBalance() { return balance; }
    public String getOwner() { return owner; }
}

Java has no property syntax, so accessors are explicit methods. Every object is created with new and lives on the heap. Production code should use BigDecimal for currency.

Python

class Account:
    def __init__(self, owner: str, balance: float = 0.0) -> None:
        self.owner = owner
        self._balance = balance  # leading underscore: "internal, don't touch"

    @property
    def balance(self) -> float:
        return self._balance

    def deposit(self, amount: float) -> None:
        if amount <= 0:
            raise ValueError("Amount must be positive")
        self._balance += amount

The @property decorator makes account.balance read-only, since no setter is defined. Python never blocks access to _balance. It trusts the caller.

Encapsulation: Enforcement Differs Sharply

Python’s name mangling rewrites __secret inside class Vault to _Vault__secret. This prevents accidental collisions in subclasses. It is not a security feature.

Inheritance: Syntax and Rules

All four languages support the “is-a” relationship. The rules for what you may inherit differ.

// C++: public inheritance, multiple bases allowed
class Savings : public Account {
public:
    Savings(std::string owner, double balance, double rate)
        : Account(std::move(owner), balance), rate_(rate) {}
private:
    double rate_;
};

C++ requires you to call the base constructor explicitly in the initializer list if the base has no default constructor.

// Java: single class inheritance, multiple interfaces
public class Savings extends Account implements Auditable {
    private final double rate;

    public Savings(String owner, double balance, double rate) {
        super(owner, balance);
        this.rate = rate;
    }
}

// C#: single class inheritance, multiple interfaces
public class Savings : Account, IAuditable
{
    private readonly decimal _rate;

    public Savings(string owner, decimal balance, decimal rate)
        : base(owner, balance) => _rate = rate;
}

# Python: multiple inheritance, resolved by MRO
class Savings(Account, Auditable):
    def __init__(self, owner: str, balance: float, rate: float) -> None:
        super().__init__(owner, balance)
        self.rate = rate

Java and C# forbid multiple class inheritance to avoid the diamond problem. C++ allows it and solves ambiguity with virtual inheritance. Python resolves it with the C3 linearization algorithm. Inspect the order with Savings.__mro__.

Polymorphism: Static vs. Dynamic Dispatch

Dynamic dispatch picks the method implementation at runtime based on the object’s real type. The defaults differ by language.

#include <iostream>
#include <memory>
#include <vector>

class Shape {
public:
    virtual ~Shape() = default;               // required for safe deletion via base pointer
    virtual double area() const = 0;          // pure virtual: makes Shape abstract
};

class Circle : public Shape {
public:
    explicit Circle(double r) : r_(r) {}
    double area() const override { return 3.14159265 * r_ * r_; }
private:
    double r_;
};

class Rect : public Shape {
public:
    Rect(double w, double h) : w_(w), h_(h) {}
    double area() const override { return w_ * h_; }
private:
    double w_, h_;
};

int main() {
    std::vector<std::unique_ptr<Shape>> shapes;
    shapes.push_back(std::make_unique<Circle>(2.0));
    shapes.push_back(std::make_unique<Rect>(3.0, 4.0));
    for (const auto& s : shapes) std::cout << s->area() << '\n';
}

This prints 12.5664 and 12. Without virtual, s->area() would bind statically to Shape::area. Without a virtual destructor, deleting a derived object through a base pointer is undefined behavior. The override specifier makes the compiler verify that you are actually overriding something.

public abstract class Shape
{
    public abstract double Area();
}

public class Circle(double r) : Shape
{
    public override double Area() => Math.PI * r * r;
}

public class Rect(double w, double h) : Shape
{
    public override double Area() => w * h;
}

C# requires both virtual (or abstract) in the base and override in the derived class. This is the explicit opt-in model. Primary constructors (Circle(double r)) are available from C# 12.

public abstract class Shape {
    public abstract double area();
}

public class Circle extends Shape {
    private final double r;
    public Circle(double r) { this.r = r; }
    @Override public double area() { return Math.PI * r * r; }
}

public class Rect extends Shape {
    private final double w, h;
    public Rect(double w, double h) { this.w = w; this.h = h; }
    @Override public double area() { return w * h; }
}

Every non-static, non-final, non-private Java method is virtual. The @Override annotation is optional but catches signature typos at compile time.

from abc import ABC, abstractmethod
import math

class Shape(ABC):
    @abstractmethod
    def area(self) -> float: ...

class Circle(Shape):
    def __init__(self, r: float) -> None:
        self.r = r
    def area(self) -> float:
        return math.pi * self.r ** 2

class Rect(Shape):
    def __init__(self, w: float, h: float) -> None:
        self.w, self.h = w, h
    def area(self) -> float:
        return self.w * self.h

Instantiating Shape() raises TypeError. Python also supports duck typing: any object with an .area() method works in a loop, with no shared base class. Use typing.Protocol to express that contract for static type checkers.

Memory Management and Object Lifetime

Garbage collection frees memory but does not release files, sockets, or locks on time. Each language has its own construct for that.

#include <fstream>

void writeLog() {
    std::ofstream file("app.log");   // opened here
    file << "started\n";
}                                     // closed here, even if an exception is thrown

RAII ties resource lifetime to scope. The destructor runs on every exit path.

def write_log() -> None:
    with open("app.log", "w") as f:   # __enter__ / __exit__ protocol
        f.write("started\n")

The with statement calls __exit__ on every exit path, including exceptions. C# using var and Java try (var f = ...) follow the same idea.

Edge Cases That Trip Up Developers

• C++ object slicing: Passing a Circle by value into a Shape parameter copies only the Shape part. Pass by reference or pointer.
• Java and C# field hiding: Fields are not polymorphic. Only methods are dispatched dynamically.
• C# new modifier: A derived method marked new hides the base method instead of overriding it. A base-typed reference then calls the base version.
• Python mutable defaults: def __init__(self, items=[]) shares one list across every instance. Use None and create the list inside.
• Python super() in multiple inheritance: It follows the MRO, not the direct parent. Every class in the chain must cooperate.

Performance and Trade-Offs at a Glance

Bad Code vs. Good Code

Anti-pattern: Type-checking instead of polymorphism (C#)

// BAD: every new shape forces edits here
public static double TotalArea(IEnumerable<object> shapes)
{
    double total = 0;
    foreach (var s in shapes)
    {
        if (s is Circle c) total += Math.PI * c.R * c.R;
        else if (s is Rect r) total += r.W * r.H;
        else throw new NotSupportedException();
    }
    return total;
}

This code violates the Open/Closed Principle. Adding a Triangle means editing TotalArea and every other function that branches on type.

// GOOD: new shapes plug in without touching existing code
public static double TotalArea(IEnumerable<Shape> shapes) =>
    shapes.Sum(s => s.Area());

Dynamic dispatch replaces the branching. The function is typed against the abstraction, so it never changes when new shapes appear.

Anti-pattern: Manual memory handling (C++)

// BAD: leaks if process() throws, double-delete risk if copied
Shape* s = new Circle(2.0);
process(*s);
delete s;

// GOOD: ownership is explicit and exception-safe
auto s = std::make_unique<Circle>(2.0);
process(*s);
// freed automatically when s leaves scope

std::unique_ptr expresses single ownership. Use std::shared_ptr only when ownership is truly shared.

Anti-pattern: Public mutable state (Python)

# BAD: any caller can corrupt invariants
acct = Account("Ada", 100)
acct.balance = -5000

With the @property version shown earlier and no setter, that assignment raises AttributeError. All mutation then goes through deposit(), which validates input.

Which Language Fits Your Project?

For learning OOP itself, start with Python to grasp the concepts, then move to Java or C# to see strict enforcement. Learn C++ last to understand what the other runtimes do for you.

FAQ

Which language is the most object-oriented: C++, C#, Java, or Python?

Python is the most uniform, since every value, including integers and functions, is an object. Java and C# are class-centric but keep primitives and value types. C++ is multi-paradigm and does not force you into classes.

Does Python support real encapsulation?

Not at the language level. Python uses naming conventions (_name) and name mangling (__name) to signal intent. Nothing prevents access, so encapsulation relies on developer discipline and tools like linters and type checkers.

Can Java and C# use multiple inheritance?

Not for classes. Both let a class implement multiple interfaces. Since Java 8 and C# 8, interfaces can include default method bodies, which gives limited multiple inheritance of behavior without state.

Is C++ OOP faster than Java or C# OOP?

Usually, yes, for workloads sensitive to memory layout and allocation, because C++ has no GC and supports stack-allocated objects. Modern JIT compilers in Java and C# close much of the gap in long-running services by devirtualizing and inlining calls.