Object-Oriented Programming Principles in Java

Vocabulary flashcards covering the core concepts of Object-Oriented Programming in Java including Encapsulation, Abstraction, Inheritance, and Polymorphism based on Day 6 training notes.

Object-Oriented Programming (OOP)

A programming paradigm that structures software into independent, interacting units (objects) and relies on principles such as abstraction, encapsulation, inheritance, and polymorphism to provide code reusability and flexibility.

Class

The basic structure or blueprint in object-oriented programming used to create objects, defining their attributes (variables) and behaviors (methods).

Object

A specific instance (instance of a class) created from a class that possesses its own state and can perform tasks through its behaviors and interactions with other objects.

Attributes

The variables defined within a class that represent the properties and store the state of an object.

Behavior

The set of methods defined within a class that operate on its variables and define the operations or actions an object can perform.

Internal State

The specific set of values held by an object's variables at any given point during program execution.

Class Members

The collective set of variables and methods contained within a class definition.

Encapsulation

The OOP principle of bundling data and possible operations together within an object while hiding direct access to internal state through controlled access modifiers.

Abstraction (Information Hiding)

A design principle that focuses on exposing what a class or object does through its public interface while concealing the complex implementation details of how it operates.

public Access Modifier

An access specifier that makes a class member accessible to any other class in any package.

private Access Modifier

An access specifier that restricts visibility of a class member strictly to within the defining class itself.

protected Access Modifier

An access specifier that allows members to be accessed by any class in the same package, as well as by subclasses located in different packages.

Default Access Modifier

The access level applied when no modifier keyword is specified, permitting access only to classes within the same package.

Access Modifier Permissions

A summary chart detailing accessibility levels across classes, packages, subclasses, and external packages for public, protected, default, and private members.

Accessor Methods (Getters)

Public methods used to retrieve or inspect the values of private instance variables from outside the class.

Mutator Methods (Setters)

Public methods used to control and modify the values stored in private instance variables while enforcing state integrity.

this Keyword

An internal reference keyword used within a class to refer to the current executing object instance.

Instance Members

Variables and methods that belong to a specific object instance of a class, requiring object creation prior to invocation.

Static Members

Variables and methods defined with the static keyword that belong to the class itself rather than individual instances, accessed directly via ClassName.member.

Java Class Library (API)

A pre-packaged collection of reusable object classes organized into packages (such as java.util) provided by the Java environment.

Inheritance

An OOP mechanism that allows a derived class (subclass) to inherit attributes and methods from an existing class (superclass), enabling code reuse and hierarchical organization.

Superclass

The parent class in an inheritance hierarchy from which attributes and methods are inherited by subclasses.

Subclass

A derived class that inherits members from a superclass using the extends keyword and can add or specialize its own features.

Object Class

The root superclass of all classes in Java, automatically serving as the base parent class if no explicit superclass is declared.

final Keyword (Class Level)

A modifier applied to a class declaration that prevents other classes from inheriting from or extending it.

Method Overriding

Redefining a method in a subclass with the exact same signature (name and parameters) as a method in its superclass to customize its behavior.

Method Overloading

Defining multiple methods within the same class (or across parent/child classes) that share the same name but differ in parameter types or count.

Polymorphism

The principle of 'one interface, multiple methods,' allowing a single method call or interface reference to exhibit different behaviors depending on the runtime object type.

Interface

A program component containing method headings without bodies, implemented by classes using the implements keyword to guarantee specific functionality.

Abstract Class

A class declared with the abstract keyword that cannot be directly instantiated and can contain abstract methods without bodies that subclasses must implement.