Object-Oriented Programming OOP Fundamentals 2026

Nearly all modern programming languages support OOP, and future ones will too. If you work in software development, you’re likely already using object-oriented programming principles.

Our Amazon book recommendation for OOP:

Should you pick up such a book right away? Not necessarily. If you’re new to OOP languages, I’d recommend starting with a general programming book or course for your chosen language instead. These tend to explain the fundamentals well, and you’ll naturally pick up OOP along the way. A dedicated OOP book might be too dense if you lack programming experience.

Here are comprehensive programming books:

We’ll walk through the key principles here and provide some practical examples.

What is Object-Oriented Programming (OOP)?

Object-oriented programming (OOP) is a programming paradigm that centers on the concept of “objects”—units that bundle data and the methods needed to process it together. In OOP, programs are designed as collections of objects that interact with one another to solve complex problems.

The core OOP principles are:

1. Encapsulation 2. Inheritance 3. Polymorphism 4. Abstraction

Encapsulation in Object-Oriented Programming

Each object in OOP contains data (attributes or properties) and methods (functions) that manipulate that data. Encapsulation hides an object’s internal details and exposes a public interface for interaction with the object.

Encapsulation in OOP means that an object’s internals stay hidden and are only accessible through defined interfaces. Here are examples of encapsulation in JavaScript, PHP, and Java:

Access Modifiers as Tools of Object-Oriented Programming

A brief overview: In object-oriented languages like Java and C#, access modifiers control how classes, methods, constructors, and properties can be accessed. Here are the common access modifiers explained:

public: A public member is accessible from anywhere—inside and outside the class or package where it’s defined. private: A private member is accessible only within the class where it’s defined. It cannot be accessed from outside or from derived classes (subclasses). protected: A protected member is accessible within its own class and from derived classes, regardless of whether they’re in the same package. default (package-private in Java): When no access modifier is specified, the member has package access in Java, meaning it’s accessible from any class in the same package but not from classes outside it. internal (in C#): An internal member is accessible throughout the entire assembly where it’s defined, but not from outside the assembly.

These access modifiers help enforce the principles of encapsulation and information hiding in OOP by controlling the visibility and accessibility of different parts of your code.

Encapsulation Example in JavaScript:

In JavaScript, encapsulation can be achieved using functions and closures, since it lacks explicit keywords like private or public.

Encapsulation Example in PHP:

PHP OOP Encapsulation PHP supports encapsulation through access modifiers like private, protected, and public.

Encapsulation Example in Java:

Java OOP Encapsulation

In all three examples, data (name and age) in the Person class is encapsulated and accessible only through public methods (getName() and getAge()). Direct access to internal variables from outside the class is prevented, which demonstrates encapsulation in action.

Inheritance in Object-Oriented Programming

Inheritance allows new objects (derived classes) to acquire properties and behavior from existing objects (base classes). This promotes code reuse and makes it easier to build and maintain complex systems.

Inheritance in JavaScript works differently than in classical object-oriented languages like Java or C++. JavaScript uses prototypes for inheritance rather than class-based inheritance (though modern JavaScript versions provide class syntax that relies on prototypes under the hood).

In JavaScript, every object inherits properties and methods from a prototype object. Here’s a simple example showing how inheritance works in JavaScript:

In this example, Employee is created to inherit from Person. This happens by:

Calling the Person constructor function with Person.call(this, name) inside the Employee constructor to inherit Person’s properties. Setting Employee.prototype to an object created from Person.prototype, allowing Employee to inherit Person’s methods via Object.create(Person.prototype). Overriding the greet method for Employee to define specific behavior for Employee instances.

Polymorphism in Object-Oriented Programming

Polymorphism allows objects to respond to the same message or method call in different ways, depending on their type or class. This enables flexible code structures where the same code can work with various object types.

Polymorphism, a central OOP concept, refers to the ability of objects from different classes to respond to the same message or method in different ways. The term “polymorphism” comes from Greek and means “many forms.” In OOP, polymorphism allows an interface to have multiple implementations, resulting in more flexible and reusable code.

There are mainly two types of polymorphism:

• Method Overriding Here, classes that inherit from a base class can “override” a base class method to provide their own implementation. For example, a base class Animal might have a speak() method, and derived classes Dog and Cat can override it to output “Bark” and “Meow” respectively.

• Method Overloading Here, the same class can have multiple methods with the same name but different parameters. The correct method is selected at runtime based on the arguments passed.

Polymorphism lets developers write code that works with objects of different classes as long as they share a common interface or base class. This leads to a more flexible and extensible codebase, since new classes can be added without changing existing code.

In JavaScript, polymorphism is typically implemented through prototypes and constructor functions. Here’s an example showing how polymorphism works in JavaScript:

In this example, Animal is a base constructor function with a speak method. Both Dog and Cat are derived constructor functions that inherit from Animal. Each derived class calls the Animal constructor with a different sound. This effectively “overrides” how the speak method works for their respective instances, even though they use the same method in the prototype. This is polymorphism in action: different objects execute the same method in different ways.

Abstraction in Object-Oriented Programming

Abstraction simplifies complex real-world aspects by modeling only the relevant properties and behaviors. This makes it easier to understand and work with complex systems.

Abstraction in programming, including JavaScript, refers to the practice of simplifying complex reality by presenting only relevant data and actions while hiding unnecessary details. In JavaScript, this can be achieved using constructor functions, classes (ES6 and later), or modules to define an interface that encapsulates a component’s or object’s functionality.

Here’s a simple example of abstraction in JavaScript using a class:

In this example, Car is an abstract representation of a car. It hides the complexity of what actually happens when a car starts or drives, and instead provides simple start and drive methods. Users of the Car class don’t need to worry about engine details, transmission, or other internal mechanics. They interact with the Car object only through its defined methods.

This kind of abstraction keeps code clean, understandable, and maintainable by hiding details and exposing only what matters to the class user.

Which well-known programming languages don’t use OOP?

Several well-known programming languages prioritize paradigms other than Object-Oriented Programming (OOP), though some may include optional OOP features. Here are some examples:

C A procedural language used for systems and applications programming. It has no support for OOP concepts like classes and objects.

Fortran An older language primarily used in scientific and engineering applications. It’s procedural and lacks OOP support.

COBOL Designed for business applications, COBOL is procedural and didn’t include OOP in its original design, though later versions introduced some object-oriented features.

Bash/Shell-scripting languages Used for writing scripts in Unix and Linux environments, these languages are procedural and typically don’t support object-oriented concepts.

Haskell A functional programming language that emphasizes functions over objects. Functional languages like Haskell operate under different paradigms than OOP.

Erlang Another functional language, widely used for distributed systems and real-time applications.

Prolog A logic-based programming language, primarily applied in artificial intelligence and computational linguistics.

SQL (Structured Query Language) A language for managing and querying data in relational database systems. SQL is declarative and doesn’t follow OOP principles.

These languages follow different paradigms—procedural, functional, declarative, or logic-based. Each has its own strengths and appropriate use cases, and the choice of language often depends on your project’s specific requirements.

Which well-known languages support OOP?

Many modern and widely-used programming languages support Object-Oriented Programming (OOP).

Java One of the most prominent OOP languages, known for platform independence and a comprehensive standard library.

C++ An extension of C that adds OOP capabilities, used in systems and application programming.

Python A versatile high-level language that supports OOP and is praised for its simple, readable syntax.

C# (C-Sharp) Created by Microsoft, this OOP language is commonly used for Windows applications and game development.

Ruby A dynamic language known for its elegant and productive syntax. Ruby follows the philosophy that “everything is an object.”

PHP Originally a simple scripting language, it now fully supports OOP and is widely used for web development.

Swift Created by Apple, Swift is an OOP language for developing iOS and macOS applications.

Kotlin A relatively new language designed for the Java Virtual Machine (JVM) with full OOP support. It’s increasingly used for Android development.

Objective-C The primary language for iOS and macOS development before Swift’s introduction.

Smalltalk One of the first pure OOP languages, it pioneered many concepts that shaped later OOP languages.

These languages offer comprehensive support for OOP concepts like classes, objects, inheritance, polymorphism, and encapsulation. They’re used across a wide range of domains, from systems programming to mobile and web development to scientific applications.

Which programming language should beginners start with?

That’s a tough question. I started with BASIC, then moved to Turbo Pascal, and learned Java as my first OOP language at university.

Personally, I recommend Python or JavaScript because you can build your own projects right away.

The choice of programming language for beginners depends on several factors: your personal interests, the types of projects you want to build, and what learning resources are available. Here are some languages commonly recommended for beginners:

Python: Python’s clear and readable syntax makes it ideal for beginners. It’s used across many domains—from web development to data analysis to machine learning.

JavaScript: If you’re interested in web development, JavaScript is essential. It runs on the client side in virtually every web browser and increasingly on the server side via Node.js.

Java: A versatile language widely used in enterprise environments. Its stricter syntax than Python can help you grasp fundamental programming principles.

C#: If you’re interested in game development, especially with the Unity engine, C# is an excellent choice. It’s also used for Windows applications.

Ruby: Known for its elegant syntax, Ruby suits beginners interested in web development, particularly with the Ruby on Rails framework.

Kotlin: If you want to develop Android apps, Kotlin is a modern and approachable language that Google recommends as the preferred language for Android.

Swift: For iOS app development, Swift is the go-to choice. Created by Apple, it’s accessible to beginners.

Remember that mastering the fundamentals—loops, conditionals, variables, functions, and data structures—matters more than which specific language you choose. These concepts are universal across programming languages.

---

Continue on the OOP learning path

The next article in the OOP learning path covers OOP Fundamentals: Classes, Objects, Instances, Attributes & Methods — the core concepts of classes and objects.

Recommended reading: Object-Oriented Programming