OOPS Cheat Sheet: Java vs C++
Golden Rule: OOP concepts are the same in Java and C++. Differences exist only in implementation rules,
restrictions, and syntax.
1. Encapsulation
Wrapping data (variables) and methods into a single unit (class) and controlling access.
Java Implementation
class Student {
private int marks;
public void setMarks(int m) {
marks = m;
}
public int getMarks() {
return marks;
}
}
C++ Implementation
class Student {
private:
int marks;
public:
void setMarks(int m) {
marks = m;
}
int getMarks() {
return marks;
}
};
Java C++
Strict encapsulation Flexible
No structs for OOP struct + class
Safer by default Programmer responsible
2. Abstraction
Showing what to do, hiding how it is done.
Java – Abstract Class
abstract class Shape {
abstract void draw();
}
class Circle extends Shape {
void draw() {
[Link]("Drawing Circle");
}
}
Java – Interface
interface Shape {
void draw();
}
class Circle implements Shape {
public void draw() {
[Link]("Drawing Circle");
}
}
C++ – Pure Virtual Function
class Shape {
public:
virtual void draw() = 0;
};
class Circle : public Shape {
public:
void draw() {
cout << "Drawing Circle";
}
};
Java C++
abstract class, interface Pure virtual functions
Interface supports MI MI via classes
Cleaner abstraction More control
3. Inheritance
One class acquires properties of another class.
Java – Single Inheritance
class Parent {
void show() {
[Link]("Parent");
}
}
class Child extends Parent {
void display() {
[Link]("Child");
}
}
Java – Multiple Inheritance via Interface
interface A {
void show();
}
interface B {
void display();
}
class C implements A, B {
public void show() {}
public void display() {}
}
C++ – Multiple Inheritance
class A {
public:
void show() {}
};
class B {
public:
void display() {}
};
class C : public A, public B {
};
Java C++
No MI of classes MI supported
Uses interfaces Direct inheritance
Safer Risky but powerful
4. Polymorphism
Same function name, different behavior.
C++ – Operator Overloading
class A {
public:
int x;
A(int x) { this->x = x; }
A operator+(A obj) {
return A(x + obj.x);
}
};
Java – Method Overriding
class Parent {
void show() {
[Link]("Parent");
}
}
class Child extends Parent {
void show() {
[Link]("Child");
}
}
C++ – Runtime Polymorphism
class Parent {
public:
virtual void show() {
cout << "Parent";
}
};
class Child : public Parent {
public:
void show() {
cout << "Child";
}
};
Java C++
No operator overloading Supports it
Virtual by default Explicit virtual
Simpler More control
5. Constructors & Destructors
Java
class Test {
Test() {
[Link]("Constructor");
}
}
C++
class Test {
public:
Test() {
cout << "Constructor";
}
~Test() {
cout << "Destructor";
}
};
6. Memory Management
Java C++
Automatic (Garbage Collection) Manual (new / delete)
No user-level pointers Heavy pointer usage
Safer Faster but risky
Final Interview One-Liner
Java and C++ follow the same OOP principles, but Java enforces OOP strictly for safety and simplicity,
whereas C++ provides more flexibility and control at the cost of complexity.