OOP

Object-Oriented Programming (OOP)

Object-oriented programming (OOP) is a programming paradigm that organizes code around objects — bundles of data (attributes) and behavior (methods) — using co…

The CString Class

How MFC's CString class manages dynamic text, formatting, searching, and interop with Win32 string APIs.

MFC Collection Classes

A tour of MFC's template and legacy collection classes for storing arrays, lists, and maps of data, and how to choose between them.

LINQ to Objects

LINQ to Objects is the flavor of LINQ that runs entirely in memory against IEnumerable<T> collections like arrays, List<T>, and Dictionary<T>, using compiled d…

Class Libraries and NuGet Packages

Understand how to build reusable .NET class libraries, reference them across projects, and package and publish them as NuGet packages.

GPO Scope and Inheritance

How GPO scope is controlled through linking, security filtering, WMI filtering, Block Inheritance, and Enforced links, and how conflicts are resolved.

Group Policy Objects Explained

An introduction to Group Policy Objects (GPOs), how they store settings, and how they get applied to users and computers in Active Directory.

Users, Groups, and Computer Objects

The core AD object types — user accounts, security/distribution groups, and computer accounts — and how group scope and type govern permissions.

Entity Classes and Conventions

Learn how EF Core discovers and maps plain C# classes to database tables using convention-based modeling, including primary keys, shadow properties, and backin…

Page Object Model in Playwright

How to structure Playwright tests using the Page Object Model to separate UI locators and actions from test logic for better maintainability.

Actions Class: Mouse Hover and Drag-and-Drop

Learn how Selenium's Actions class composes mouse hover, click-and-hold, and multi-step drag gestures that simple click() and sendKeys() calls cannot express.

Page Object Model (POM)

Understand the Page Object Model design pattern for organizing Selenium tests around reusable, maintainable page classes instead of scattered locators.

Working with Objects

Understand how every piece of PowerShell output is a typed .NET object with properties and methods, and learn to inspect, access, and build them.

Object-Oriented Fortran

Explore how modern Fortran supports encapsulation, inheritance via type extension, and runtime polymorphism through CLASS and SELECT TYPE.

Object-Oriented Pascal

Learn how Pascal implements classes, inheritance, polymorphism, and constructors/destructors through the `class` type and virtual methods.

Object Pascal Basics

Get started with Object Pascal's classes, methods, constructors, and inheritance — the object-oriented extension of standard Pascal.

Your First Apex Class

A hands-on walkthrough of writing a simple Apex class, covering class structure, methods, access modifiers, static vs instance members, and how to test it.

Inheritance in Solidity

Inheritance lets contracts reuse and extend each other with the is keyword, virtual/override, super, C3-linearized multiple inheritance, and ordered constructo…

The Workbook and Worksheet Objects

Learn how the Workbook and Worksheet objects sit at the heart of Excel's object model, and how to reference, add, activate, and manage them reliably in VBA.

Classes and Objects in VB.NET

Learn how VB.NET classes act as blueprints and objects as their instances, covering fields, methods, constructors, and Shared members.

Inheritance and Interfaces

Explore how VB.NET classes reuse and extend behavior through Inherits, Overridable/Overrides, and how Interfaces define implementation-free contracts.

Properties and Encapsulation

Understand how VB.NET Property blocks and Private fields work together to enforce encapsulation, validation, and controlled access to object state.

Tcl Object-Orientation with TclOO

How to define classes, objects, methods, and inheritance in Tcl using the built-in TclOO framework (oo::class, oo::define, oo::copy).

Class Methods vs Instance Methods

Learn the difference between Objective-C's + class methods and - instance methods, and when to use each in real-world class design.

Classes and Objects in Objective-C

How Objective-C classes are declared with @interface/@implementation, and how objects are created via alloc and init.

Java Cheat Sheet

Core Java syntax, data types, collections, generics, and streams for writing robust object-oriented JVM applications.

C# Cheat Sheet

Core C# syntax, LINQ queries, generic collections, async/await patterns, and object-oriented features for building .NET applications.

Kotlin Cheat Sheet

Kotlin syntax, null safety, data classes, coroutines, and extension functions for concise, safe JVM development.

Swift Cheat Sheet

Swift syntax, optional handling, structs versus classes, protocols, and closures for building type-safe iOS and macOS applications.

Ruby Cheat Sheet

Ruby syntax, blocks, symbols, mixins, and enumerable methods for expressive, object-oriented scripting and web development.

PHP Cheat Sheet

PHP syntax, associative arrays, superglobals, and object-oriented features for server-side web development and dynamic scripting.

Scala Cheat Sheet

Scala syntax, case classes, pattern matching, immutable collections, and functional programming features that run on the JVM.

Objective-C Cheat Sheet

Fundamental Objective-C syntax covering classes, properties, messaging, ARC memory management, and protocols.

PowerShell Scripting Cheat Sheet

Core PowerShell scripting reference covering variables, the object pipeline, control flow, functions, and common cmdlets.

VB.NET Cheat Sheet

Core VB.NET syntax covering variables, control flow, classes and inheritance, collections, and common data types.

Groovy Cheat Sheet

Practical Groovy syntax covering closures, collections, GDK operators, and classes for the JVM dynamic language.

Crystal Cheat Sheet

Core Crystal syntax covering static typing, classes, collections, and blocks for a Ruby-like compiled language.

Smalltalk Cheat Sheet

Foundational Smalltalk syntax covering message sends, class definitions, block-based conditionals and loops, and common collection operations.

Python OOP Cheat Sheet

Object-oriented Python covering classes, inheritance, dunder methods, computed properties, class/static methods, and abstract base classes.

Python Decorators Cheat Sheet

Python decorator patterns including basic function wrappers, functools.wraps, parameterized decorators, class-based decorators, and common built-in decorators.

Python Metaclasses Cheat Sheet

Covers how Python classes are created via type, writing custom metaclasses, and when to reach for simpler alternatives instead.

JavaScript DOM Manipulation Cheat Sheet

Covers selecting DOM elements, creating and modifying nodes, handling events with delegation, and toggling classes with vanilla JavaScript.

JavaScript Prototypes & Inheritance Cheat Sheet

Covers the prototype chain, constructor functions, ES6 class syntax, and Object.create for building inheritance in JavaScript.

JavaScript Web Workers Cheat Sheet

Covers creating dedicated workers, message passing with postMessage, transferable objects, and the limits of the worker global scope.

Modern JavaScript (ES2020+) Cheat Sheet

Summarizes optional chaining, nullish coalescing, BigInt, new Promise combinators, private class fields, and other ES2020-ES2023 additions.

JavaScript Destructuring & Spread Cheat Sheet

Covers array and object destructuring with defaults and renaming, the spread operator for arrays and objects, and common usage patterns.

TypeScript Decorators Cheat Sheet

Covers enabling legacy experimental decorators, writing class, method, property, and parameter decorators, and their execution order.

TypeScript Generics Deep Dive Cheat Sheet

Covers generic functions, constraints with extends and keyof, generic classes with default type parameters, and common generic patterns.

Java OOP Cheat Sheet

Covers classes, constructors, inheritance, polymorphism, interfaces with default methods, and Java's access modifiers with examples.

What is Polymorphism in OOP?

Polymorphism is the object-oriented principle that lets objects of different classes respond to the same method call in their own class-specific way.

Difference Between Abstraction and Encapsulation

Abstraction hides complexity by exposing only the essential behavior of an object, while encapsulation hides an object’s internal data by bundling it with the…

What are the Four Pillars of OOP?

The four pillars of object-oriented programming are Encapsulation, Abstraction, Inheritance, and Polymorphism — the principles that structure code around objec…

Difference Between Interface and Abstract Class

An interface defines a contract of methods a class must implement with no state, while an abstract class can provide partial implementation and state and serve…

Composition vs Inheritance in OOP

Inheritance models an "is-a" relationship where a class derives from a parent, while composition models a "has-a" relationship where a class is built from othe…

What are SOLID Principles?

SOLID is five object-oriented design principles — Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion — th…

What is Inheritance in OOP?

Inheritance is the object-oriented mechanism by which a class (the subclass) acquires the fields and methods of another class (the superclass), enabling code r…

Method Overloading vs Overriding

Method overloading is defining multiple methods with the same name but different parameter lists within a class, resolved at compile time, while method overrid…

What is Encapsulation in OOP?

Encapsulation is the object-oriented principle of bundling an object’s data with the methods that operate on it and restricting direct access to that data from…

What is a Constructor in OOP?

A constructor is a special method invoked automatically when an object is created that initializes the object’s state, sharing the class’s name and having no r…

What is Abstraction in OOP?

Abstraction is the object-oriented principle of exposing only the essential features and behavior of an object while hiding the underlying implementation compl…

What is Method Overriding in OOP?

Method overriding is when a subclass provides its own implementation of a method already defined in its superclass, using the same name and signature.

What is Coupling and Cohesion in OOP?

Coupling measures how dependent one module or class is on another, while cohesion measures how strongly the responsibilities inside a single module belong toge…

What is the Observer Pattern?

The Observer pattern defines a one-to-many dependency where a subject notifies a list of registered observers automatically whenever its state changes.

What is a Virtual Function?

A virtual function is a member function declared in a base class that a derived class can override, with the actual implementation resolved at runtime based on…

Aggregation vs Composition in OOP

Aggregation and composition are both "has-a" relationships between objects, but composition implies strict ownership where the part cannot outlive the whole, w…

What is the Liskov Substitution Principle?

The Liskov Substitution Principle (LSP) states that objects of a subclass must be substitutable for objects of the base class without altering the correctness…

What is the Strategy Pattern?

The Strategy pattern defines a family of interchangeable algorithms, encapsulates each one behind a common interface, and lets the client swap the algorithm at…

What is Multiple Inheritance?

Multiple inheritance is when a class inherits fields and methods from more than one parent class simultaneously, combining their behavior into a single subclas…

What is a Copy Constructor?

A copy constructor is a special constructor that creates a new object as a duplicate of an existing object of the same class, copying its field values into the…

What is the Open-Closed Principle?

The Open-Closed Principle (OCP) states that software entities — classes, modules, functions — should be open for extension but closed for modification, meaning…

What is the Builder Pattern?

The Builder pattern is a creational design pattern that separates the step-by-step construction of a complex object from its final representation, letting the…

What is the Prototype Pattern?

The Prototype pattern is a creational design pattern that creates new objects by cloning an existing, fully configured instance rather than constructing one fr…

What is the Adapter Pattern?

The Adapter pattern is a structural design pattern that converts the interface of an existing class into another interface a client expects, letting otherwise…