Object Oriented Programming using Java (Unit 1 & 2 Review)

A collection of vocabulary flashcards covering basic Java history, the 12 Buzzwords, data types, variables, and core Object-Oriented Programming (OOP) concepts from Units 1 and 2.

Green Team

The small team of Sun engineers, including James Gosling, who initiated the Java language project in June 1991.

James Gosling

The person known as the father of Java who developed the language at Sun Microsystems in 1995.

Greentalk

The initial name given to the Java language by James Gosling, which used the file extension .gt.

Oak

The name Java was called before 1995, chosen as a symbol of strength and the national tree of many countries.

Bytecode

The platform-independent result of Java compilation; it is a highly optimized set of instructions designed to be executed by the Java run-time system.

Platform Independent

A Java feature described as "Write Once, Run Anywhere" (WORA), meaning code compiled into bytecode can run on any software-based platform.

Classloader

A part of the Java Runtime Environment (JRE) used to load Java classes into the Java Virtual Machine dynamically, enhancing security by separating local classes from network sources.

Bytecode Verifier

A security feature that checks code fragments for illegal code that could violate access rights to objects.

Security Manager

A component that determines what resources a class can access, such as reading or writing to the local disk.

Robust

A buzzword describing Java's strength, achieved through strong memory management, lack of pointers, and exception handling mechanisms.

Architecture-neutral

A feature where there are no implementation-dependent details; for example, the size of primitive types like int is fixed at $4\,bytes$ for both $32$ and $64$-bit architectures.

Multi-threaded

A feature that allows the writing of programs that deal with many tasks at once by defining multiple threads that share a common memory area.

Programming Paradigm

The methodology for writing program codes; Java is exclusively object-oriented, focusing on objects that make up the system.

Abstraction

The process of hiding implementation details and showing only essential functionality to the user, achieved via abstract classes or interfaces.

Encapsulation

The process of wrapping code and data together into a single unit (like a capsule) to protect it from system-wide access.

Inheritance

The process of creating a new class from an existing class, establishing an "is-a" relationship using the extends keyword.

Polymorphism

The ability to perform one task in different ways, implemented in Java through method overloading and method overriding.

Method Overloading

A type of compile-time polymorphism where multiple methods in a class have the same name but different parameters (number or type).

Method Overriding

A type of runtime polymorphism where a subclass provides a specific implementation of a method already declared in its parent class.

Byte Data Type

An $8$-bit signed two's complement integer with a range from $-128$ to $127$.

Int Data Type

A $32$-bit signed two's complement integer, which is the default for integral values.

Char Data Type

A $16$-bit Unicode character with a minimum value of '\u0000' and a maximum value of '\uffff'.

Local Variable

A variable declared inside the body of a method that can only be used within that specific method.

Instance Variable

A variable declared inside the class but outside any method; it is instance-specific and created when an object is instantiated.

Static Variable

A variable declared with the static keyword, sharing a single copy among all instances of a class and allocated memory only once during class loading.

the "this" keyword

A reference variable in Java that refers to the current object of a class, often used to resolve ambiguity between instance variables and local parameters.

Instance Variable Hiding

A state where a local variable in a method has the same name as an instance variable, causing use of the name to refer to the local one unless the this keyword is used.

Garbage Collection

The automatic process performed by the JVM to reclaim runtime unused memory by destroying unreferenced objects.

finalize() method

A method of the Object class called by the Garbage Collector before an object is destroyed to perform cleanup activities.

Private Access Modifier

An access level that restricts visibility only to members within the same class; the most restrictive modifier.

Default Access Modifier

The access level applied when no modifier is specified; it allows access only within the same package.

Protected Access Modifier

An access level that allows visibility within the same package and by subclasses in different packages.

Public Access Modifier

The widest access level, making members accessible from anywhere within the classes, packages, or outside them.

the "super" keyword

A reference variable used to refer to immediate parent class objects, invoke parent methods, or call parent constructors.

Dynamic Method Dispatch

The process by which a call to an overridden method is resolved at runtime rather than at compile-time based on the object type.

Abstract Class

A class declared with the abstract keyword that cannot be instantiated and may contain abstract methods without bodies.

Final Keyword

A keyword used to denote constants; when applied to variables they cannot be changed, to methods they cannot be overridden, and to classes they cannot be inherited.