What is the difference between stack and heap memory in OOP?

In OOP languages, objects are primarily stored in the heap, while primitive values and references live on the stack. Understanding this explains how objects are managed: Stack memory: fast, LIFO allocation; stores: local variables, method call frames, primitive values, object references (not the objects themselves); automatically managed — freed when method returns; limited size (stack overflow on deep recursion). Heap memory: slower, dynamically managed; stores: actual object instances; managed by garbage collector (Java/C#/Python) or manually (C++) or by ARC (Swift); larger than stack; where all new allocations go. How objects work: // In Java: void processOrder() { int amount = 100; // Stack: amount=100 Order order = new Order(); // Stack: order=reference; Heap: actual Order object order.setAmount(amount); // Heap object is modified // When method returns: // Stack frame removed -- amount gone, order reference gone // Heap object remains until GC collects it }. Garbage collection: Java, C#, Python automatically reclaim heap memory when objects are no longer referenced. GC tracks references — when count reaches zero, memory is freed. Memory leak: when objects remain referenced (preventing GC) but are no longer needed. Common cause: event listeners not removed, static collections growing unbounded, long-lived objects holding references to short-lived ones. Stack overflow: infinite recursion exceeds stack size — stack frames can't be allocated. OutOfMemoryError: heap is full — GC can't reclaim enough memory. In Java, heap size configurable: -Xmx2g.