UNIT 1

I. OOPS Concepts and Java Programming Fundamentals

1. Write the Difference Between Procedural Oriented

Programming (POP) & Object Oriented Programming (OOP)

The development of object-oriented programming was driven by the

limitations encountered when building large, complex systems using older
procedural paradigms. The core difference between Procedural Oriented
Programming (POP) and Object-Oriented Programming (OOP) lies in their
foundational organizational structure and approach to data handling.

Procedural Oriented Programming (POP)

POP, typical of languages like C, follows a top-down design approach.

Programs are logically broken down into a series of smaller, sequential
procedures or functions. The emphasis is placed on the step-wise
execution of these functions—that is, how the task is accomplished. In this
paradigm, data is often separated from the functions that operate on it.
Consequently, POP frequently relies on global data that is shared across
many independent functions. This shared data model presents challenges
for security and scalability, as any function can potentially access and
modify the data, leading to increased risk of unintended side effects.

Object-Oriented Programming (OOP)

OOP, which Java embodies, uses a bottom-up design approach, focusing

the program structure around real-world entities called objects. An object
bundles data (attributes) together with the methods (behaviors) that are
authorized to manipulate that data. This binding is known as
encapsulation. Objects communicate by invoking methods on one
another, a mechanism referred to as message passing. This methodology
significantly improves code reuse, system maintenance, and scalability for
complex applications.

The fundamental structural divergence between these paradigms dictates

their respective strengths and weaknesses, especially concerning security
and code reuse. OOP uses encapsulation and access specifiers (such
as private) to hide internal data from external modification. This structural
control is what leads to high security, as it prevents unauthorized access.
This controlled management of internal state in turn promotes high
modularity, ensuring that objects function reliably irrespective of external
code changes, thereby enabling superior code reuse through concepts like
Inheritance and well-defined interfaces.

Table 1: Comparison of Procedural Oriented Programming (POP) and

Object-Oriented Programming (OOP)
 Parameter Procedural Oriented Object-Oriented
Programming (POP) Programming (OOP)

Focus Functions/Procedures (The steps Data/Objects (The entities

to achieve the task). that encapsulate data and
behavior).

Design Top-down (breaking down the Bottom-up (building objects

Approach primary task). first, then composing the
application).

Data Hiding Not supported. Relies on global Supported via Encapsulation

data that is easily accessible. and access specifiers
(private, protected).

Security Low. Global data sharing High. Data hiding prevents

increases risks. unauthorized external access.

Modularity Low. Functions are independent High. Code reuse is achieved

& and generally not reusable through Objects and
Reusability across contexts. Inheritance.

2. What is Java? What are the features of Java.

Java is a high-level, class-based, object-oriented programming language

developed by Sun Microsystems (now Oracle). It was designed to be
portable, reliable, and secure, enabling the creation of large-scale,
enterprise-level applications.

Key Features and Characteristics of Java

Java’s widespread adoption is attributable to a powerful set of features

designed to ensure robust, secure, and portable execution across diverse
computing environments.

1. Object-Oriented: Java enforces the OOP paradigm rigorously,

organizing all executable code within classes and objects. It
naturally supports the core OOP pillars: encapsulation, inheritance,
polymorphism, and abstraction.

2. Platform Independence: This is Java's signature feature,

summarized by the slogan "Write Once, Run Anywhere." Java source
code is compiled into an intermediate form known as bytecode.
 This bytecode is executed by the Java Virtual Machine (JVM), which
acts as an interpreter tailored for the specific operating system and
hardware. Since the bytecode itself is independent of the machine
architecture, the same compiled file can run without modification on
any platform hosting a compatible JVM.

3. Robustness: Java eliminates potentially dangerous programming

practices, such as the direct use of pointers, which often lead to
memory corruption in other languages. It enforces strong type
checking and includes a built-in mechanism for automatic memory
management called Garbage Collection.

4. Security: Java provides strong security through features

implemented within the JVM, including bytecode verification,
sandboxing, and the Security Manager. These mechanisms restrict
unauthorized access and protect the underlying system from
malicious or buggy code.

5. Multithreading: The language provides integrated support for

creating and managing multiple threads concurrently. This feature is
vital for developing high-performance applications that can handle
multiple tasks simultaneously, ensuring responsive user interfaces
and efficient resource utilization.

6. High Performance: Java achieves high execution speed by

employing a Just-In-Time (JIT) compiler within the JVM. The JIT
identifies frequently executed sections of bytecode ("hot spots") and
dynamically compiles them into optimized native machine code
during runtime, significantly improving performance beyond simple
interpretation.

7. Distributed Computing: Java simplifies network application

development through APIs and technologies like Remote Method
Invocation (RMI) and Java Database Connectivity (JDBC). This
infrastructure allows components of a program to be spread across
multiple machines on a network and communicate effectively.

3. What is Java Virtual Machine? Write its components.

The Java Virtual Machine (JVM) is an abstract machine defined by a

specification that provides the runtime environment for executing Java
bytecode. The JVM is the core component that enables Java's architectural
neutrality and portability by acting as a universal translator between the
compiled bytecode and the physical hardware.

Role of the JVM

The JVM’s primary role is to load, verify, and execute Java class files. It
manages the runtime memory necessary for the program and ensures the
execution environment is secure. The ability of the JVM to interpret
bytecode, regardless of the underlying operating system, is the
foundational technology behind Java's platform independence.

Detailed Components of the JVM

The JVM architecture is organized into three main subsystems:

1. Class Loader Subsystem The class loader is responsible for locating

and loading class files (.class) from the file system or network into
memory. This process involves three steps:

 Loading: Reads the binary data of the class file.

 Linking: The class is "wired up" with the rest of the program. This
phase includes Verification (checking the structural integrity of the
bytecode), Preparation (allocating memory for static variables and
initializing them to default values), and Resolution (replacing
symbolic references with direct memory references).

 Initialization: Executes any static initializers defined in the class

and assigns the actual values to static variables.

2. Runtime Data Areas (Memory) These memory areas are allocated

by the JVM when a program executes. They are crucial for storing program
data and execution state.

Table 2: Components of the JVM Runtime Data Areas

Componen Description Scope Failure Condition

t

Method Shared space for storing class Shared OutOfMemoryError

Area metadata, method definitions, by all
static variables, and the Run- threads
Time Constant Pool.

Heap Area Dynamic, shared memory Shared OutOfMemoryError (if

space where all objects and by all GC fails to reclaim
arrays are allocated. This area threads sufficient space).
is subject to automatic
memory management by the
Garbage Collector.
 Componen Description Scope Failure Condition
t

JVM Stack Private runtime stack created Private StackOverflowError

for each thread. Stores Frames, (Per (e.g., due to excessive
which hold local variables, Thread) recursion).
operand stacks, and method
invocation information.

PC Private register for each thread Private N/A

Register that stores the memory (Per
address of the next instruction Thread)
to be executed.

Native Private stack for each thread Private StackOverflowError

Method dedicated to executing native (Per
Stack methods (code written in Thread)
languages like C/C++
accessed via JNI).

The distinct allocation of memory areas is critical for runtime diagnostics.

For instance, if a program encounters excessive object creation without
sufficient memory reclamation, leading to an OutOfMemoryError during
instantiation, the issue is structurally isolated to the Heap area.
Conversely, if deep, uncontrolled recursion occurs, resulting in a system
crash, the failure can be traced to the thread’s dedicated Stack area
(StackOverflowError). This separation provides a clear architectural
structure for identifying and resolving memory-related faults.

3. Execution Engine The component responsible for executing the

bytecode loaded into memory.

 Interpreter: Executes bytecode instructions sequentially.

 JIT Compiler: Optimizes performance by translating frequently

used bytecode segments into native machine code.

 Garbage Collector (GC): An automatic process that runs

periodically to detect and deallocate memory occupied by objects in
the Heap that are no longer referenced by the running program.

4. Discuss about the Java Environment.

The Java Environment comprises the complete set of tools and libraries
necessary to compile, execute, and develop Java applications. It is defined
by a nested set of components: the Java Development Kit (JDK), the Java
Runtime Environment (JRE), and the Java Virtual Machine (JVM).

1. Java Virtual Machine (JVM): The base execution engine, as

detailed previously.

2. Java Runtime Environment (JRE): This is the minimum

requirement for executing a compiled Java program. It bundles the
JVM along with the core set of Java Class Libraries (API files) that
provide essential functionalities (e.g., input/output,
networking). End-users who only need to run Java applications
typically install the JRE.

3. Java Development Kit (JDK): This is the full development package

used by programmers. It includes the JRE, along with essential
development tools such as the Java Compiler (javac), debuggers,
and documentation generators.

This structured environment ensures standardization: developers create

code using the JDK, compile it into portable bytecode, and users run that
bytecode using the JRE/JVM, guaranteeing consistent behavior regardless
of the underlying hardware or operating system.

5. Explain the basic structure of Java Program

A Java program is fundamentally structured around classes, methods, and

statements, enforced by specific syntax rules. Every Java program must
contain at least one class definition, which acts as the encapsulation
boundary.

A minimal executable program requires a class definition and the

standardized entry point: the main method.

Java

// Optional: Package declaration (organizes classes)

package [Link];

// Optional: Import statements (brings in external libraries)

import [Link];

// Mandatory: Class Definition (The program container)

public class ProgramExample {

// Mandatory: Main Method (The JVM entry point)

public static void main(String args) {

// Statements: Instructions terminated by a semicolon

int value = 50;

// Block: Code inside braces {}

if (value > 40) {

[Link]("Condition Met.");

The language relies heavily on specific separators to define structure:

parentheses () are used for parameter lists and expression precedence;
braces {} define code blocks (classes, methods, loops, conditional
branches); the semicolon ; marks the end of a statement; and the
period . is used to separate package names or access members of an
object or class.

6. Explain various data types are available in Java.

Java's data types are categorized into two fundamental groups: primitive
types, which hold raw values, and non-primitive types, which hold
references to objects. Java is a strongly typed language, meaning every
variable must be declared with a specific type.

Primitive Data Types

These are the most basic data types and directly store their values in
memory (typically on the Stack). There are eight defined primitive types.

Category Type Size Description

(Bits)

Integers byte, short, int, l 8, 16, Used for whole numbers; int is the
ong 32, 64 default integer type.
 Category Type Size Description
(Bits)

Floating float, double 32, 64 Used for numbers with fractional

Point parts; double is the default.

Character char 16 Stores a single Unicode character.

Boolean boolean 1 Stores logical values: true or false.

Non-Primitive (Reference) Data Types

These types are more complex and are typically created by the
programmer or provided by the Java API. Instead of storing the actual data
value, non-primitive variables store a memory address, or reference,
pointing to the object’s location in the Heap.

Examples include Classes, Interfaces, and Arrays. Unlike primitive

types, non-primitive variables can be assigned the value null (meaning
they reference no object) and are used to invoke methods.

The method by which data is passed to methods—by value for primitives

versus by reference for objects—is determined by this classification.
Because non-primitive types rely on reference semantics, any modification
to the referenced object within a method affects the original object's state
in the Heap, reinforcing the need for careful object state management.

7. Write about Variables in Java.

A variable in Java is a named placeholder for a data value. Variables are

classified based on their declaration location (scope) and their lifetime,
which corresponds to where they are allocated within the JVM’s runtime
data areas.

1. Instance Variables (Non-Static Fields): These variables are

declared inside a class but outside any method or block. They
represent the state of a specific object instance. A unique copy of an
instance variable exists for every object created from the class, and
their memory is allocated within the Heap Area when an object is
instantiated.

2. Class Variables (Static Fields): Declared using

the static modifier, these variables belong to the class itself, not to
any specific object. Only a single copy of a class variable exists,
 regardless of how many objects are created. They are loaded into
the Method Area when the class is first loaded by the JVM.

3. Local Variables: These variables are declared within a method,

constructor, or code block. They are temporary, existing only while
that block of code is executing. Local variables reside in the thread’s
private Stack Area.

4. Parameters: Variables used in the signature of a method or

constructor to accept input values.

8. Explain about Constants/Literals in Java.

Constants and literals are both used to represent fixed, immutable values
in a Java program, but they differ in how they are represented and named
within the source code.

Literals

A literal is a raw, explicit value written directly into the source code
without an identifier or name. Literals are used to specify the initial value
for variables, or as operands in expressions.

Examples of literals include:

 100 (Integer literal)

 3.14 (Floating-point literal)

 'X' (Character literal)

 "Java Programming" (String literal)

 true or false (Boolean literals).

Constants

A constant is a named variable that is restricted from being modified after

its initial value assignment. In Java, the primary mechanism for defining a
constant value is the keyword final. A variable declared as final must be
initialized only once, either at the time of declaration or within a
constructor.

To define a true class-level constant—a single, globally accessible, and

unmodifiable value—the variable must be declared with
both static and final modifiers. A variable declared merely
as final without static is still unmodifiable, but a new, separate copy of
that unmodifiable variable is created for every object instance, which
undermines the objective of having a single, shared constant. Using static
final ensures that the value is a compile-time constant, initialized only
once when the class is loaded into the Method Area, promoting efficiency
and ensuring singular reference across the application.

9. Explain the various types of operators used in Java.

Operators are special symbols that perform specific operations on

operands (variables or values). Java supports a diverse set of operators
categorized by their function:

Operator Purpose Examples

Type

Arithmeti Used for + (Addition), - (Subtraction), * (Multiplication), / (Divisi

c mathematic on), % (Modulo).
al
operations.

Relationa Compare == (Equal to), != (Not equal to), >, <, >=, <=.
l two values
and return a
boolean
result.

Logical Combine && (Logical AND), `

boolean
expressions
to produce
a single
boolean
result.

Assignme Assign =, +=, -=, *=, /=, %=.

nt values to
variables,
often
combining
assignment
with
arithmetic.
 Operator Purpose Examples
Type

Unary Operate on ++ (Increment), -- (Decrement), - (Unary

a single minus), ! (Logical complement).
operand.

Bitwise Perform &, `

manipulatio
n directly
on the
binary
representati
ons (bits) of
integer
operands.

Ternary A shorthand condition? expression_if_true : expression_if_false.

(Conditio operator for
nal) simple if-
else logic.

When multiple operators are used in a single expression, the order of

evaluation is determined by operator precedence. Arithmetic
operations are prioritized highest, followed by comparison operators, and
finally by logical operators (&&, ||). Programmers must use
parentheses () explicitly to override this default order and ensure the
expression evaluates as intended.

10. What is Decision making statements? What are types of If

statements supported by Java? Explain with example.

Decision making statements (or conditional flow statements) enable a

program to execute a particular block of code only if a specified boolean
condition is satisfied. They are essential for controlling the logic flow of an
application.

Types of if Statements Supported by Java

1. Simple if Statement: Executes a block of code if the boolean

condition evaluates to true. If the condition is false, the program
skips the block and continues execution immediately after
the if structure. The associated else block is optional.
 2. if-else Statement: Provides a two-way decision path. If the
condition is true, the if block is executed; otherwise, the else block is
executed.

3. if-else-if Ladder: Used when multiple, mutually exclusive conditions

must be checked sequentially. The blocks are evaluated from top to
bottom, and only the code associated with the first true condition is
executed.

4. Nested if-else Statement: This structure involves placing one or

more if or if-else statements inside the body of an
outer if or else statement. This is necessary when the evaluation of
a secondary condition logically depends on the fulfillment of a
primary condition.

Example of Nested if-else: The example below checks if a number is

positive, and if so, performs a secondary check to determine if it is even
or odd.

Java

public class NestedExample {

public static void main(String args) {

int x = 12;

if (x > 0) { // Outer condition: Is x positive?

if (x % 2 == 0) { // Nested condition: Is x even?

[Link]("Positive and Even");

} else {

[Link]("Positive and Odd");

} else {

[Link]("Zero or Negative");

11. Define Loop? What are the looping Constructs supported by

Java? Explain with example.
A loop is a programming construct that facilitates the repeated execution
of a block of code until a specified condition governing the repetition
evaluates to false. Loops automate repetitive tasks and are essential for
iterative processing of data.

Looping Constructs in Java

Java supports three primary loop constructs, plus an enhanced version for
collections traversal:

1. for Loop: The most common loop construct, typically used when the
number of iterations is known or easily determined. It combines
initialization, condition checking, and update steps into a concise
header.

2. while Loop: An entry-controlled loop where the condition is

checked before executing the body. The loop continues as long as
the condition remains true.

3. do-while Loop: An exit-controlled loop where the body executes at

least once before the condition is checked (detailed further in
Section 13).

4. Enhanced for Loop (For-each): Designed to simplify iteration over

arrays and collections, focusing on accessing elements sequentially
rather than managing indices.

Example: for Loop

Java

for (int i = 0; i < 3; i++) {

[Link]("Loop iteration " + i);

// Output: Loop iteration 0, 1, 2

12. Discuss in detail Jumps in Loops. (OR) Discuss about Continue

and Break Statements with example.

Jump statements are control flow modifiers that disrupt the normal,
sequential execution order within a loop or method.
The break and continue statements are specifically designed to manage
flow within iterative structures.

The break Statement

The break statement causes the program to immediately and
unconditionally exit the entire loop structure (for, while, or do-while)
or switch block that contains it.

 Impact: Execution jumps immediately to the statement following

the terminated structure.

 Use Case: The statement is typically used when the program finds
a required element in a search or encounters a state that
necessitates abandoning all remaining iterations.

Example of break:

Java

for (int i = 1; i <= 10; i++) {

if (i == 5) {

break; // Exit the loop entirely

[Link](i);

// Output: 1, 2, 3, 4. The loop stops before processing 5.

The continue Statement

The continue statement skips the remaining statements in the current

iteration of the loop and forces the control flow to jump immediately to the
loop's condition check (or update step for a for loop), thereby starting the
next iteration.

 Impact: Only the code subsequent to the continue statement within

the current loop body is bypassed. The loop itself remains active
and continues its execution sequence.

 Use Case: Ideal for filtering, where certain conditions must be

ignored or skipped while the overall iteration process continues.

Example of continue:

Java

for (int i = 1; i <= 10; i++) {

if (i % 2!= 0) {

continue; // Skip odd numbers

}
 [Link]("Even: " + i);

// Output: Even: 2, Even: 4,..., Even: 10. Odd numbers are skipped.

The difference between these two jump statements lies in the level of
control they exert. The break command provides coarse control,
mandating the termination of the entire looping structure. Conversely,
the continue command offers finer control, allowing the program to skip
only a single, specified cycle and preserve the execution of subsequent
iterations.

13. Distinguish between Do..While and While Loop?

Both while and do-while loops are used for iteration based on a condition,
but they are distinguished by the timing of the condition check.

Table 3: Distinction between While Loop and Do-While Loop

Feature While Loop Do-While Loop

Control Entry-Controlled loop. Exit-Controlled loop.

Type

Condition Checked before the execution Checked after the execution of

Check of the loop body. the loop body.

Execution Executes zero or more times. Executes at least once,

Guarantee If the condition is false initially, regardless of whether the initial
the body is skipped. condition is true or false.

Syntax while (condition) { body } do { body } while (condition);

Example Iterating over an array or file Prompting user input or

Use where we must first ensure data displaying a menu, where the
exists. action must happen at least
once.

The mandatory execution of the do-while loop body prior to condition

evaluation is the critical difference. For instance, if a variable x is
initialized to 10 and the condition is x < 5, a while loop would never run,
but a do-while loop would execute its body once before evaluating the
condition (10 < 5) and exiting.
UNIT-2

Arrays, Classes, Objects, & Inheritance Implementation

14. What is an Array? Explain Creation of an One-dimensional

Array.

Definition of an Array

An array in Java is a data structure used to store a fixed-size, contiguous

collection of elements of the same data type. Arrays are object types in
Java, meaning the array structure itself is allocated dynamically on the
Heap.

Key characteristics include:

 1. Homogeneous Data: An array can only store elements belonging
to its declared type (e.g., int for integers).

2. Fixed Length: The size (number of elements) is determined at

instantiation and cannot be altered during runtime.

3. Indexed Access: Elements are accessed rapidly using a zero-based

index (subscript), with access time being constant, denoted
as O(1).

Creation of an One-Dimensional Array

Creating an array typically involves three steps:

1. Declaration: The array variable is declared, specifying the element

type and indicating that it is an array using brackets ``.

Java

int numbers;

2. Instantiation (Memory Allocation): The new operator is used to

allocate the necessary memory block in the Heap, and the size of the
array is specified.

Java

numbers = new int; // Allocates memory for 5 integers.

Once instantiated, Java automatically initializes the array elements to

default values (e.g., 0 for integers, null for objects).

3. Initialization (Assigning Values): Values are placed into the specific

indices.

Java

numbers = 10;

numbers = 50;

Alternatively, an array can be declared, instantiated, and initialized

simultaneously using an array literal:

Java

String fruits = {"apple", "banana", "cat"}; [25]

15. Discuss about the Command Line Arguments.

Command Line Arguments (CLAs) are values passed to a Java program

during its execution directly from the command prompt or terminal. They
allow external data or configuration parameters to be supplied to the
application without requiring interactive input.

Handling in Java

The Java main method is defined to accept an array of strings as its

parameter:

Java

public static void main(String args)

When a program is executed (e.g., java MyProgram arg1 arg2), the JVM
automatically collects the space-separated arguments (arg1, arg2, etc.)
and stores them sequentially in the args array.

Data Type Restriction and Conversion: A crucial aspect of CLAs is that

all arguments, regardless of whether they appear numeric or
alphanumeric, are stored as elements of the String args array. If the
program requires these arguments to be treated as primitive numeric
types (like integers or doubles), explicit type conversion must be
performed by the developer using wrapper class methods, such
as [Link]() or [Link](). Failure to convert a non-
numeric argument intended for a numeric variable will result in a
runtime NumberFormatException.

CLAs are often used in professional environments to define operational

parameters, such as database connection paths or configuration file
locations, that control the program's behavior upon launch.

16. Briefly explain about Strings and String Class Methods in Java.

In Java, a string is a sequence of characters, implemented through

the [Link] class. The String class is fundamental to the language
and exhibits critical properties related to memory management and
thread safety.

String Characteristics

1. Immutability: String objects are fundamentally immutable. Once a

String object is created in memory, its value cannot be
changed. Operations that appear to modify a string (e.g.,
concatenation) actually result in the creation of a new String object,
leaving the original object unchanged. This immutability is key for
security and efficiency, particularly in concurrent environments and
when utilizing the String Constant Pool for memory optimization.

2. Interfaces Implemented: The String class implements

the CharSequence interface, allowing access to individual
 characters (e.g., via charAt()), and
the Comparable<String> interface, enabling lexicographical
comparison.

Essential String Class Methods

The String class provides rich methods for querying, comparing, and
manipulating strings :

Method Description

length() Returns the number of characters in the string.

charAt(int index) Returns the character at the specified index.

concat(String str) Concatenates the given string to the end of the current
string.

substring(int Extracts a new string containing a portion of the original

beginIndex, int string.
endIndex)

trim() or strip() Returns a new string with leading and trailing whitespace
removed.

compareTo(String Compares two strings lexicographically. Returns 0 if equal,

anotherString) a negative value if the current string comes before the
argument, and a positive value otherwise.

indexOf(String s) Returns the index of the first occurrence of the specified

substring.

valueOf(dataType) A static method that converts various data types

(primitives or objects) into their string representation.

17. What is a Class? Explain how to define a class in Java.

Definition of a Class

A class is the core concept of object-oriented programming. It acts as a

non-physical blueprint or template from which specific objects (instances)
are created. The class defines the structure and behavior common to all
objects derived from it.

A class definition serves to encapsulate two primary components:

1. State (Fields/Variables): Data members that define the attributes

of an object.

2. Behavior (Methods): Functions that define the actions an object

can perform or the ways in which its data can be accessed or
modified.

Defining a Class in Java

A class is defined using the keyword class, followed by the chosen class
name. The body of the class is enclosed within curly braces {}.

Java

public class Vehicle {

// 1. Fields (State)

private String color; // Instance variable, restricted access via 'private'

private int speed;

// 2. Constructor (Used for initial object creation)

public Vehicle(String c) {

[Link] = c;

// 3. Methods (Behavior)

public void accelerate(int change) {

speed += change;

// Example of a data access method (Getter)

public String getColor() {

return color;
 }

The use of access modifiers, such as private, is critical in class definition.

Declaring fields as private ensures that they can only be accessed by
methods within their own class, effectively implementing data hiding and
encapsulation.

18. How do you create an Object and also explain how class
members are accessed?

An object is an instantiation of a class—a concrete entity created at

runtime that holds specific values for the data members defined in the
class blueprint.

Creating an Object

The standard method for creating an object involves three conceptual

steps, usually executed in a single line of code using the new operator :

1. Declaration: Declaring a variable of the class type (Vehicle myCar).

2. Instantiation: The new operator is executed, dynamically

allocating memory in the Heap for the new object.

3. Initialization: The class constructor (Vehicle("Red")) is called,

which assigns initial values to the instance variables.

Example:

Java

// Creates an object named 'myCar' from the Vehicle class

Vehicle myCar = new Vehicle("Red");

While the new keyword is used for nearly all object creation, alternative,
less common methods exist, such as using reflection
([Link]().newInstance()), cloning, or deserialization.

Accessing Class Members

Access to the data and methods (members) defined within a class is

controlled by the member type (instance or static) and the access
modifiers.

1. Accessing Instance Members: Instance variables and methods

are unique to each object and must be accessed through the
object’s reference variable using the dot operator (.).

Java
// Accessing (calling) an instance method:

[Link](20);

// Accessing an instance variable (if allowed by access modifiers):

String color = [Link]();

2. Accessing Static (Class) Members: Static variables and methods

belong to the class as a whole, not to a specific object. They are
accessed directly using the class name, although they can
technically be accessed via an object reference.

Java

// Assuming Vehicle had a static constant MAX_SPEED

// [Link](Vehicle.MAX_SPEED);

The dot operator is the fundamental mechanism through which the

program resolves the name of the variable (which holds a reference on the
Stack) to the actual data structure in the Heap, thereby allowing the
invocation of methods or manipulation of instance data belonging to that
specific object.