IB Computer Science - Option D

Flashcards in bold are HL content. Generated with GPT o3-mini using ThinkIB Notes.

Object

A self-contained unit that encapsulates data (attributes) and behaviors (methods) representing a real-life entity.

Instantiation

The process of creating an instance (object) from a class blueprint using a constructor.

UML

Unified Modeling Language; a visual language used to design and represent the structure of object-oriented systems.

Decomposition

The process of breaking a complex problem or system into smaller, manageable objects with distinct responsibilities.

Relationships

The ways objects interact, including inheritance (is-a), association (has-a), and dependency (uses-a).

Dependencies

Connections where one object or class relies on another for functionality, affecting code flexibility and maintenance.

Data Types

Classifications of data (e.g., int, float, String, boolean) that determine the kind of values variables can hold.

Parameters

Special variables defined in a method’s signature that accept values (arguments) when the method is called.

Encapsulation

The bundling of data and methods within an object while restricting direct access to some of its components.

State

The current values of an object's attributes, reflecting its properties at a specific point in time.

Behavior

The actions or operations (methods) that an object can perform to interact with data or other objects.

Constructor

A special method in a class used to initialize new objects, often having the same name as the class.

Default Constructor

An automatically provided constructor (if none is defined) that initializes an object with default values.

Inheritance

An object-oriented concept where a subclass acquires the properties and behaviors of a superclass (an “is-a” relationship).

Association

A general relationship where one class interacts with or uses another, often described as a “has-a” or “uses-a” relationship.

Aggregation

A form of association indicating a “has-a” relationship where parts can exist independently of the whole.

Composition

A strong form of aggregation where parts cannot exist without the whole, representing a “part-of” relationship.

Dependency

A relationship where one class relies on another for a specific function, often implemented via method parameters or local variables.

Interface

A contract that specifies a set of methods a class must implement, promoting abstraction and loose coupling.

Abstract Class

A class that contains both abstract (no implementation) and concrete methods, used as a base for subclasses.

Design Patterns

Reusable solutions to common design problems that reduce dependencies and promote modular, flexible code.

Declaration

The step in object creation where a variable of a specific object type is defined.

Initialization

The process of setting an object's initial state by calling its constructor during instantiation.

Argument

The actual value provided to a method's parameter when the method is invoked.

Encapsulation

A language mechanism that bundles data with the methods that operate on that data, while restricting access to some of the object's components.

Access Modifiers

In Java, keywords (private, default, protected, public) used to control the visibility of class data and methods.

Advantages of Encapsulation

Enhances code reusability, maintainability, flexibility, and security by modeling real-world entities and controlling data access.

Inheritance

An OOP feature that represents the “is-a” relationship; it allows a subclass to inherit properties and methods from a superclass.

Inheritance Terminology

The subclass (child) is derived from the superclass (parent), typically using the "extends" keyword in Java.

Advantages of Inheritance

Promotes code reuse and maintainability by centralizing common variables and behavior in a superclass.

Polymorphism

The ability of a programming language to process objects differently based on their data type or class, enabling method overriding and overloading.

Overriding

When a subclass provides its own implementation of a method that is already defined in its superclass, enabling dynamic method dispatch.

Overloading

Defining multiple methods in the same class with the same name but different argument lists (different number, type, or sequence of parameters).

Object Libraries

Collections of pre-written, reusable code (classes and objects) that streamline development by providing standard functionality.

Advantages of Object Libraries

Enable faster development, increased reliability, easier debugging, consistency, reduced costs, and access to specialized expertise.

Disadvantages of OOP

Includes a steeper learning curve, increased complexity, larger program size, potentially slower performance, and may not be ideal for all problem types.

Programming Teams

Collaborative groups of developers who work together using modular design and standardized coding practices to improve productivity and quality.

Advantages of Programming Teams

Faster development through parallel work, reduced dependencies via modularity, specialized expertise, and improved communication and innovation.

Modularity

The design principle of breaking a program into smaller, self-contained modules, each responsible for a specific function.

Advantages of Modularity in Program Development

Improves maintainability, readability, reusability, testing, parallel development, and scalability by isolating functionality into distinct components.

Class

A template containing methods and variables that model the state and behavior of an object; specific instances can be created from it.

Identifier

A name given to a package, class, interface, method, or variable.

Primitive

A basic data type in Java (e.g., int, long, double, char, boolean) that defines the kind of data a variable can hold.

Instance variable

A variable defined in a class that holds unique data for each object created from that class.

Parameter variable

A variable defined in a method's signature that receives a value (argument) when the method is called.

Local variable

A variable declared inside a method or block that is accessible only within that specific scope.

Method

A procedure defined within a class that represents the behavior or functionality of an object.

Accessor

A method (getter) that returns the value of an encapsulated (usually private) data member.

Mutator

A method (setter) that modifies the value of an encapsulated (usually private) data member.

Constructor

A special method with the same name as its class used to initialize new objects (instantiation).

Signature

The combination of a method's name and its parameter list, which defines how the method is called.

Return value

The value a method sends back to its caller after execution.

Private

An access modifier that restricts variables, methods, and constructors to be accessible only within the same class.

Protected

An access modifier that allows variables, methods, and constructors to be accessed within the same package or by subclasses.

Public

An access modifier that allows variables, methods, and constructors to be accessed from any other class.

Extends

A keyword used in Java to create a subclass, indicating that it inherits properties and methods from a superclass.

Static

A keyword indicating that a field, method, or inner class belongs to the class itself rather than any instance of the class.

Primitive data types

The basic types in Java (int, long, double, char, boolean, etc.) used to store simple values.

Selection statements

Control structures (if, if-else, switch) that enable decision making by executing different code blocks based on conditions.

Repetition statements

Looping constructs (for, while, do-while) that execute a block of code multiple times.

Static arrays

Fixed-size arrays that hold elements of the same data type and do not change size after declaration.

Internationalisation

The design and development of software to support multiple languages and cultural norms, often via Unicode, resource bundles, and locale support.

Ethical and moral obligations of programmers

The responsibility to write safe, reliable, and socially responsible code by ensuring quality, respecting intellectual property, protecting data privacy, and considering the societal impact of technology.

Recursion

A programming technique where a procedure or function calls itself with a termination condition, processing successive iterations until a base case is reached.

Recursive Algorithms

Algorithms that use recursion for clarity and elegant problem-solving (e.g., tree traversal, factorial calculation) but may use more memory and risk stack overflow.

Factorial (Recursive)

A recursive method for computing factorial defined as n! = n * (n–1)! with a base case of 1! = 1.

Trace Recursive Algorithms

A technique using a stack model to follow and debug recursive calls, showing how each call is stored and then resolved from the base case upward.

Object Reference

A variable that stores the memory address of an object; it points to the actual object in RAM rather than containing the object itself.

Abstract Data Type (ADT)

A high-level description of a data structure defined by its behavior (operations) without specifying its implementation details.

Lists (ADT)

A collection of elements with defined operations (e.g., add, remove, search) that can be implemented as arrays or linked lists.

JETS

The Java Examination Tool Subset, a simplified version of Java's standard library used in IB exams with essential collection methods.

Stack

An ADT based on Last-In, First-Out (LIFO) principles, supporting operations like push, pop, peek, and isEmpty.

Queue

An ADT based on First-In, First-Out (FIFO) principles, with core operations including enqueue, dequeue, peek, and isEmpty.

Binary Tree

A hierarchical data structure where each node has at most two children; used in searching, sorting, and representing hierarchical data.

Code Conventions

Standardized rules for naming, formatting, and organizing code (e.g., class names, method names, indentations) that improve readability and maintainability.