Revision Before ExamÂļ
ā§§. Interface = āĻŽā§āĻāύ āĻŦā§āϞā§āĻĒā§āϰāĻŋāύā§āĻ (āĻāĻžāĻāĻā§-āĻāϞāĻŽā§)Âļ
āĻāĻā§āĻāĻŋāύāĻŋā§āĻžāϰāϰāĻž āĻāĻāĻĻāĻŽ āĻļā§āϰā§āϤ⧠āĻā§āĻŦāĻŋāϞ āĻŦāĻž āĻāĻžāĻāĻā§ āĻāϏā§āĻž āύāĻāĻļāĻž āĻāϰāϞā§āύ: "āĻāĻžā§āĻŋāϰ āĻāĻžāϰāĻāĻž āĻāĻžāĻāĻž āĻĨāĻžāĻāĻŦā§, āĻāĻāĻāĻž āϏā§āĻāĻŋā§āĻžāϰāĻŋāĻ āĻĨāĻžāĻāĻŦā§, āĻŦā§āϰā§āĻ āĻĨāĻžāĻāĻŦā§āĨ¤"
- Static āĻŽā§āĻĨāĻĄā§āϰ āϞāĻāĻŋāĻ: āĻāĻ āĻāĻžāĻāĻā§-āĻāϞāĻŽā§ āύāĻāĻļāĻžāϰ āĻā§āϤāϰā§āĻ āĻāĻāĻāĻž āĻā§āϞā§āĻŦāĻžāϞ āϏā§āĻā§āϝāĻžāύā§āĻĄāĻžāϰā§āĻĄ āĻŦāĻž āύāĻŋā§āĻŽ āĻĢāĻŋāĻā§āϏāĻĄ āĻāϰ⧠āĻĻā§āĻā§āĻž āĻšāϞ⧠(āϝā§āĻŽāύ: "āϏāĻŦ āĻāĻžā§āĻŋ āĻāĻžāĻāĻžāϰ āĻāύā§āϝ āϰāĻžāĻŦāĻžāϰ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻāϰāĻŦā§"âāĻāĻāĻž āĻŦāĻĻāϞāĻžāύ⧠āϝāĻžāĻŦā§ āύāĻž)āĨ¤ āĻāĻāĻž āĻšāϞ⧠āĻāύā§āĻāĻžāϰāĻĢā§āϏā§āϰ static āĻŽā§āĻĨāĻĄ āĻŦāĻž āĻāύāϏā§āĻā§āϝāĻžāύā§āĻ āĻā§āϝāĻžāϰāĻŋā§ā§āĻŦāϞāĨ¤
⧍. Class = āĻĒā§āϰā§āĻā§āĻāĻžāĻāĻĒ (Prototype)Âļ
āύāĻāĻļāĻž āĻĻā§āĻā§ āĻĢā§āϝāĻžāĻā§āĻāϰāĻŋ āĻŦāĻž āϞā§āϝāĻžāĻŦā§ āĻĒā§āϰāĻĨāĻŽ āĻāĻāĻāĻž āĻā§āϏā§āĻ āĻŽāĻĄā§āϞ āĻŦāĻž āĻĒā§āϰā§āĻā§āĻāĻžāĻāĻĒ āϤā§āϰāĻŋ āĻāϰāĻž āĻšāϞā§āĨ¤ āĻāĻāĻžāύ⧠āĻāĻā§āĻāĻŋāύā§āϰ āĻā§āϤāϰā§āϰ āϤāĻžāϰ āĻā§āĻāĻžāĻŦā§ āĻā§ā§āĻž āϞāĻžāĻāĻŦā§, āĻŽā§āĻāĻžāϞ āĻŦāĻĄāĻŋ āĻā§āĻāĻžāĻŦā§ āĻĢāĻŋāĻā§āϏāĻĄ āĻšāĻŦā§ (āĻā§āĻĄā§āϰ āĻŦāĻĄāĻŋ āĻŦāĻž āϞāĻāĻŋāĻ) āϏāĻŦāĻāĻŋāĻā§ āϏāĻŽā§āĻĒā§āϰā§āĻŖ āϏā§āĻā§āϰāĻžāĻāĻāĻžāϰ āĻāϰāĻž āĻšāϞā§āĨ¤ āĻāĻāĻž āĻšāϞ⧠āĻāĻĒāύāĻžāϰ ClassāĨ¤ āĻĒā§āϰā§āĻā§āĻāĻžāĻāĻĒ āύāĻŋāĻā§ āϰāĻžāϏā§āϤāĻžā§ āĻāϞ⧠āύāĻž, āĻāĻŋāύā§āϤ⧠āĻāĻāĻž āĻāϏāϞ āĻāĻžā§āĻŋ āĻŦāĻžāύāĻžāύā§āϰ āĻāύā§āϝ āĻāĻāĻĻāĻŽ āϰā§āĻĄāĻŋ āϏā§āĻā§āϰāĻžāĻāĻāĻžāϰāĨ¤
ā§Š. Object = āϰāĻŋāϝāĻŧā§āϞ āĻ āĻŦāĻā§āĻā§āĻ (Real Object)Âļ
āĻāĻ āĻĒā§āϰā§āĻā§āĻāĻžāĻāĻĒ (Class) āϏāĻĢāϞāĻāĻžāĻŦā§ āĻāĻžāĻ āĻāϰāĻžāϰ āĻĒāϰ āĻĢā§āϝāĻžāĻā§āĻāϰāĻŋāϰ āĻ ā§āϝāĻžāϏā§āĻŽā§āĻŦāϞāĻŋ āϞāĻžāĻāύ āĻĨā§āĻā§ āϞāĻžāĻ āϞāĻžāĻ āĻāĻžā§āĻŋ āϤā§āϰāĻŋ āĻšā§ā§ āĻļā§āϰā§āĻŽā§ āĻāϞ⧠āĻāϏāϞā§āĨ¤ āϝā§āĻŽāύ āĻāĻĒāύāĻžāϰ āĻā§āύāĻž āϞāĻžāϞ āϰāĻā§āϰ āĻā§ā§āĻāĻž āĻāĻžā§āĻŋāĻāĻŋ, āϝā§āĻāĻžā§ āĻāĻĒāύāĻŋ āĻāĻžāĻŦāĻŋ āĻĻāĻŋā§ā§ āϏā§āĻāĻžāϰā§āĻ āĻĻāĻŋāĻā§āĻā§āύ āĻāĻŦāĻ āĻĄā§āϰāĻžāĻāĻ āĻāϰāĻā§āύāĨ¤ āĻāĻāĻŋāĻ āĻšāϞ⧠āĻāϏāϞ Object āĻŦāĻž āĻŽā§āĻŽā§āϰāĻŋāϤ⧠āĻāĻžā§āĻāĻž āύā§āĻā§āĻž āϰāĻŋā§āĻžāϞ āĻāϞāĻŋāĻŽā§āύā§āĻāĨ¤
āĻāĻ āύāĻāϰ⧠āĻāĻĒāύāĻžāϰ āϤā§āϰāĻŋ āĻāϰāĻž āĻŽā§āĻŽā§āϰāĻŋ āĻŽā§āϝāĻžāĻĒ:Âļ
| āĻāĻĒāύāĻžāϰ āĻĨāĻŋāĻāϰāĻŋ | āĻāĻžāĻāĻžāϰ āϰā§āĻĒ | āĻŦāĻžāϏā§āϤāĻŦ āĻāĻĻāĻžāĻšāϰāĻŖ (āĻāĻžā§āĻŋ) |
|---|---|---|
| āĻŽā§āĻāύ āĻŦā§āϞā§āĻĒā§āϰāĻŋāύā§āĻ | interface Vehicle | āĻāĻžāĻāĻā§āϰ āύāĻāĻļāĻž + āĻā§āϞā§āĻŦāĻžāϞ āϏā§āĻā§āϝāĻžāύā§āĻĄāĻžāϰā§āĻĄ |
| āĻĒā§āϰā§āĻā§āĻāĻžāĻāĻĒ | class ToyotaCar | āĻā§āϏā§āĻ āĻŽāĻĄā§āϞ (āϏāĻŦ āĻŽā§āĻĨāĻĄā§āϰ āĻāϏāϞ āĻā§āĻĄ āϰā§āĻĄāĻŋ) |
| āϰāĻŋā§āĻžāϞ āĻ āĻŦāĻā§āĻā§āĻ | new ToyotaCar() | āĻļā§āϰā§āĻŽ āĻĨā§āĻā§ āĻā§āύāĻž āĻāĻĒāύāĻžāϰ āύāĻŋāĻā§āϰ āĻāĻžā§āĻŋāĻāĻŋ |
WHAT IS JRE
Java Runtime Environment (JRE)Âļ
Definition:
Java Runtime Environment (JRE) is a software layer or package that provides the minimum requirements for executing or running a Java application on a computer. It combines the Java Virtual Machine (JVM) with core class libraries and other supporting components.
Key Functions:
- Code Execution: It loads, verifies, and executes Java bytecode on the host machine.
- Environment Provisioning: It acts as an interface between the Java application and the underlying operating system.
- Resource Management: It allocates the necessary memory and system resources required for the program to run smoothly.
Core Components:
JRE is primarily composed of two elements:
- Java Virtual Machine (JVM): The heart of JRE. It interprets the Java bytecode and converts it into machine-specific code that the computer's CPU can understand.
- Core Class Libraries: A collection of pre-written, built-in Java classes and libraries (e.g., java.lang, java.util) that programs need to run.
The JRE Equation:
JRE = JVM + Core Class Libraries (excluding development tools)
Difference between JRE and JDK:
- JRE (Java Runtime Environment): Used only to run Java applications. It is meant for end-users.
- JDK (Java Development Kit): Used to develop (write and compile) Java applications. It includes JRE along with development tools like a compiler (javac) and debugger.
What do you understand by JVM? Briefly explain the function of JVM
Java Virtual Machine (JVM)Âļ
Definition:
Java Virtual Machine (JVM) is an abstract (āĻāĻžāϞā§āĻĒāύāĻŋāĻ/āĻŦāĻŋāĻŽā§āϰā§āϤ), software-based engine (āϝāύā§āϤā§āϰāĻā§āĻļāϞ) that acts as a runtime environment for executing (āϏāĻŽā§āĻĒāĻžāĻĻāύ āĻāϰāĻž) Java bytecode. It is the heart (āĻŽā§āϞ āĻā§āύā§āĻĻā§āϰ) of the Java platform and is responsible (āĻĻāĻžā§ā§/āĻŽā§āϞ āĻā§āĻŽāĻŋāĻāĻž āϰāĻžāĻā§) for making Java a "Write Once, Run Anywhere" (WORA) language, as it converts (āϰā§āĻĒāĻžāύā§āϤāϰ āĻāϰā§) platform-independent (āĻ
āĻĒāĻžāϰā§āĻāĻŋāĻ āϏāĻŋāϏā§āĻā§āĻŽā§āϰ āĻāĻĒāϰ āύāĻŋāϰā§āĻāϰāĻļā§āϞ āύ⧠āĻāĻŽāύ) bytecode into machine-specific (āύāĻŋāϰā§āĻĻāĻŋāώā§āĻ āĻāĻŽā§āĻĒāĻŋāĻāĻāĻžāϰā§āϰ āĻāĻĒāϝā§āĻā§) code.
Key Functions of JVMÂļ
The JVM performs four primary (āĻĒā§āϰāϧāĻžāύ/āĻŽā§āϞāĻŋāĻ) tasks during the lifecycle (āĻā§āĻŦāύāĻāĻā§āϰ) of a Java program:
- Class Loading: The Class Loader subsystem (āĻāĻĒ-āĻŦā§āϝāĻŦāϏā§āĻĨāĻž) loads the compiled (āĻ āύā§āĻĻāĻŋāϤ/āϏāĻāĻāϞāĻŋāϤ) .class files (bytecode) into the computer's memory (āϏā§āĻŽā§āϤāĻŋāĻļāĻā§āϤāĻŋ/āϰâā§āϝāĻžāĻŽ).
- Bytecode Verification: The Bytecode Verifier checks the code for security violations (āύāĻŋāϰāĻžāĻĒāϤā§āϤāĻž āϞāĻā§āĻāύ) and ensures (āύāĻŋāĻļā§āĻāĻŋāϤ āĻāϰā§) it does not corrupt (āύāώā§āĻ/āĻā§āώāϤāĻŋāĻā§āϰāϏā§āϤ āĻāϰāĻž) the system memory.
- Code Execution: The Execution Engine converts the bytecode into native (āϏā§āĻŦāĻĻā§āĻļā§/āĻāĻŽā§āĻĒāĻŋāĻāĻāĻžāϰā§āϰ āύāĻŋāĻāϏā§āĻŦ) machine code using an Interpreter (āĻĻā§āĻāĻžāώā§) and a JIT (Just-In-Time) Compiler, then runs it.
- Memory Management: JVM automatically (āϏā§āĻŦāϝāĻŧāĻāĻā§āϰāĻŋāϝāĻŧāĻāĻžāĻŦā§) manages memory allocation (āĻŦāϰāĻžāĻĻā§āĻĻāĻāϰāĻŖ) and reclaims (āĻĒā§āύāϰā§āĻĻā§āϧāĻžāϰ/āĻŽā§āĻā§āϤ āĻāϰāĻž) unused memory through a process (āĻĒā§āϰāĻā§āϰāĻŋāϝāĻŧāĻž) called Garbage Collection (GC) (āĻāĻŦāϰā§āĻāύāĻž āύāĻŋāώā§āĻāĻžāĻļāύ).
Java Types - Trick to remember
āĻŦāĻžāĻāϞāĻžā§ āĻāĻ ā§ŽāĻāĻŋ āĻĄā§āĻāĻž āĻāĻžāĻāĻĒ āϏāĻšāĻā§ āĻŽāύ⧠āϰāĻžāĻāĻžāϰ āĻāύā§āϝ āύāĻŋāĻā§āϰ āϝā§āĻā§āύ⧠āĻāĻāĻāĻŋ āĻā§āϰāĻŋāĻā§āϏ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻāϰāϤ⧠āĻĒāĻžāϰā§āύ:
āĻā§āϰāĻŋāĻ ā§§: āĻāĻāĻāĻŋ āϏāĻšāĻ āĻŦāĻžāĻāϞāĻž āĻŦāĻžāĻā§āϝ (āĻĒā§āϰāĻĨāĻŽ āĻ āĻā§āώāϰ āĻĻāĻŋā§ā§)Âļ
āύāĻŋāĻā§āϰ āĻŦāĻžāĻā§āϝāĻāĻŋ āĻŽāύ⧠āϰāĻžāĻā§āύ:
āĻŦāĻ āĻļāĻžāĻļā§ā§āĻŋ āĻāĻļāĻžāϰāĻž āϞā§āĻāĻŋā§ā§ āĻĢā§āϞā§āϝāĻžāĻ āĻĄā§āĻā§āϰā§āĻļāύ āĻāϰ⧠āĻŦāĻžāϰāĻŦāĻžāϰ
āĻāĻŦāĻžāϰ āĻĒā§āϰāĻĨāĻŽ āĻ āĻā§āώāϰāĻā§āϞ⧠āĻŽāĻŋāϞāĻŋā§ā§ āύāĻŋāύ:
- āĻŦāĻ \(\rightarrow\) byte
- āĻļāĻžāĻļā§ā§āĻŋ \(\rightarrow\) short
- āĻāĻļāĻžāϰāĻž \(\rightarrow\) int
- āϞā§āĻāĻŋā§ā§ \(\rightarrow\) long
- āĻĢā§āϞā§āϝāĻžāĻ \(\rightarrow\) float
- āĻĄā§āĻā§āϰā§āĻļāύ \(\rightarrow\) double
- āĻāϰ⧠\(\rightarrow\) char
- āĻŦāĻžāϰāĻŦāĻžāϰ \(\rightarrow\) boolean
āĻā§āϰāĻŋāĻ ā§¨: āĻāĻā§āϰ āĻŽāĻžāϧā§āϝāĻŽā§ āĻā§āϰā§āĻĒ āĻāϰ⧠āĻŽāύ⧠āϰāĻžāĻāĻž (āϏāĻŦāĻā§āϝāĻŧā§ āĻŦā§āĻā§āĻāĻžāύāĻŋāĻ āĻāĻĒāĻžā§)Âļ
āĻŽā§āĻāϏā§āĻĨ āύāĻž āĻāϰ⧠āĻŽāĻžāĻĨāĻžā§ āĻāĻāĻāĻž āĻŽā§āϝāĻžāĻĒ āϤā§āϰāĻŋ āĻāϰ⧠āύāĻŋāύāĨ¤ āĻāĻ ā§ŽāĻāĻŋ āĻāĻžāĻāĻĒāĻā§ āĻŽāĻžāϤā§āϰ ā§ŠāĻāĻŋ āĻāĻžāĻā§ āĻāĻžāĻ āĻāϰāĻž āϝāĻžā§:
- āϏāĻāĻā§āϝāĻžāϰ āĻĻāϞ (āĻĒā§āϰā§āĻŖāϏāĻāĻā§āϝāĻž): āϏāĻžāĻāĻ āĻā§āĻ āĻĨā§āĻā§ āĻŦā§ āĻā§āϰāĻŽāĻžāύā§āϏāĻžāϰ⧠āϏāĻžāĻāĻžāύā§:
- byte \(\rightarrow\) short \(\rightarrow\) int \(\rightarrow\) long
- āĻĻāĻļāĻŽāĻŋāĻā§āϰ āĻĻāϞ (āĻāĻā§āύāĻžāĻāĻļ): āĻā§āĻ āĻāĻŦāĻ āĻŦā§:
- float \(\rightarrow\) double
- āĻ āύā§āϝāĻžāύā§āϝ (āĻ āĻā§āώāϰ āĻ āϞāĻāĻŋāĻ):
- char (āĻ
āĻā§āώāϰā§āϰ āĻāύā§āϝ)
- boolean (āĻšāĻžāĻ/āύāĻž āĻŦāĻž true/false āĻāϰ āĻāύā§āϝ)
āĻāĻžāĻāĻžāϰ āĻāĻ ā§ŽāĻāĻŋ āĻĒā§āϰāĻŋāĻŽāĻŋāĻāĻŋāĻ āĻĄā§āĻāĻž āĻāĻžāĻāĻĒā§āϰ āϏāĻžāĻāĻ āĻŽāύ⧠āϰāĻžāĻāĻžāϰ āĻāĻāĻāĻŋ āĻĻāĻžāϰā§āĻŖ āĻāĻŦāĻ āϏāĻšāĻ āύāĻŋā§āĻŽ āĻāĻā§āĨ¤
āĻĒā§āϰāĻĨāĻŽā§ āĻŽā§āĻŽā§āϰāĻŋāϰ āĻšāĻŋāϏāĻžāĻŦāĻāĻž āĻŦā§āĻā§āύ: ā§§ Byte = ā§Ž bitsāĨ¤ āĻāĻžāĻāĻžā§ āϏāĻžāĻāĻāĻā§āϞ⧠āϏāĻŦāϏāĻŽā§ āĻĻā§āĻŦāĻŋāĻā§āĻŖ āĻŦāĻž āĻā§ā§āĻžā§ āĻā§ā§āĻžā§ āĻŦāĻžā§ā§āĨ¤
āύāĻŋāĻā§ āĻāĻĻā§āϰ āϏāĻžāĻāĻ āĻāĻŦāĻ āϏāĻšāĻā§ āĻŽāύ⧠āϰāĻžāĻāĻžāϰ āĻā§āϰāĻŋāĻ āĻĻā§āĻā§āĻž āĻšāϞā§:
ā§§. āĻĒā§āϰā§āĻŖāϏāĻāĻā§āϝāĻžāϰ āĻĻāϞ (Integers)Âļ
āĻāĻĻā§āϰ āϏāĻžāĻāĻ āĻā§āϰāĻŽāĻžāύā§āϏāĻžāϰ⧠⧧, ⧍, ā§Ē, ā§Ž āĻŦāĻžāĻāĻ (āĻĒā§āϰāϤāĻŋāĻŦāĻžāϰ⧠āĻĻā§āĻŦāĻŋāĻā§āĻŖ āĻšāĻā§āĻā§):
- byte â ā§§ Byte (ā§Ž bits) â āϏāĻŦāĻā§ā§ā§ āĻā§āĻāĨ¤
- short â ⧍ Bytes (ā§§ā§Ŧ bits) â āĻŦāĻžāĻāĻā§āϰ āĻĻā§āĻŦāĻŋāĻā§āĻŖāĨ¤
- int â ā§Ē Bytes (ā§Šā§¨ bits) â āĻļāϰā§āĻā§āϰ āĻĻā§āĻŦāĻŋāĻā§āĻŖ (āĻāĻāĻŋ āĻāĻžāĻāĻžā§ āϏāĻŦāĻā§ā§ā§ āĻŦā§āĻļāĻŋ āĻŦā§āϝāĻŦāĻšā§āϤ āĻšā§)āĨ¤
- long â ā§Ž Bytes (ā§Ŧā§Ē bits) â āĻāύā§āĻā§āϰ āĻĻā§āĻŦāĻŋāĻā§āĻŖ (āĻ āύā§āĻ āĻŦā§ āϏāĻāĻā§āϝāĻžāϰ āĻāύā§āϝ)āĨ¤
⧍. āĻĻāĻļāĻŽāĻŋāĻā§āϰ āĻĻāϞ (Floating-points)Âļ
āĻāĻĻā§āϰ āϏāĻžāĻāĻ āĻĒā§āϰā§āĻŖāϏāĻāĻā§āϝāĻžāϰ āĻŦā§ āĻĻā§āĻāĻŋ āĻāĻžāĻāĻĒā§āϰ āϏāĻŽāĻžāύ (ā§Ē āĻāĻŦāĻ ā§Ž āĻŦāĻžāĻāĻ):
- float â ā§Ē Bytes (ā§Šā§¨ bits) â int āĻāϰ āϏāĻŽāĻžāύ āϏāĻžāĻāĻāĨ¤
- double â ā§Ž Bytes (ā§Ŧā§Ē bits) â long āĻāϰ āϏāĻŽāĻžāύ āϏāĻžāĻāĻ (āĻĻāĻļāĻŽāĻŋāĻā§ āĻāĻāĻŋ āϏāĻŦāĻā§ā§ā§ āĻŦā§āĻļāĻŋ āĻŦā§āϝāĻŦāĻšā§āϤ āĻšā§)āĨ¤
ā§Š. āĻŦāĻžāĻāĻŋ āĻĻā§āĻāĻŋ āϏā§āĻĒā§āĻļāĻžāϞ āĻāĻžāĻāĻĒÂļ
- char â ⧍ Bytes (ā§§ā§Ŧ bits) â āĻāĻžāĻāĻž āĻāĻāύāĻŋāĻā§āĻĄ (Unicode) āϏāĻžāĻĒā§āϰā§āĻ āĻāϰā§, āϤāĻžāĻ āĻāĻāĻāĻŋ āĻ āĻā§āώāϰā§āϰ āĻāύā§āϝ ⧍ āĻŦāĻžāĻāĻ āύā§ā§āĨ¤ (āĻŽāύ⧠āϰāĻžāĻāĻžāϰ āĻā§āϰāĻŋāĻ: short āĻāϰ āϏāĻŽāĻžāύ)āĨ¤
- boolean â ā§§ bit (ā§§ āĻŦāĻžāĻāĻ āύā§, āĻŽāĻžāϤā§āϰ ā§§āĻāĻŋ āĻŦāĻŋāĻ) â āĻāĻžāϰāĻŖ āĻāϰ āĻāĻžāĻ āĻļā§āϧ⧠āĻšā§āϝāĻžāĻ (true) āĻ āĻĨāĻŦāĻž āύāĻž (false) āϏāĻāϰāĻā§āώāĻŖ āĻāϰāĻžāĨ¤ āĻāϰ āĻāύā§āϝ ā§§ āĻŦāĻŋāĻ-āĻ āϝāĻĨā§āώā§āĻ (ā§Ļ āĻŦāĻž ā§§)āĨ¤
āϏāĻžāĻāĻ āĻŽāύ⧠āϰāĻžāĻāĻžāϰ āĻļāϰā§āĻāĻāĻžāĻ āĻāĻžāϰā§āĻÂļ
| āĻĄāĻžāĻāĻž āĻāĻžāĻāĻĒ | āϏāĻžāĻāĻ (Byte-āĻ) | āĻŽāύ⧠āϰāĻžāĻāĻžāϰ āϏāĻšāĻ āϏā§āϤā§āϰ |
|---|---|---|
| byte | ā§§ Byte | āĻļā§āϰā§āϰ āĻāĻžāĻāĻĒ, āϤāĻžāĻ ā§§ |
| short | ⧍ Bytes | ā§§ āĻāϰ āĻĻā§āĻŦāĻŋāĻā§āĻŖ = ⧍ |
| int | ā§Ē Bytes | ⧍ āĻāϰ āĻĻā§āĻŦāĻŋāĻā§āĻŖ = ā§Ē |
| long | ā§Ž Bytes | ā§Ē āĻāϰ āĻĻā§āĻŦāĻŋāĻā§āĻŖ = ā§Ž |
| float | ā§Ē Bytes | int āĻāϰ āϏāĻŽāĻžāύ |
| double | ā§Ž Bytes | long āĻāϰ āϏāĻŽāĻžāύ |
| char | ⧍ Bytes | short āĻāϰ āϏāĻŽāĻžāύ |
| boolean | ā§§ bit | āϏāĻŦāĻā§ā§ā§ āĻā§āĻ (āĻļā§āϧ⧠True/False) |
What is multithreading in Java? Discuss the advantages of multithreading over process based multitaskingÂļ
What is multithreading in Java? Discuss the advantages of multithreading over process based multitasking
Definition:
Multithreading is a feature (āĻŦā§āĻļāĻŋāώā§āĻā§āϝ) in Java that allows concurrent (āĻāĻāĻ āϏāĻŽā§ā§/āϝā§āĻāĻĒā§) execution of two or more parts of a program for maximum utilization (āĻŦā§āϝāĻŦāĻšāĻžāϰ/āĻŦā§āϝāĻŦāĻšāĻžāϰāĻŋāĻ āϏā§āĻŦāĻŋāϧāĻž) of the CPU. Each part of such a program is called a thread (āϏā§āϤāĻž/āĻā§āώā§āĻĻā§āϰāϤāĻŽ āĻ
āĻāĻļ), and threads are light-weight sub-processes within a single program.
Advantages of Multithreading over Process-Based MultitaskingÂļ
Multitasking can be achieved in two ways: Process-based (āĻĒā§āϰāϏā§āϏ-āĻāĻŋāϤā§āϤāĻŋāĻ) and Thread-based (āĻĨā§āϰā§āĻĄ-āĻāĻŋāϤā§āϤāĻŋāĻ/āĻŽāĻžāϞā§āĻāĻŋāĻĨā§āϰā§āĻĄāĻŋāĻ). Multithreading is highly preferred due to the following advantages:
- Resource Sharing (āϰāĻŋāϏā§āϰā§āϏ āĻļā§ā§āĻžāϰāĻŋāĻ): Threads share the same address space (āĻ āĻŋāĻāĻžāύāĻž āĻŽā§āĻŽā§āϰāĻŋ) and memory of the process. In contrast, separate processes require isolated (āĻĒā§āĻĨāĻ/āĻāϞāĻžāĻĻāĻž) memory allocations, which wastes system memory.
- Low Context-Switching Overhead (āĻāĻŽ āĻāύāĻā§āĻā§āϏāĻ-āϏā§āĻāĻāĻŋāĻ āĻāϰāĻ): Switching from one thread to another within the same process takes very little time. Switching between two independent processes is highly expensive (āĻŦā§āϝāϝāĻŧāĻŦāĻšā§āϞ/āϧā§āϰāĻāϤāĻŋāϰ) and consumes more CPU cycles.
- Efficient Communication (āĻĻāĻā§āώ āϝā§āĻāĻžāϝā§āĻ): Communication between threads is very fast and easy because they share memory. Processes require Inter-Process Communication (IPC) (āĻāύā§āϤāĻāĻĒā§āϰāϏā§āϏ āϝā§āĻāĻžāϝā§āĻ) mechanisms, which are complex and slow.
- Non-Blocking Operation (āĻŦāĻžāϧāĻžāĻšā§āύ āĻāĻžāϰā§āϝāĻā§āϰāĻŽ): If one thread undergoes an exception (āĻŦā§āϝāϤāĻŋāĻā§āϰāĻŽ/āϤā§āϰā§āĻāĻŋ) or enters a waiting state (like downloading a file), other threads continue to run smoothly without blocking (āĻāĻāĻā§ āĻĻā§āĻā§āĻž) the entire user interface.
- Improved Performance (āĻāύā§āύāϤ āĻāĻžāϰā§āϝāĻā§āώāĻŽāϤāĻž): Multithreading utilizes multi-core CPUs effectively (āĻāĻžāϰā§āϝāĻāϰāĻāĻžāĻŦā§). Multiple threads can run on different processor cores at the exact same time, speeding up execution.
What do you understand by Collection Framework in Java? Write some differences between List, Set, and Map in the collection hierarchy.Âļ
What do you understand by Collection Framework in Java? Write some differences between List, Set, and Map in the collection hierarchy.
Definition:
The Java Collection Framework (JCF) is a unified (āĻāĻā§āĻā§āϤ/āϏāĻŽāύā§āĻŦāĻŋāϤ) architecture that provides a set of interfaces and classes to store and manipulate (āύāĻŋāϝāĻŧāύā§āϤā§āϰāĻŖ/āĻĒāϰāĻŋāĻŦāϰā§āϤāύ āĻāϰāĻž) a group of objects. It standardizes (āĻŽāĻžāύāϏāĻŽā§āĻŽāϤ āĻāϰāĻž) data handling across Java applications by replacing older, legacy (āĻāϤā§āϤāϰāĻžāϧāĻŋāĻāĻžāϰ āϏā§āϤā§āϰ⧠āĻĒā§āϰāĻžāĻĒā§āϤ/āĻĒā§āϰā§āύā§) utility classes like Vector, Stack, and Hashtable. According to standard authoritative sources like GeeksforGeeks and TutorialsPoint, this framework optimizes performance by offering ready-made, highly efficient data structures.
Core Components:
* Interfaces (āĻāύā§āĻāĻžāϰāĻĢā§āϏ): Abstract data types representing collections (e.g., Collection, List, Set, Map).
* Implementations (āĻŦāĻžāϏā§āϤāĻŦāĻžāϝāĻŧāύ): Concrete classes providing internal mechanics for interfaces (e.g., ArrayList, HashSet, HashMap).
* Algorithms (āĻ
ā§āϝāĻžāϞāĻāϰāĻŋāĻĻāĻŽ): High-performance static methods for searching, sorting, and shuffling (āĻāϞāĻāĻĒāĻžāϞāĻ āĻāϰāĻž) elements.
Differences Between List, Set, and MapÂļ
While List and Set inherit from the core Collection interface, Map stands independently because it manages structured pairs rather than standalone items.
| Feature (āĻŦā§āĻļāĻŋāώā§āĻā§āϝ) | List (āϞāĻŋāϏā§āĻ) | Set (āϏā§āĻ) | Map (āĻŽā§āϝāĻžāĻĒ) |
|---|---|---|---|
| Data Layout (āĻĄāĻžāĻāĻž āĻŦāĻŋāύā§āϝāĻžāϏ) | Stores elements in an ordered sequence (āĻā§āϰāĻŽāĻžāύā§āϏāĻžāϰ⧠āϏāĻžāĻāĻžāύā§) by index. | Stores elements in an unordered (āĻāϞā§āĻŽā§āϞā§) mathematical collection. | Stores data using a Key-Value pair (āĻāĻžāĻŦāĻŋ āĻāĻŦāĻ āĻŽāĻžāύā§āϰ āĻā§ā§āĻž) structure. |
| Duplicates (āĻ āύā§āϰā§āĻĒ āĻāĻĒāĻžāĻĻāĻžāύ) | Allows duplicate items freely. | Strictly prohibits (āĻāĻ ā§āϰāĻāĻžāĻŦā§ āύāĻŋāώāĻŋāĻĻā§āϧ āĻāϰāĻž) duplicates. | Keys must be unique; values can be duplicated. |
| Null Handling (āĻāĻžāϞāĻŋ āĻŽāĻžāύ āĻŦā§āϝāĻŦāϏā§āĻĨāĻžāĻĒāύāĻž) | Accepts multiple null elements. | Allows at most one null element. | Allows one null key and multiple null values. |
| Access Vector (āĻ ā§āϝāĻžāĻā§āϏā§āϏ āĻŽāĻžāϧā§āϝāĻŽ) | Uses an integer index (e.g., list.get(0)). | Requires an iterator (āĻĒā§āύāϰāĻžāĻŦā§āϤā§āϤāĻŋāĻāĻžāϰāĻ) or enhanced loop. | Uses the key object to fetch values (e.g., map.get(key)). |
| Hierarchy Position (āĻļā§āϰā§āĻŖā§āĻŦāĻŋāύā§āϝāĻžāϏ⧠āĻ āĻŦāϏā§āĻĨāĻžāύ) | Directly extends the Collection interface. | Directly extends the Collection interface. | Does not extend Collection; acts as a separate root interface. |
| Top Classes (āĻļā§āϰā§āώāϏā§āĻĨāĻžāύā§ā§ āĻā§āϞāĻžāϏāϏāĻŽā§āĻš) | ArrayList, LinkedList, Vector | HashSet, LinkedHashSet, TreeSet | HashMap, LinkedHashMap, TreeMap |
âąī¸ 30-Second Exam Revision Note:
* Framework Core: Unified architecture consisting of Interfaces, Classes, and Algorithms.
* List: Ordered sequence, allows duplicate values, index-driven.
* Set: Unordered collection, enforces strict uniqueness, no index access.
* Map: Dynamic key-value pairs, keys are strictly unique, completely separate interface root.
* Key Equation: List & Set â Collection Interface â Map Interface.
Please provide the next question from your previous terms to proceed with the generation of this study guide.
Does Java support multiple inheritances where each class is able to extend multiple classes?
āĻāĻžāĻāĻž āĻĒā§āϰāϧāĻžāύāϤ The Diamond Problem (āĻĄāĻžāϝāĻŧāĻŽāύā§āĻĄ āĻĒā§āϰāĻŦāϞā§āĻŽ) āĻŦāĻž āĻŽā§āĻĨāĻĄ āύāĻŋā§ā§ āϤā§āϰāĻŋ āĻšāĻā§āĻž āĻāĻ āϧāϰāĻŖā§āϰ āĻāĻāĻŋāϞ āĻĻā§āĻŦā§āϝāϰā§āĻĨāϤāĻž (ambiguity) āĻā§āĻžāύā§āϰ āĻāύā§āϝ āϏāϰāĻžāϏāϰāĻŋ āĻā§āϞāĻžāϏā§āϰ āĻŽāĻžāϧā§āϝāĻŽā§ multiple inheritance āϏāĻžāĻĒā§āϰā§āĻ āĻāϰ⧠āύāĻžāĨ¤
āϏāĻšāĻ āĻāĻžāώāĻžā§ āĻŦāĻŋāώā§āĻāĻŋ āύāĻŋāĻā§ āĻŦā§āϝāĻžāĻā§āϝāĻž āĻāϰāĻž āĻšāϞā§:
ā§§. āĻĻā§āϝ āĻĄāĻžāϝāĻŧāĻŽāύā§āĻĄ āĻĒā§āϰāĻŦāϞā§āĻŽ (The Diamond Problem)Âļ
āϧāϰā§āύ, āĻāĻžāĻāĻžā§ āĻāĻāĻžāϧāĻŋāĻ āĻā§āϞāĻžāϏ āĻāĻā§āϏāĻā§āύā§āĻĄ āĻāϰāĻž āϏāĻŽā§āĻāĻŦ (āϧāϰ⧠āύāĻŋāĻā§āĻāĻŋ)āĨ¤ āĻāĻāύ āĻāĻāĻāĻŋ āĻĻā§āĻļā§āϝāĻĒāĻ āĻāĻŋāύā§āϤāĻž āĻāϰā§āύ:
- āĻāĻāĻāĻŋ āϏā§āĻĒāĻžāϰāĻā§āϞāĻžāϏ āĻāĻā§ Class A, āϝāĻžāϰ āĻŽāϧā§āϝ⧠print() āύāĻžāĻŽā§ āĻāĻāĻāĻŋ āĻŽā§āĻĨāĻĄ āĻāĻā§āĨ¤
- āĻĻā§āĻāĻŋ āĻāĻžāĻāϞā§āĻĄ āĻā§āϞāĻžāϏ Class B āĻāĻŦāĻ Class C āĻāĻāϝāĻŧāĻ Class A-āĻā§ āĻāĻā§āϏāĻā§āύā§āĻĄ āĻāϰā§āĻā§ āĻāĻŦāĻ āύāĻŋāĻā§āĻĻā§āϰ āĻŽāϤ⧠āĻāϰ⧠print() āĻŽā§āĻĨāĻĄāĻāĻŋāĻā§ āĻāĻāĻžāϰāϰāĻžāĻāĻĄ (override) āĻāϰā§āĻā§āĨ¤
-
āĻāĻāύ āϝāĻĻāĻŋ āĻāĻāĻāĻŋ āύāϤā§āύ āĻā§āϞāĻžāϏ Class D āĻāĻāĻ āϏāĻžāĻĨā§ Class B āĻāĻŦāĻ Class C āĻĻā§āĻāĻāĻžāĻā§āĻ āĻāĻā§āϏāĻā§āύā§āĻĄ āĻāϰ⧠(class D extends B, C):
[ Class A (print) ]
/ \
/ \
[ Class B (print) ] [ Class C (print) ]
/
/
[ Class D (print?) ]
āĻāĻāύ āϝāĻĻāĻŋ āĻāĻĒāύāĻŋ Class D-āĻāϰ āĻāĻāĻāĻŋ āĻ
āĻŦāĻā§āĻā§āĻ āϤā§āϰāĻŋ āĻāϰ⧠print() āĻŽā§āĻĨāĻĄāĻāĻŋ āĻāϞ āĻāϰā§āύ, āϤāĻāύ āĻāĻžāĻāĻž āĻāĻŽā§āĻĒāĻžāĻāϞāĻžāϰ āĻŽāĻžāϰāĻžāϤā§āĻŽāĻ āĻāύāĻĢāĻŋāĻāĻļāύ⧠āĻĒā§ā§ āϝāĻžāĻŦā§âāϏ⧠āĻāĻŋ Class B-āĻāϰ āĻŽā§āĻĨāĻĄāĻāĻŋ āϰāĻžāύ āĻāϰāĻŦā§, āύāĻžāĻāĻŋ Class C-āĻāϰ āĻŽā§āĻĨāĻĄāĻāĻŋ āϰāĻžāύ āĻāϰāĻŦā§?
āĻāĻ āϝ⧠āĻšā§āϰāĻ āĻāĻā§āϤāĻŋāϰ (diamond shape) āĻāύāĻĢāĻŋāĻāĻļāύ āϤā§āϰāĻŋ āĻšā§, āĻāĻā§āĻ āĻĄāĻžāϝāĻŧāĻŽāύā§āĻĄ āĻĒā§āϰāĻŦāϞā§āĻŽ āĻŦāϞā§āĨ¤ āϏāĻŋ++ (C++) āĻāϰ āĻŽāϤ⧠āĻāĻžāώāĻžā§ āĻāĻāĻŋ āĻšā§āϝāĻžāύā§āĻĄā§āϞ āĻāϰāĻž āĻā§āϞā§āĻ āĻā§āĻĄ āĻ
āύā§āĻ āĻāĻāĻŋāϞ āĻšā§ā§ āϝāĻžā§āĨ¤ āĻāĻžāĻāĻž āϤā§āϰāĻŋāϰ āĻŽā§āϞ āĻāĻĻā§āĻĻā§āĻļā§āϝ āĻāĻŋāϞ āĻāĻāĻŋāĻā§ āϏāĻšāĻ āĻ āϏā§āϰāĻā§āώāĻŋāϤ āϰāĻžāĻāĻž, āϤāĻžāĻ āĻā§āϞāĻžāϏā§āϰ āĻā§āώā§āϤā§āϰ⧠āĻāĻāĻŋ āύāĻŋāώāĻŋāĻĻā§āϧ āĻāϰāĻž āĻšā§ā§āĻā§āĨ¤
⧍. āĻŽā§āĻŽā§āϰāĻŋ āĻāĻŦāĻ āĻāύāϏā§āĻā§āϰāĻžāĻā§āĻāϰ āĻāϞāĻŋāĻ āĻāĻāĻŋāϞāϤāĻžÂļ
āϝāĻāύ āĻāĻĒāύāĻŋ āĻā§āύ⧠āĻāĻžāĻāϞā§āĻĄ āĻā§āϞāĻžāϏā§āϰ āĻ āĻŦāĻā§āĻā§āĻ āϤā§āϰāĻŋ āĻāϰā§āύ, āϤāĻāύ āĻŦā§āϝāĻžāĻāĻā§āϰāĻžāĻāύā§āĻĄā§ āϤāĻžāϰ āĻĒā§āϝāĻžāϰā§āύā§āĻ āĻā§āϞāĻžāϏā§āϰ āĻāύāϏā§āĻā§āϰāĻžāĻā§āĻāϰ (super()) āĻāϞ āĻšā§āĨ¤ āϝāĻĻāĻŋ āĻāĻāĻāĻŋ āĻā§āϞāĻžāϏ āĻĻā§āĻāĻŋ āĻāϞāĻžāĻĻāĻž āĻā§āϞāĻžāϏāĻā§ āĻāĻā§āϏāĻā§āύā§āĻĄ āĻāϰā§, āϤāĻŦā§ āĻā§āύ āĻĒā§āϝāĻžāϰā§āύā§āĻ āĻā§āϞāĻžāϏā§āϰ āĻāύāϏā§āĻā§āϰāĻžāĻā§āĻāϰ āĻāĻā§ āĻāϞ āĻšāĻŦā§ āĻāĻŦāĻ āĻŽā§āĻŽā§āϰāĻŋāϤ⧠āĻā§āϝāĻžāϰāĻŋā§ā§āĻŦāϞāĻā§āϞ⧠āĻā§āĻāĻžāĻŦā§ āĻ ā§āϝāĻžāϞā§āĻā§āĻ āĻšāĻŦā§, āϤāĻž āύāĻŋā§ā§ āĻāĻāĻŋāϞāϤāĻž āϤā§āϰāĻŋ āĻšāϤā§āĨ¤
ā§Š. āĻā§āĻĄ āϏāĻšāĻ āĻ āĻĒāϰāĻŋāώā§āĻāĻžāϰ āϰāĻžāĻāĻžÂļ
āĻāĻžāĻāĻžāϰ āĻĄāĻŋāĻāĻžāĻāύāĻžāϰāϰāĻž (āϝā§āĻŽāύ āĻā§āĻŽāϏ āĻāϏāϞāĻŋāĻ) āĻā§ā§ā§āĻāĻŋāϞā§āύ āĻāĻžāĻāĻž āϝā§āύ āĻāĻāĻāĻŋ āϏāĻžāϧāĻžāϰāĻŖ āĻāĻŦāĻ āĻāĻāĻŋāϞāϤāĻžāĻŽā§āĻā§āϤ āĻāĻžāώāĻž āĻšā§āĨ¤ āĻāĻāĻžāϧāĻŋāĻ āĻā§āϞāĻžāϏ āĻāύāĻšā§āϰāĻŋāĻ āĻāϰāϞ⧠āĻā§āĻĄ āĻŽā§āĻāύāĻā§āĻāύ āĻāϰāĻž āĻāĻŦāĻ āĻĄāĻŋāĻŦāĻžāĻ āĻāϰāĻž āĻāĻ āĻŋāύ āĻšā§ā§ āĻĒā§ā§āĨ¤Âļ
āĻāĻžāĻāĻžāϰ āĻ āϞā§āĻāĻžāϰāύā§āĻāĻŋāĻ āϏāĻŽāĻžāϧāĻžāύÂļ
āĻāĻžāĻāĻž āĻā§āϞāĻžāϏā§āϰ āĻā§āώā§āϤā§āϰ⧠āĻāĻāĻŋ āĻŦā§āϞāĻ āĻāϰāϞā§āĻ Interface (āĻāύā§āĻāĻžāϰāĻĢā§āϏ) āĻāϰ āĻŽāĻžāϧā§āϝāĻŽā§ āĻāĻŋāύā§āϤ⧠multiple inheritance āĻāϰāĻžāϰ āϏā§āϝā§āĻ āĻĻā§ā§āĨ¤
- āĻāĻāĻāĻŋ āĻā§āϞāĻžāϏ āĻāĻāϏāĻžāĻĨā§ āĻāĻāĻžāϧāĻŋāĻ āĻāύā§āĻāĻžāϰāĻĢā§āϏ implements āĻāϰāϤ⧠āĻĒāĻžāϰā§āĨ¤
- āĻāĻžāĻāĻž ā§Ž āĻĨā§āĻā§ āĻāύā§āĻāĻžāϰāĻĢā§āϏ⧠default method āĻāϏāĻžāϰ āĻĒāϰ āϝāĻĻāĻŋ āĻĻā§āĻāĻŋ āĻāύā§āĻāĻžāϰāĻĢā§āϏ⧠āĻāĻāĻ āύāĻžāĻŽā§āϰ āĻŽā§āĻĨāĻĄ āĻĨāĻžāĻā§, āϤāĻŦā§ āĻāĻžāĻāĻž āĻāĻŽā§āĻĒāĻžāĻāϞāĻžāϰ āĻāĻĒāύāĻžāĻā§ āĻŦāĻžāϧā§āϝ āĻāϰāĻŦā§ āĻāĻžāĻāϞā§āĻĄ āĻā§āϞāĻžāϏ⧠āĻŽā§āĻĨāĻĄāĻāĻŋ āĻāĻāĻžāϰāϰāĻžāĻāĻĄ āĻāϰ⧠āĻāύāĻĢāĻŋāĻāĻļāύ āĻĻā§āϰ āĻāϰāϤā§āĨ¤ āĻĢāϞ⧠āĻĄāĻžāϝāĻŧāĻŽāύā§āĻĄ āĻĒā§āϰāĻŦāϞā§āĻŽ āĻāĻžā§āĻžāĻ āĻāĻāĻžāϧāĻŋāĻ āĻāĻāϰāĻŖ āĻŦāĻž āĻĢāĻŋāĻāĻžāϰ āĻāĻ āĻā§āϞāĻžāϏ⧠āĻāύāĻž āϝāĻžā§āĨ¤

