Object-Oriented Programming Flashcards

Question 1

What is a class in object-oriented programming, and what does it define?

Accepted Answer

A class is a blueprint that defines the attributes and methods shared by every object of one kind. It describes what data an object will hold and what actions it can perform, but it does not store particular values. Programmers write the class once and then create as many objects from it as needed.

Question 2

What is an object, and how does it relate to a class?

Accepted Answer

An object is a concrete instance created from a class, holding its own set of values for the attributes the class defines. Two objects built from the same class share the same structure and behavior but can differ in their data. For example, many Car objects can differ in color and mileage.

Question 3

What is an attribute, and how does it differ from a method?

Accepted Answer

An attribute is a named piece of data stored by an object, such as a name or a balance. A method is a named procedure that belongs to a class and operates on an object's data, such as deposit or print. Attributes describe what an object knows, while methods describe what it can do.

Question 4

What is a constructor and why is it used?

Accepted Answer

A constructor is a special method that runs automatically when an object is created from a class. Its main job is to set up the new object in a valid starting state, usually by assigning initial values to its attributes. This ensures that no object begins its life with missing or invalid data.

Question 5

What is the difference between instance variables and class variables?

Accepted Answer

An instance variable belongs to each individual object, so every object keeps its own copy of the value. A class variable, sometimes called a static variable, belongs to the class itself and is shared by all of its objects. Changing a class variable affects every object that reads it.

Question 6

What does it mean for an object to have state and behavior?

Accepted Answer

State is the set of current attribute values that describe an object at a given moment, while behavior is the set of methods that the object can perform. Together they define what an object is and what it does. Two objects of the same class can have different states but the same behavior.

Question 7

What is a reference, and why does it matter when two variables point to one object?

Accepted Answer

A reference is a value that tells the program where an object lives in memory, so a variable holding a reference points to the object rather than containing a copy of it. When two variables refer to the same object, a change made through one is visible through the other.

Question 8

What is object identity, and how does it differ from equality of values?

Accepted Answer

Object identity asks whether two references point to the very same object in memory. Equality of values asks whether two objects contain the same data, even if they are separate objects. Two distinct objects can be equal in value but not identical, so languages usually provide separate operations for each check.

Question 9

What does encapsulation mean in object-oriented programming design?

Accepted Answer

Encapsulation is the practice of bundling an object's data together with the methods that operate on that data, while controlling how outside code can access it. It hides internal details behind a defined interface. The goal is to keep internal state consistent and let the implementation change without breaking callers.

Question 10

Why do programmers make attributes private and expose public methods instead?

Accepted Answer

Private attributes can only be read or changed by the class's own code, so the class can enforce rules about valid values. Public methods act as a controlled gateway, letting outside code request actions safely. For example, a withdraw method can refuse an amount that would make a balance negative.

Question 11

What are access modifiers, and what do public, private, and protected typically mean?

Accepted Answer

Access modifiers are keywords that control which code is allowed to use a class member. Public members can be used from anywhere, private members only from inside the same class, and protected members from the class and its subclasses. Exact rules vary by language, so check the documentation for the language you are using.

Question 12

What is a getter, and what is a setter?

Accepted Answer

A getter is a method that returns the value of a private attribute, and a setter is a method that assigns a new value to it. Using them instead of direct access lets the class validate input, compute derived values, or log changes. Read-only data may need only a getter.

Question 13

What is an invariant, and how does encapsulation help protect one?

Accepted Answer

An invariant is a condition that must always hold true for an object, such as a bank balance never being negative. Encapsulation protects invariants because only the class's own methods can change the internal data, and those methods can validate each change. If outside code cannot bypass the checks, the invariant stays intact.

Question 14

How does immutability relate to encapsulation in object design?

Accepted Answer

An immutable object is one whose state cannot change after construction, so every attribute is set once and never modified. Immutability complements encapsulation because it removes the need to guard against later changes. Immutable objects are also safe to share between parts of a program, since no one can alter them unexpectedly.

Question 15

What is a property in languages that support them, and how does it differ from a plain public attribute?

Accepted Answer

A property looks like a simple attribute when read or written, but it is actually backed by getter and setter logic that runs behind the scenes. Callers keep the convenient syntax of field access, while the class retains control over validation and computed values. A plain public attribute offers no such hook.

Question 16

What is a defensive copy, and when should a class return one?

Accepted Answer

A defensive copy is a duplicate of a mutable object, created so that the original internal data cannot be changed through a reference the caller holds. A class should return one whenever it hands out a mutable internal object, such as a list, since otherwise callers could alter its state.

Question 17

What is inheritance, and what problem does it solve?

Accepted Answer

Inheritance lets a new class, called a subclass, reuse and extend the attributes and methods of an existing class, called its superclass or base class. It solves the problem of duplicating shared code across related classes. A Dog class might inherit common behavior from an Animal class and add behavior of its own.

Question 18

What does an is-a relationship mean, and how does it guide inheritance?

Accepted Answer

An is-a relationship means that a subclass object can truthfully be described as a kind of its superclass, such as a Dog being an Animal. Inheritance fits best when this statement holds in every context the subclass will be used. If the relationship is only partial, composition is usually the better choice.

Question 19

What is method overriding, and how does it differ from overloading?

Accepted Answer

Method overriding happens when a subclass provides its own implementation of a method that it inherits, keeping the same name and parameters. Overloading means defining several methods with the same name but different parameter lists within one class. Overriding changes behavior along an inheritance chain, while overloading offers variations for different inputs.

Question 20

What is polymorphism, and why is it useful?

Accepted Answer

Polymorphism means that one interface can be used with objects of different classes, and each object responds in its own way. Code that calls a method on a superclass reference can work with any subclass without knowing its type. This lets programs add new kinds of objects without rewriting the code that uses them.

Question 21

How does dynamic dispatch allow polymorphism to work at runtime?

Accepted Answer

Dynamic dispatch is the process of choosing which method implementation to run based on the actual type of the object at runtime, not the declared type of the variable holding it. When a call is made through a superclass reference, the runtime looks up the object's real class and runs its version of the method.

Question 22

Why does a subclass constructor usually call its superclass constructor first?

Accepted Answer

The superclass portion of an object must be initialized before the subclass adds its own fields, because the subclass depends on inherited attributes being in a valid state. Calling the superclass constructor first guarantees this order. Some languages insert an implicit call automatically when none is written.

Question 23

What is an abstract class, and how is it different from a regular superclass?

Accepted Answer

An abstract class is a class that cannot be instantiated directly and typically includes one or more methods declared without a full implementation. Its purpose is to define a common base that subclasses must complete. A regular superclass can be created as an object on its own and usually provides working behavior.

Question 24

Why might a subclass call the overridden method from its superclass?

Accepted Answer

A subclass sometimes wants to extend the superclass behavior rather than replace it entirely. It can call the parent version explicitly, perform its own extra work, and then combine the results. This pattern is common in constructors, logging, and validation, where the base behavior should always run.

Question 25

What is abstraction, and how does it differ from encapsulation?

Accepted Answer

Abstraction is the practice of exposing only the essential features of an object while hiding unnecessary complexity. Encapsulation is the mechanism that bundles data with methods and restricts access to internal state. Abstraction is about deciding what a user needs to see, while encapsulation is about enforcing that boundary in code.

Question 26

What is an interface, and what does it promise to callers?

Accepted Answer

An interface is a named contract that lists method signatures a type must provide, without supplying the implementation. Any class that implements the interface promises to support every listed method, so callers can rely on them. The interface describes what can be done, not how it is done.

Question 27

How does programming to an interface rather than a concrete class help a design?

Accepted Answer

Code that depends on an interface does not care which concrete class supplies the behavior, so implementations can be swapped without editing the caller. This makes it easier to test code by substituting a fake implementation, and to extend a system with new classes. Depending on stable contracts reduces the ripple effect of changes.

Question 28

When would you choose an abstract class over an interface?

Accepted Answer

Choose an abstract class when related subclasses share real code, state, or a common constructor, since an abstract class can hold fields and concrete methods. Choose an interface when unrelated classes need to promise the same capability, since a class can usually implement several interfaces but extend only one superclass.

Question 29

What is an abstract method, and what must a subclass do with it?

Accepted Answer

An abstract method is a method declared in an abstract class or interface without a body. It defines a required operation that every concrete subclass must implement before it can be instantiated. A subclass that leaves any abstract method unimplemented must itself be declared abstract. This lets the base class call the operation safely.

Question 30

What does it mean to program against a contract, and why do tests often rely on it?

Accepted Answer

Programming against a contract means writing code that depends only on the promised behavior described by an interface or documented API. Tests often rely on this because they can replace a real dependency, such as a database connection, with a simple stand-in that follows the same contract.

Question 31

What is the main risk of adding a new method to a widely used interface?

Accepted Answer

Every class that implements the interface must then provide the new method, or the code will fail to compile or run. This can break third-party classes that the original authors never see or control. For that reason, interfaces are usually kept small and stable once other code depends on them.

Question 32

Why should an interface name describe a capability rather than an implementation detail?

Accepted Answer

An interface name should describe what callers can expect, such as Comparable or Readable, rather than how one particular class achieves it. A name tied to an implementation, such as ArrayBackedList, misleads readers and limits future classes that might satisfy the same contract differently. Capability-based names keep the contract focused on behavior.

Question 33

What is composition, and how does it differ from inheritance?

Accepted Answer

Composition builds a class by holding references to other objects and delegating work to them, rather than acquiring behavior through a superclass. It models a has-a relationship, such as a Car having an Engine. It is often preferred because it avoids rigid parent hierarchies.

Question 34

What does the single responsibility principle ask of a class?

Accepted Answer

The single responsibility principle says that a class should have one reason to change, meaning it should handle one well-defined job. When a class mixes unrelated duties, a change to one risks breaking the other. Splitting responsibilities into separate classes keeps each piece easier to understand, test, and modify.

Question 35

What is the open-closed principle, and how do interfaces help apply it?

Accepted Answer

The open-closed principle says that software entities should be open for extension but closed for modification. New behavior should be added by writing new classes, not by editing tested code. Interfaces help because new implementations can be plugged in wherever the interface is expected, without changing the code that uses it.

Question 36

What is the Liskov substitution principle, and what does a violation look like?

Accepted Answer

The Liskov substitution principle says that an object of a subclass should be usable wherever its superclass is expected, without breaking correctness. A violation occurs when a subclass overrides a method in a way that breaks the assumptions callers rely on, such as refusing an operation that the superclass promises to support.

Question 37

What does the dependency inversion principle recommend for high-level modules?

Accepted Answer

The dependency inversion principle recommends that high-level modules and low-level modules both depend on abstractions, such as interfaces, rather than on each other's concrete classes. Details should depend on policies, not the other way around. This arrangement lets the core logic stay stable while storage, networking, or display details change.

Question 38

What is the observer pattern, and when is it useful?

Accepted Answer

The observer pattern lets an object, the subject, keep a list of observers and notify them automatically when its state changes. Observers subscribe and unsubscribe at runtime, so the subject need not know their concrete types. It is useful for event handling, such as updating a user interface when a data model changes.

Question 39

What problem does the factory method pattern solve?

Accepted Answer

The factory method pattern moves the decision about which concrete class to create into a dedicated method, so calling code asks for an object without naming its exact class. This keeps creation logic in one place and lets subclasses choose the product they produce. It helps code depend on interfaces instead of hard-coded constructors.

Question 40

What does it mean to favor loose coupling and high cohesion in class design?

Accepted Answer

Loose coupling means classes depend on each other as little as possible, so a change in one rarely forces changes in others. High cohesion means the members of a class are closely related and work toward one clear purpose. Together, these qualities produce designs that are easier to understand, test, and maintain.

Object-Oriented Programming Flashcards

1Core Object Concepts

2Encapsulation and Access Control

3Inheritance and Polymorphism

4Abstraction and Interfaces

5Design Principles and Patterns

Learning Resources