Pick a focused question that fits your time, stack, and interview goal.
How much time do you have?
Show one-drill sessions you can finish now.
38 results across 1 active filter
Page 2 of 2
Defines abstraction as a deliberate contract over essential behavior, then explains practical C# boundaries and the cost of weak abstractions.
Defines abstraction as a deliberate contract over essential behavior and keeps Java mechanisms secondary to the design purpose.
Defines object-oriented programming clearly, then connects objects, responsibilities, and the main OOP mechanisms to practical C# design.
Defines OOP directly and connects Java objects, responsibilities, state, behavior, and collaboration to a practical design.
Distinguishes a Java type definition from a concrete runtime instance and keeps identity, state, and polymorphism tied to the question.
Uses sealed types for deliberately closed variants and connects them to exhaustive reasoning, evolution, and open extension boundaries.
Positions records as transparent, shallowly immutable data carriers with generated value-oriented members and clear modeling limits.
Frames inheritance as a behavioral is-a relationship whose subtypes must remain valid substitutes, not merely a code-reuse shortcut.
Connects static ownership to constants and stateless operations while exposing the risks of global mutable state and initialization.
Distinguishes reference identity from logical equality and shows how nulls, strings, enums, and domain values affect the choice.
Compares Java interfaces and abstract classes through contract, shared state, implementation reuse, and evolution trade-offs.
Explains how delegation preserves replaceable behavior and narrower coupling while recognizing valid inheritance cases.
Separates String immutability from interning and connects both to safe sharing, equality, concatenation, and practical performance.
Connects Java's equality and hash contracts to real HashMap and HashSet behavior, including mutable-key failures.