Object-Oriented Programming II

Comprehensive vocabulary terms and definitions covering Object-Oriented Programming (OOP) principles, Java syntax, variables, operators, methods, and modularization according to the lecture notes.

Object-Oriented Programming (OOP)

A programming paradigm that organizes software design around objects representing real-world entities rather than methods or logic.

Object

An instance of a class that contains data (attributes) and methods defining its behavior.

Class

A blueprint or template for creating objects that defines their structure and behavior.

Attributes

Variables belonging to a class or object that hold its state or data.

Methods

Functions defined inside a class that describe the behaviors of an object.

Encapsulation

The concept of bundling data and methods into a single unit, typically a class, and restricting access to internal details.

Inheritance

A principle that allows a child class to acquire properties and methods of a parent class to promote code reusability.

Polymorphism

A principle allowing objects to take on multiple forms and enabling the same operation to behave differently depending on the object.

Abstraction

The process of hiding implementation details and exposing only the essential features of an object, typically using abstract classes and interfaces.

Modularity

An advantage of OOP where code is organized into classes, making it easier to manage and modify.

Reusability

The ability to use existing code, often through inheritance, to create new classes.

Scalability

The characteristic of OOP that makes it easier to scale large projects due to its modular nature.

Maintainability

The ease of updating or debugging code without affecting other parts, promoted by encapsulation and abstraction.

Case-sensitive

A characterization of Java where names like "MyClass" and "myclass" have different meanings.

println()

A Java method that outputs values or prints text and inserts a new line at the end.

print()

A Java method similar to println() that does not insert a new line at the end of the output.

Single-line comments

Java comments starting with "//" used to explain code or prevent execution during testing.

Multi-line comments

Java comments starting with "/" and ending with "/" for longer descriptions.

Int

A variable type that stores integers (whole numbers) without decimals, such as $123$ or $-123$.

Float

A variable type that stores floating point numbers with decimals, such as $19.99$ or $-19.99$.

Char

A variable type that stores single characters, such as 'a' or 'B', surrounded by single quotes.

String

A variable type that stores text, such as "Hello World", surrounded by double quotes.

Bool

A variable type that stores values with two states: true or false.

Identifiers

Unique names used to identify variables, which can contain letters, digits, underscores, and dollar signs.

Modulus

An arithmetic operator ($$) that returns the division remainder.

Comparison Operators

Operators used to compare two values or variables, such as equal to ($==$) or not equal ($!=$).

Logical and

A logical operator (&&) that returns true if both statements are true.

length() method

A string method that returns the number of characters in a string.

indexOf() method

A string method that returns the position of the first occurrence of a specified text in a string.

Concatenation

The process of combining two strings using the $+$ operator or the concat() method.

Math.sqrt(x)

A Java method used to return the square root of a number.

Math.random()

A Java method that returns a random number between $0.0$ (inclusive) and $1.0$ (exclusive).

Math.abs(x)

A Java method that returns the absolute (positive) value of the provided number.

Scanner class

A class found in the java.util package used to get user input.

System.in

A predefined input stream used to read input from the keyboard.

nextLine()

A Scanner method used to read String input from the user.

nextInt()

A Scanner method used to read internal whole number (int) values from the user.

Break

A statement used to jump out of a loop or switch block.

Continue

A statement that breaks one iteration in a loop and continues with the next iteration.

Array

A variable type used to store multiple values in a single container using square brackets and curly braces.

Multidimensional Array

An array of arrays, useful for storing data in a tabular form with rows and columns.

Scope

Determines where a method or variable can be accessed within a program.

Static

A keyword indicating that a method or variable belongs to the class itself rather than a specific instance.

Void

A keyword indicating that a method performs an action but does not return any value.

Parameters

Variables specified after the method name inside parentheses that act as placeholders for information.

Arguments

Information passed into methods as values during a method call.

Method Overloading

When multiple methods have the same name but different parameters.

Subclass (child)

A class that inherits from another class using the extends keyword.

Superclass (parent)

The class being inherited from in an inheritance relationship.

Access Modifiers

Keywords that control the visibility of classes, methods, and variables (public, protected, default, private).

Public modifier

An access modifier where the member is accessible from any other class.

Private modifier

An access modifier where the member is accessible only within its own class.

Protected modifier

An access modifier where the member is accessible within its own package and by subclasses.

Final

A non-access modifier used to declare constants and prevent method overriding or inheritance.

Constructors

Special methods used to initialize objects' data members that are automatically called when an object is created.

Abstract class

A restricted class that cannot be used to create objects and must be inherited to be accessed.

Interface

A collection of abstract methods and constant variables used to define a contract of behavior for classes.

Modularization

The process of dividing a software system into distinct, manageable units called modules.

High Cohesion

A principle where each module performs a single, well-defined task.

Low Coupling

A principle where modules have minimal dependencies on each other to reduce the ripple effect of changes.

Separation of Concerns

A principle where different functionalities are handled in different modules to promote clarity.