Skip to content

Revision Before ExamÂļ

ā§§. Interface = āĻŽā§‡āχāύ āĻŦā§āϞ⧁āĻĒā§āϰāĻŋāĻ¨ā§āϟ (āĻ•āĻžāĻ—āĻœā§‡-āĻ•āϞāĻŽā§‡)Âļ

āχāĻžā§āϜāĻŋāύāĻŋ⧟āĻžāϰāϰāĻž āĻāĻ•āĻĻāĻŽ āĻļ⧁āϰ⧁āϤ⧇ āĻŸā§‡āĻŦāĻŋāϞ āĻŦāĻž āĻ•āĻžāĻ—āĻœā§‡ āĻ–āϏ⧜āĻž āύāĻ•āĻļāĻž āĻ•āϰāϞ⧇āύ: "āĻ—āĻžā§œāĻŋāϰ āϚāĻžāϰāϟāĻž āϚāĻžāĻ•āĻž āĻĨāĻžāĻ•āĻŦ⧇, āĻāĻ•āϟāĻž āĻ¸ā§āϟāĻŋ⧟āĻžāϰāĻŋāĻ‚ āĻĨāĻžāĻ•āĻŦ⧇, āĻŦā§āϰ⧇āĻ• āĻĨāĻžāĻ•āĻŦ⧇āĨ¤"

  • Static āĻŽā§‡āĻĨāĻĄā§‡āϰ āϞāϜāĻŋāĻ•: āĻāχ āĻ•āĻžāĻ—āĻœā§‡-āĻ•āϞāĻŽā§‡ āύāĻ•āĻļāĻžāϰ āϭ⧇āϤāϰ⧇āχ āĻāĻ•āϟāĻž āĻ—ā§āϞ⧋āĻŦāĻžāϞ āĻ¸ā§āĻŸā§āϝāĻžāĻ¨ā§āĻĄāĻžāĻ°ā§āĻĄ āĻŦāĻž āύāĻŋ⧟āĻŽ āĻĢāĻŋāĻ•ā§āϏāĻĄ āĻ•āϰ⧇ āĻĻ⧇āĻ“ā§ŸāĻž āĻšāϞ⧋ (āϝ⧇āĻŽāύ: "āϏāĻŦ āĻ—āĻžā§œāĻŋ āϚāĻžāĻ•āĻžāϰ āϜāĻ¨ā§āϝ āϰāĻžāĻŦāĻžāϰ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻŦ⧇"—āĻāϟāĻž āĻŦāĻĻāϞāĻžāύ⧋ āϝāĻžāĻŦ⧇ āύāĻž)āĨ¤ āĻāϟāĻž āĻšāϞ⧋ āχāĻ¨ā§āϟāĻžāϰāĻĢ⧇āϏ⧇āϰ static āĻŽā§‡āĻĨāĻĄ āĻŦāĻž āĻ•āύāĻ¸ā§āĻŸā§āϝāĻžāĻ¨ā§āϟ āĻ­ā§āϝāĻžāϰāĻŋā§Ÿā§‡āĻŦāϞāĨ¤

⧍. Class = āĻĒā§āϰ⧋āĻŸā§‹āϟāĻžāχāĻĒ (Prototype)Âļ

āύāĻ•āĻļāĻž āĻĻ⧇āϖ⧇ āĻĢā§āϝāĻžāĻ•ā§āϟāϰāĻŋ āĻŦāĻž āĻ˛ā§āϝāĻžāĻŦ⧇ āĻĒā§āϰāĻĨāĻŽ āĻāĻ•āϟāĻž āĻŸā§‡āĻ¸ā§āϟ āĻŽāĻĄā§‡āϞ āĻŦāĻž āĻĒā§āϰ⧋āĻŸā§‹āϟāĻžāχāĻĒ āϤ⧈āϰāĻŋ āĻ•āϰāĻž āĻšāϞ⧋āĨ¤ āĻāĻ–āĻžāύ⧇ āχāĻžā§āϜāĻŋāύ⧇āϰ āϭ⧇āϤāϰ⧇āϰ āϤāĻžāϰ āϕ⧀āĻ­āĻžāĻŦ⧇ āĻœā§‹ā§œāĻž āϞāĻžāĻ—āĻŦ⧇, āĻŽā§‡āϟāĻžāϞ āĻŦāĻĄāĻŋ āϕ⧀āĻ­āĻžāĻŦ⧇ āĻĢāĻŋāĻ•ā§āϏāĻĄ āĻšāĻŦ⧇ (āϕ⧋āĻĄā§‡āϰ āĻŦāĻĄāĻŋ āĻŦāĻž āϞāϜāĻŋāĻ•) āϏāĻŦāĻ•āĻŋāϛ⧁ āϏāĻŽā§āĻĒā§‚āĻ°ā§āĻŖ āĻ¸ā§āĻŸā§āϰāĻžāĻ•āϚāĻžāϰ āĻ•āϰāĻž āĻšāϞ⧋āĨ¤ āĻāϟāĻž āĻšāϞ⧋ āφāĻĒāύāĻžāϰ ClassāĨ¤ āĻĒā§āϰ⧋āĻŸā§‹āϟāĻžāχāĻĒ āύāĻŋāĻœā§‡ āϰāĻžāĻ¸ā§āϤāĻžā§Ÿ āϚāϞ⧇ āύāĻž, āĻ•āĻŋāĻ¨ā§āϤ⧁ āĻāϟāĻž āφāϏāϞ āĻ—āĻžā§œāĻŋ āĻŦāĻžāύāĻžāύ⧋āϰ āϜāĻ¨ā§āϝ āĻāĻ•āĻĻāĻŽ āϰ⧇āĻĄāĻŋ āĻ¸ā§āĻŸā§āϰāĻžāĻ•āϚāĻžāϰāĨ¤

ā§Š. Object = āϰāĻŋāϝāĻŧ⧇āϞ āĻ…āĻŦāĻœā§‡āĻ•ā§āϟ (Real Object)Âļ

āĻ“āχ āĻĒā§āϰ⧋āĻŸā§‹āϟāĻžāχāĻĒ (Class) āϏāĻĢāϞāĻ­āĻžāĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰāĻžāϰ āĻĒāϰ āĻĢā§āϝāĻžāĻ•ā§āϟāϰāĻŋāϰ āĻ…ā§āϝāĻžāϏ⧇āĻŽā§āĻŦāϞāĻŋ āϞāĻžāχāύ āĻĨ⧇āϕ⧇ āϞāĻžāĻ– āϞāĻžāĻ– āĻ—āĻžā§œāĻŋ āϤ⧈āϰāĻŋ āĻšā§Ÿā§‡ āĻļā§‹āϰ⧁āĻŽā§‡ āϚāϞ⧇ āφāϏāϞ⧋āĨ¤ āϝ⧇āĻŽāύ āφāĻĒāύāĻžāϰ āϕ⧇āύāĻž āϞāĻžāϞ āϰāϙ⧇āϰ āĻŸā§Ÿā§‹āϟāĻž āĻ—āĻžā§œāĻŋāϟāĻŋ, āϝ⧇āϟāĻžā§Ÿ āφāĻĒāύāĻŋ āϚāĻžāĻŦāĻŋ āĻĻāĻŋā§Ÿā§‡ āĻ¸ā§āϟāĻžāĻ°ā§āϟ āĻĻāĻŋāĻšā§āϛ⧇āύ āĻāĻŦāĻ‚ āĻĄā§āϰāĻžāχāĻ­ āĻ•āϰāϛ⧇āύāĨ¤ āĻāϟāĻŋāχ āĻšāϞ⧋ āφāϏāϞ Object āĻŦāĻž āĻŽā§‡āĻŽā§‹āϰāĻŋāϤ⧇ āϜāĻžā§ŸāĻ—āĻž āύ⧇āĻ“ā§ŸāĻž āϰāĻŋ⧟āĻžāϞ āĻāϞāĻŋāĻŽā§‡āĻ¨ā§āϟāĨ¤

alt text


āĻāĻ• āύāϜāϰ⧇ āφāĻĒāύāĻžāϰ āϤ⧈āϰāĻŋ āĻ•āϰāĻž āĻŽā§‡āĻŽā§‹āϰāĻŋ āĻŽā§āϝāĻžāĻĒ:Âļ

āφāĻĒāύāĻžāϰ āĻĨāĻŋāĻ“āϰāĻŋ āϜāĻžāĻ­āĻžāϰ āϰ⧂āĻĒ āĻŦāĻžāĻ¸ā§āϤāĻŦ āωāĻĻāĻžāĻšāϰāĻŖ (āĻ—āĻžā§œāĻŋ)
āĻŽā§‡āχāύ āĻŦā§āϞ⧁āĻĒā§āϰāĻŋāĻ¨ā§āϟ 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:

  1. 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.
  2. 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

āĻŸā§āϰāĻŋāĻ• ⧍: āĻ›āϕ⧇āϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āĻ—ā§āϰ⧁āĻĒ āĻ•āϰ⧇ āĻŽāύ⧇ āϰāĻžāĻ–āĻž (āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻŦ⧈āĻœā§āĻžāĻžāύāĻŋāĻ• āωāĻĒāĻžā§Ÿ)Âļ

āĻŽā§āĻ–āĻ¸ā§āĻĨ āύāĻž āĻ•āϰ⧇ āĻŽāĻžāĻĨāĻžā§Ÿ āĻāĻ•āϟāĻž āĻŽā§āϝāĻžāĻĒ āϤ⧈āϰāĻŋ āĻ•āϰ⧇ āύāĻŋāύāĨ¤ āĻāχ ā§ŽāϟāĻŋ āϟāĻžāχāĻĒāϕ⧇ āĻŽāĻžāĻ¤ā§āϰ ā§ŠāϟāĻŋ āĻ­āĻžāϗ⧇ āĻ­āĻžāĻ— āĻ•āϰāĻž āϝāĻžā§Ÿ:

  1. āϏāĻ‚āĻ–ā§āϝāĻžāϰ āĻĻāϞ (āĻĒā§‚āĻ°ā§āĻŖāϏāĻ‚āĻ–ā§āϝāĻž): āϏāĻžāχāϜ āϛ⧋āϟ āĻĨ⧇āϕ⧇ āĻŦ⧜ āĻ•ā§āϰāĻŽāĻžāύ⧁āϏāĻžāϰ⧇ āϏāĻžāϜāĻžāύ⧋:
  2. byte \(\rightarrow\) short \(\rightarrow\) int \(\rightarrow\) long
  3. āĻĻāĻļāĻŽāĻŋāϕ⧇āϰ āĻĻāϞ (āĻ­āĻ—ā§āύāĻžāĻ‚āĻļ): āϛ⧋āϟ āĻāĻŦāĻ‚ āĻŦ⧜:
  4. float \(\rightarrow\) double
  5. āĻ…āĻ¨ā§āϝāĻžāĻ¨ā§āϝ (āĻ…āĻ•ā§āώāϰ āĻ“ āϞāϜāĻŋāĻ•):
  6. 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)

java types mnemonic cheat sheet

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 āφāϏāĻžāϰ āĻĒāϰ āϝāĻĻāĻŋ āĻĻ⧁āϟāĻŋ āχāĻ¨ā§āϟāĻžāϰāĻĢ⧇āϏ⧇ āĻāĻ•āχ āύāĻžāĻŽā§‡āϰ āĻŽā§‡āĻĨāĻĄ āĻĨāĻžāϕ⧇, āϤāĻŦ⧇ āϜāĻžāĻ­āĻž āĻ•āĻŽā§āĻĒāĻžāχāϞāĻžāϰ āφāĻĒāύāĻžāϕ⧇ āĻŦāĻžāĻ§ā§āϝ āĻ•āϰāĻŦ⧇ āϚāĻžāχāĻ˛ā§āĻĄ āĻ•ā§āϞāĻžāϏ⧇ āĻŽā§‡āĻĨāĻĄāϟāĻŋ āĻ“āĻ­āĻžāϰāϰāĻžāχāĻĄ āĻ•āϰ⧇ āĻ•āύāĻĢāĻŋāωāĻļāύ āĻĻā§‚āϰ āĻ•āϰāϤ⧇āĨ¤ āĻĢāϞ⧇ āĻĄāĻžāϝāĻŧāĻŽāĻ¨ā§āĻĄ āĻĒā§āϰāĻŦāϞ⧇āĻŽ āĻ›āĻžā§œāĻžāχ āĻāĻ•āĻžāϧāĻŋāĻ• āφāϚāϰāĻŖ āĻŦāĻž āĻĢāĻŋāϚāĻžāϰ āĻāĻ• āĻ•ā§āϞāĻžāϏ⧇ āφāύāĻž āϝāĻžā§ŸāĨ¤