Object-oriented programming
Object-oriented programming is a programming paradigm that organizes software around objects combining state and behavior, often using encapsulation, classes, inheritance, or polymorphism.
Software Engineering for Data Scientists
Object-oriented programming is a programming paradigm that organizes software around objects containing state and behavior, commonly using classes, encapsulation, inheritance, and polymorphism.
- How it is used
- Structures data science code for portability, collaboration, and production integration.
- How deep it goes
- Defines classes, objects, methods, instance variables, encapsulation, and dot notation through a scikit-learn walkthrough.
- Examples
- Uses a car, an integer variable, and a scikit-learn RandomForestClassifier with configurable parameters.
- What you can do after
- Apply it via scikit-learn by creating model objects, setting parameters, invoking methods, and reading attributes with dot notation.
Read how Software Engineering for Data Scientists explains object-oriented programming →
Functional Design and Architecture: Examples in Haskell
A programming paradigm that organizes software around objects combining state with behavior and supports mechanisms such as encapsulation, inheritance, and polymorphism.
- How it is used
- Uses object-oriented design to guide decisions and control accidental complexity in software architecture.
- How deep it goes
- Explains interface adaptation and substitution through implementations, while relating object-oriented principles to broader design concerns.
- Examples
- Illustrates a thermometer adapter, interchangeable lamp implementations, and a spaceship control system.
- What you can do after
- Evaluate and understand object-oriented design decisions using interface contracts, patterns, and complexity as guides.
Data-Oriented Programming: Reduce software complexity
A programming paradigm in which programs are composed from objects that combine state with methods for accessing and manipulating that state.
- How it is used
- Frames OOP as a design choice whose object structure can increase the difficulty of understanding production systems.
- How deep it goes
- Explains object composition, class relationships, mutability, serialization, and hierarchies, but does not develop language-specific internals.
- Examples
- Uses a library-management class diagram and repeated JSON REST endpoint classes to expose relationship and serialization costs.
- What you can do after
- Evaluate OOP designs by tracing relationships, mutable state, serialization work, and class-hierarchy complexity.
Python Workout, Second Edition
Object-oriented programming is a programming paradigm that organizes software around objects that combine state and behavior.
- How it is used
- Organizes related data and behavior into maintainable Python objects with domain-specific interfaces.
- How deep it goes
- Defines classes, instances, methods, attributes, interfaces, inheritance, composition, and public-data tradeoffs through implementation exercises.
- Examples
- Uses student grade averages, ScoreList, and a Zoo class combining object-oriented methods with list comprehensions and generator expressions.
- What you can do after
- Build and maintain Python classes using methods, attributes, composition, inheritance, and documented interfaces.
Read how Python Workout, Second Edition explains object-oriented programming →
The Well-Grounded Rubyist, Fourth Edition
Object-oriented programming is a programming paradigm that organizes computation around objects that encapsulate data and perform actions in response to requests.
- How it is used
- Organizes calculations, data manipulation, and input/output as requests to objects.
- How deep it goes
- Defines the approach through a generic Ruby object and its method, then connects it to design; defers in-depth treatment of classes.
- Examples
- Uses a talking generic object and a cargo hold whose `unload` method delegates to a stack operation.
- What you can do after
- Build it from scratch by creating a Ruby object, defining and calling its method, and choosing names that express an object's purpose.
Read how The Well-Grounded Rubyist, Fourth Edition explains object-oriented programming →
Python Workout: 50 ten-minute exercises
Object-oriented programming is a programming paradigm that organizes software around objects defined by classes containing state and behavior.
- How it is used
- Organizes related data and behavior into domain-specific objects instead of separating nouns from verbs procedurally.
- How deep it goes
- Defines classes, objects, methods, and selected Python features through a score example and Zoo exercises.
- Examples
- Uses procedural and ScoreList grade calculations plus Zoo filtering, transfer, and keyword-query exercises.
- What you can do after
- Build Python classes that combine stored data with methods and extend them through practical object-oriented exercises.
Read how Python Workout: 50 ten-minute exercises explains object-oriented programming →
Go in Practice, Second Edition
Object-oriented programming is a programming paradigm that organizes software around objects combining data with operations and commonly uses abstraction, inheritance, and polymorphism.
- How it is used
- Applies object-oriented ideas to Go development through structs, interfaces, and methods.
- How deep it goes
- Explains the model through Java and Go listings, then demonstrates compile-time interface checking.
- Examples
- Uses Animal, Cat, Dog, and Llama examples to contrast inheritance with interface relationships.
- What you can do after
- Apply it via Go structs, methods, and interfaces to model object-like behavior without explicit inheritance.
Read how Go in Practice, Second Edition explains object-oriented programming →
Data-Oriented Programming in Java
Object-oriented design is a software design approach that organizes functionality around objects, their interfaces, and collaborations.
- How it is used
- Organizes enterprise workflows around objects, interfaces, responsibilities, and collaborations.
- How deep it goes
- Works through interfaces, strategies, repositories, factories, tests, and abstraction leakage, while stopping short of exhaustive pattern design.
- Examples
- Uses Java ingestion of account, invoice, and dispute files through transformers, repositories, factories, mocks, and manifest-driven loops.
- What you can do after
- Build it from scratch by decomposing a workflow into interfaces, implementations, repositories, factories, and collaborating objects.
Read how Data-Oriented Programming in Java explains object-oriented programming →
Acing the Frontend Interview
Object-oriented programming is a programming paradigm that organizes behavior and state into interacting objects, commonly represented by classes.
- How it is used
- Frames object-oriented programming as a contrasting and complementary paradigm for assessing functional JavaScript and TypeScript design.
- How deep it goes
- Reaches class-based modules and their interaction with functional pipelines, but stops short of detailed object-oriented mechanics.
- Examples
- Uses DataSource and DataSink classes around a clean-transform-summarize data pipeline.
- What you can do after
- Evaluate trade-offs when blending functional pipelines with class-based modules.
Read how Acing the Frontend Interview explains object-oriented programming →
Grokking Software Architecture
A programming paradigm that organizes software around objects containing state and behavior, commonly using classes, encapsulation, inheritance, and polymorphism.
- How it is used
- Uses OOP as the foundation for SOLID design principles and as a way to model systems that change over time.
- How deep it goes
- Defines four OOP pillars with analogies and traces OOP's origins through Simula, without showing implementation code.
- Examples
- Uses smartphone and camera analogies, app classes, and a Simula hospital with patient types and a TreatmentRoom.
- What you can do after
- Understand how objects can model changing systems and support modular extensions.
Read how Grokking Software Architecture explains object-oriented programming →
The Art of Unit Testing 3e
A programming paradigm that structures software around objects encapsulating state and behavior.
- How it is used
- Frames object-oriented design as a JavaScript paradigm and applies it to dependency injection and mock-based interaction testing.
- How deep it goes
- Treats the style through design choices, dependency injection, and mocking rather than presenting a language-independent implementation theory.
- Examples
- Uses TypeScript object-oriented examples and discusses dependency-injection and mock-object patterns.
- What you can do after
- Evaluate whether object-oriented or functional design better fits a team and apply shared patterns across both styles.
Read how The Art of Unit Testing 3e explains object-oriented programming →
Python How-To
Object-oriented programming is a programming paradigm that organizes software around objects containing data and related behavior.
- How it is used
- Organizes Python programs around objects, particularly custom-class instances that combine data with functionality.
- How deep it goes
- Defines classes, instances, attributes, and methods, then demonstrates object use without exhaustively covering Python’s object model.
- Examples
- Uses compiled regular expressions, Pattern methods, and direct re-module function calls to contrast object-oriented and functional styles.
- What you can do after
- Apply it via Python’s re module by compiling a Pattern object and invoking its attributes and search methods.
Read how Python How-To explains object-oriented programming →
The Well-Grounded Python Developer: How the pros use Python and Flask
Object-oriented programming is a programming paradigm that organizes software around objects containing state and behavior.
- How it is used
- Organizes state and the functions acting on it when separate stateful contexts become difficult to manage.
- How deep it goes
- Explains encapsulation, classes, instances, inheritance, and composition as design mechanisms for reusable objects.
- Examples
- Uses stateful function calls, collection objects, and a cookie-cutter analogy to distinguish classes from instances.
- What you can do after
- Apply it by designing classes that combine data and methods, reuse features through inheritance, and extend designs through composition.
Also covered in
- Simple Object-Oriented Design: Create clean, maintainable applications
- The Creative Programmer
- Object-Oriented Software Design in C++
- Grokking Statistics
- Kotlin in Action, 2E
- Learn Go with Pocket-Sized Projects
- Julia as a Second Language
- The Quick Python Book, Fourth Edition
- Modern Angular
- Software Design for Python Programmers
- Get Programming: Learn to code with Python
- The Art of Code
What to know first
- PythonPython is a high-level, general-purpose, dynamically typed programming language with readable syntax and support for multiple programming paradigms.
- functionA function is a callable unit of program code that performs a computation or operation, can accept inputs, and may produce a result or side effect.
- attributeAn attribute is a named property or piece of information associated with an entity, object, or structured data item.
- classA class is a programming-language construct that defines a type’s structure and behavior and provides a basis for creating or representing objects.
Related concepts
- functional programmingcontrasts with · Functional programming is a programming paradigm that expresses computation through the evaluation and composition of functions, typically favoring immutable data and minimizing mutable state and side effects.
- encapsulationhas part · Encapsulation is a software design principle that contains data and implementation details behind a controlled interface, restricting direct access to internal state.
- inheritancehas part · Inheritance is a mechanism in which a derived type or descendant element receives properties or behavior from a parent, subject to rules that may allow specialization or overriding.
- abstractionhas part · Abstraction is a simplified representation that preserves relevant properties or behavior while omitting details unnecessary at a given level or for a given purpose.
- polymorphismhas part · Polymorphism is a programming-language capability that lets a common operation or interface work with values of different types, with behavior or implementation determined by the type or value.
- relational database management systemcontrasts with · A relational database management system is software that stores and manages data organized according to the relational model and supports operations for defining, querying, and updating that data.
Questions about object-oriented programming
What is object-oriented programming?
Object-oriented programming is a programming paradigm that organizes software around objects combining state and behavior, often using encapsulation, classes, inheritance, or polymorphism.
Which Manning books explain object-oriented programming?
Software Engineering for Data Scientists, Functional Design and Architecture: Examples in Haskell, Data-Oriented Programming: Reduce software complexity, Python Workout, Second Edition, The Well-Grounded Rubyist, Fourth Edition, Python Workout: 50 ten-minute exercises, Go in Practice, Second Edition, Data-Oriented Programming in Java and 5 more.
What should I know before learning object-oriented programming?
Manning books that teach object-oriented programming usually introduce Python, function, attribute and class first.
What is the difference between object-oriented programming and functional programming?
Object-oriented programming is a programming paradigm that organizes software around objects combining state and behavior, often using encapsulation, classes, inheritance, or polymorphism. Functional programming is a programming paradigm that expresses computation through the evaluation and composition of functions, typically favoring immutable data and minimizing mutable state and side effects.
What are the parts of object-oriented programming?
Object-oriented programming includes encapsulation, inheritance, abstraction and polymorphism.
What is object-oriented programming also called?
Object-oriented programming is also called OOP, OO, object orientation, object-oriented paradigm or object-oriented style.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.












