Software Engineering and Object-Oriented Programming with Java

Vocabulary practice flashcards covering software engineering fundamentals, Git version control, object-oriented design and Java programming, inheritance, polymorphism, interfaces, exception handling, and software testing.

Waterfall Model

A sequential, plan-driven process model suited for safety-critical systems, such as vehicle and aviation controls.

Incremental / Evolutionary Model

An iterative software process model where each iteration is typically $2$ weeks long, driven by features (Agile methods), and suited for business applications.

Agile Manifesto

A software development approach focused on adapting to changes better, delivering frequently through continuous integration and delivery, and involving customers throughout development.

Pair Programming in XP

An Extreme Programming practice where two developers share a single workstation—one acting as the driver and the other as the navigator—swapping roles every few minutes.

Object-Oriented Analysis (OOA)

The development of an object model of the application or problem domain to define "what" the system does.

Object-Oriented Design (OOD)

The development of an object-oriented system model to implement requirements, focusing on "how" the system works.

Git Staging Area

An intermediate area between the working directory and the local repository where changes are staged using the Add command before being committed.

Git Commit

The command that permanently saves staged snapshot changes from the staging area into the local repository.

Git Checkout

The Git command used to switch the current active working branch.

Data Encapsulation

An OOP feature that bundles data (private variables) and operations (public methods) together within an object to better protect data.

Information Hiding

The practice of decoupling the dependency between an API and its implementation so that client code does not need to change when the internal implementation changes.

Class

An abstract data type (ADT) and blueprint/template that defines the data fields and operations for a group of similar objects.

Instantiation

The process of creating an object instance of a class, which involves allocating memory at runtime.

Constructor

A special method with the exact same name as the class and no return type (not even void), invoked using the new operator to create and initialize objects.

Anonymous Object

An object that is instantiated without being assigned to a named reference variable (e.g., new Circle(5.0).getArea()).

Garbage Collection

A Java runtime mechanism that automatically detects and reclaims memory occupied by objects that are no longer pointed to by any reference variable.

Method Overloading

Defining multiple methods within the same class that share the same name but have different method signatures (different parameter lists).

Method Overriding

Defining a method in a subclass with the same signature and a compatible return type as a method in its superclass to provide a specialized implementation.

Static Variable

A class-level variable shared by all objects of that class and stored in a single common memory space.

Coupling

The degree to which software modules depend on one another; high coupling causes a change in one component to trigger a ripple effect of required modifications across others.

Immutable Object

An object whose internal state and contents cannot be altered once it has been created (e.g., instances of String).

Autoboxing

The automatic conversion performed by the Java compiler from a primitive data type into its corresponding wrapper class object.

Auto-unboxing

The automatic conversion performed by the Java compiler from a wrapper class object back into its corresponding primitive type value.

Interned String

A memory optimization wherein the JVM maintains a single shared instance for distinct string literals that have the exact same character sequence.

Enum Class

A specialized Java class used to define a predefined set of constants in uppercase letters, inheriting directly from java.lang.Enum without allowing external instantiation via new.

Dependency (OOD)

A relationship where one class depends on another such that changes to the second might necessitate changes to the first (e.g., passing an object as a method parameter).

Aggregation

A "has-a" ownership relationship between classes where the aggregated component can exist independently of the aggregating owner object, designated in UML with a hollow diamond.

Composition

A strict form of aggregation where the lifetime of the aggregated object depends entirely on the owner object and cannot exist independently, designated in UML with a solid diamond.

Refactoring

The process of altering the internal structure of software without altering its external behavior to improve readability, eliminate redundancy, and facilitate debugging.

Bad Code Smell

A surface indicator or structural defect in code (such as duplicate code, long methods, lazy classes, or data clumps) that suggests deeper architectural problems.

super Keyword

A keyword used as the first line of code in a subclass constructor to explicitly call a superclass constructor, or used to reference an overridden superclass method.

Polymorphism

The principle that an instance of a subclass can be used wherever a superclass object is expected, enabling dynamic runtime dispatch of overridden methods.

Dynamic Binding

The runtime resolution process by which the JVM determines which implementation of an overridden method to execute based on the actual object type rather than the declared reference type.

Abstract Class

A class defined with the abstract keyword that cannot be instantiated directly and can contain constructors, instance variables, concrete methods, and abstract methods.

Interface

A reference type specifying common operations across classes that contains only abstract methods and constants, implemented by concrete classes via realization.

Template Method Pattern

A design pattern wherein the parent class defines the invariant sequence of execution steps while allowing subclasses to customize specific step implementations.

Exception

A runtime object that represents an error or abnormal condition preventing normal program execution from continuing.

Checked Exception

An exception that the Java compiler requires the programmer to explicitly catch with a try-catch block or declare in the method signature with throws (e.g., IOException).

Unchecked Exception

An exception subclassing RuntimeException that reflects programming logic errors and is not enforced by the compiler for try-catch handling.

finally Block

A block following a try block that executes regardless of whether an exception occurs or is caught, commonly utilized to perform cleanup actions like closing resources.

Exception Propagation

The automatic backward traversal of an uncaught thrown exception through the call stack until an appropriate matching catch handler is encountered.

Software Testing

The activity of executing a software application to find defects and verify whether it fulfills specified requirements.

Test Oracle

A source or mechanism that determines what the expected output or result of a given test case should be.

White-Box Testing

A software testing technique that analyzes internal code structures, execution paths, conditions, and branch coverage.

Black-Box Testing

A software testing technique that tests inputs and outputs against functional specifications without reference to internal source code implementation.

Equivalence Class Partitioning

A black-box testing strategy that divides input data ranges into distinct groups of equivalent values from which representative test inputs are selected.

Boundary Value Analysis

A test design technique focused on selecting test values specifically at the extreme upper and lower boundaries of equivalence partitions.