Object-Oriented Programming (OOP) Terms in Java

A complete set of 18 vocabulary flashcards covering key object-oriented programming concepts, components, and method types in Java.

Declaration statement for an instance field

Creates a variable that represents an attribute or state of an object. Declared at the class level (outside any methods) and usually marked private (e.g., private int score;).

Actual parameter

The real value or variable passed into a method or constructor when you call it (also called an argument), placed inside the parentheses of a call statement (e.g., 10 in player.setScore(10);).

Call statement for a method

An instruction that tells the program to execute a specific block of code (a method), used anywhere in code where an action needs to be performed (e.g., dog.bark();).

Private encapsulated method

A method hidden from other classes to keep internal logic secure, used strictly within its own class to handle internal, hidden tasks (e.g., private void validatePassword() { … }).

Object-oriented design

A software planning methodology that organizes programs around real-world objects and data, used during the planning phase to map out classes, fields, and interactions.

Client class

A class that makes use of another class by instantiating it or calling its methods, acting as the 'user' or external interface that interacts with a separate utility class.

Formal parameter

A placeholder variable defined in a method's header to accept incoming data, located inside the parentheses of a method definition or signature (e.g., int newAge in public void setAge(int newAge)).

Helper method

A private method written to assist other public methods within the same class, used to break down long, complex routines and avoid duplicating code inside a class.

Default constructor

A hidden, no-argument constructor automatically provided by the compiler if you write zero constructors, running behind the scenes to allocate memory and assign default values ($0$, null, false).

Main method

The mandatory entry point where a standalone Java program begins executing code, placed in the primary class you want to run (public static void main(String[] args)).

Overloaded constructor

When a class has multiple constructors with the same name but different parameters, used to give the programmer multiple options for creating and initializing an object.

Modifier method

A public method (commonly called a setter) used by client classes to safely change or update an object's internal private instance variable data.

Object class

The universal root class (java.lang.Object) that every single Java class implicitly inherits from, used as a generic type or to inherit core methods like .toString() and .equals().

Declaring a reference

Creating an object variable name without assigning it an actual object yet, allocating space for a pointer in memory that temporarily holds a value of null.

Child class

A class that inherits fields and behaviors from another class (the parent class), used to extend code functionality using the extends keyword.

Object variable

A variable that holds the memory address (reference) of an instantiated object, used to track, modify, and interact with objects throughout your code.

Accessor method

A public method (commonly called a getter) that reads and returns a private instance variable, used by client classes to safely view data without being allowed to modify it directly.

No-argument constructor

A constructor explicitly written by the programmer that accepts zero parameters, used to set custom, default starting values for an object when no specific details are provided.