OBJECT-ORIENTED PROGRAMMING

CONCEPTS & CORE FEATURES OF JAVA

Student Study Material

Topics Covered
Classes • Objects • Inheritance • Polymorphism • Abstraction • Encapsulation
Features of Java • Bytecode • JVM • JDK

Each topic follows a structured 15-point format:

Definition → Introduction → Need → Characteristics → Advantages → Disadvantages → Applications → Real-Time Example → Diagram → Types → Syntax
→ Java Program → Output → Explanation → Summary
Table of Contents
TOC \h \o "1-1"
1. Classes

1. Definition
A class is a user-defined blueprint or template from which objects are created. It defines a set of properties
(fields/variables) and behaviors (methods) that are common to all objects of that type.

2. Introduction
In Java, everything revolves around classes because Java is a purely object-oriented language. A class does not
occupy memory until an object is created from it. It acts like a mould — the mould itself is not the product, but
every product made from it shares the same structure.

3. Need / Importance
• Provides a structured way to group related data and functions together.
• Enables code reusability — one class can be used to create many objects.
• Forms the foundation for other OOP principles like inheritance, polymorphism and encapsulation.
• Helps organize large programs into manageable, logical units.

4. Characteristics
• A class is a logical entity, not a physical one.
• It does not consume memory until instantiated.
• It can contain fields, methods, constructors, blocks, and nested classes/interfaces.
• A class can be declared using the 'class' keyword.

5. Advantages
• Promotes modularity and code reuse.
• Makes maintenance and debugging easier.
• Supports data hiding through access modifiers.
• Encourages a clear, real-world-oriented design of programs.

6. Disadvantages
• Overuse of classes for very small programs can add unnecessary complexity.
• Poorly designed class hierarchies can make code harder to maintain.

7. Applications
• Designing banking systems (Account class, Customer class).
• Building GUI applications (Button, Frame classes).
• Modelling real-world entities in simulations and games.
• Backbone of frameworks like Spring, Hibernate, Android SDK.
8. Real-Time Example
A 'Car' class can define common properties such as colour, brand, and speed, and common behaviours such as
start(), stop(), and accelerate(). Every car manufactured (Swift, i20, City) is an object created from this single
blueprint.

9. Diagram

[DIAGRAM] Class Diagram (UML): A rectangle divided into three parts — Class Name on top,
Attributes/Fields in the middle, and Methods/Operations at the bottom.

10. Types
• Concrete Class – a fully implemented class.
• Abstract Class – contains abstract methods, cannot be instantiated directly.
• Final Class – cannot be inherited.
• Static Class (nested) – a class declared static inside another class.
• Inner Class – a class defined within another class.

11. Syntax

class ClassName {
// fields (data members)
dataType fieldName;

// constructor
ClassName() { }

// methods (member functions)

returnType methodName() { }
}

12. Java Program

class Student {
// fields
String name;
int rollNo;

// method
void display() {
[Link]("Name: " + name);
[Link]("Roll No: " + rollNo);
}
}

public class ClassDemo {

public static void main(String[] args) {
Student s1 = new Student();
[Link] = "Arun";
[Link] = 101;
[Link]();
}
 }

13. Output

Name: Arun
Roll No: 101

14. Program Explanation

Here, 'Student' is a class with two fields (name, rollNo) and one method (display()). Inside the main() method of
the ClassDemo class, an object s1 is created using the 'new' keyword, values are assigned to its fields, and
display() is called to print them.

15. Summary

Summary: A class is a blueprint that defines fields and methods. It does not occupy memory by itself;
objects created from it hold actual data. Classes are the foundation of object-oriented programming in
Java.
2. Objects

1. Definition
An object is a real-world entity or a runtime instance of a class that has state (fields/attributes) and behaviour
(methods). It is created from a class using the 'new' keyword.

2. Introduction
While a class is only a design, an object is the actual entity built from that design. Every object has its own copy
of instance variables but shares the methods defined in the class. Objects interact with each other by calling
methods, which forms the basis of object-oriented communication.

3. Need / Importance
• Objects are required to actually use the properties and methods defined in a class.
• They allow multiple independent entities to be created from a single class.
• They enable real-world modelling of entities like Student, Employee, Car, etc.
• They provide the actual memory allocation for data manipulation.

4. Characteristics
• State – represented by the values of an object's attributes.
• Behaviour – represented by the methods an object can perform.
• Identity – a unique identifier (memory address/reference) that distinguishes one object from another.
• Objects are created dynamically at runtime using the 'new' keyword.

5. Advantages
• Allows multiple instances with independent states from a single class.
• Supports real-world modelling, making programs intuitive.
• Enables message passing between different parts of a program.
• Facilitates reusability of class definitions.

6. Disadvantages
• Creating too many objects unnecessarily can increase memory usage.
• Improper object management may lead to memory leaks in large applications.

7. Applications
• Every entity manipulated in an object-oriented program — e.g., an 'Employee' object in payroll software.
• GUI components such as buttons, text fields, and windows are objects.
• Database records mapped to objects in ORM frameworks (e.g., Hibernate).
• Game characters, vehicles, and items in simulations.
8. Real-Time Example
If 'Car' is a class, then 'myHondaCity' and 'myMaruti800' are objects of that class — each with its own colour,
number plate, and speed, but sharing the same methods like start() and stop().

9. Diagram

[DIAGRAM] Object Diagram: A rectangle labelled 'objectName : ClassName' showing the specific attribute
values held by that instance, distinguishing it from the general class diagram.

10. Types
• Local Object – created inside a method, has method-level scope.
• Instance Object – created using 'new' and referenced through a variable, holds the object's state
throughout its lifetime.
• Anonymous Object – created without storing the reference in a variable, used once immediately.

11. Syntax

ClassName referenceVariable = new ClassName();

// Example
Student s1 = new Student();

12. Java Program

class Student {
String name;
int rollNo;
}

public class ObjectDemo {

public static void main(String[] args) {
// Creating two objects of the same class
Student s1 = new Student();
Student s2 = new Student();

[Link] = "Priya";
[Link] = 1;

[Link] = "Karthik";
[Link] = 2;

[Link]([Link] + " - " + [Link]);

[Link]([Link] + " - " + [Link]);
}
}

13. Output

Priya - 1
Karthik - 2
14. Program Explanation
Two separate objects, s1 and s2, are created from the same Student class. Each object maintains its own
independent copy of the fields name and rollNo, proving that objects have their own distinct state even though
they come from the same class.

15. Summary

Summary: An object is a concrete instance of a class with its own state and identity, created at runtime
using 'new'. Multiple objects of the same class exist independently in memory while sharing the same
method definitions.
3. Inheritance

1. Definition
Inheritance is an OOP mechanism in which one class (subclass/child class) acquires the fields and methods of
another class (superclass/parent class), enabling code reuse and establishing an 'IS-A' relationship.

2. Introduction
Inheritance allows a new class to be built upon an existing class. The child class can reuse the parent's code and
also add its own new features or override existing behaviour. In Java, inheritance is implemented using the
'extends' keyword for classes and 'implements' for interfaces.

3. Need / Importance
• Avoids duplication of code by reusing existing class functionality.
• Establishes a natural hierarchical relationship between classes.
• Makes it easier to extend or modify functionality without touching existing tested code.
• Forms the basis for runtime polymorphism (method overriding).

4. Characteristics
• Supports the 'IS-A' relationship (e.g., a Dog IS-A Animal).
• The subclass inherits all non-private members of the superclass.
• Java does not support multiple inheritance through classes (to avoid ambiguity), but supports it through
interfaces.
• Constructors are not inherited, but the parent constructor can be invoked using super().

5. Advantages
• Increases code reusability and reduces redundancy.
• Improves code organization through hierarchical classification.
• Makes it easy to add new features to existing classes.
• Supports method overriding, enabling runtime polymorphism.

6. Disadvantages
• Tight coupling between parent and child classes can make changes risky.
• Deep inheritance hierarchies can be difficult to understand and maintain.
• Java's lack of multiple class inheritance can sometimes require workarounds using interfaces.

7. Applications
• GUI frameworks where custom components extend base classes (e.g., a custom Button extends JButton).
• Banking systems where SavingsAccount and CurrentAccount extend a common Account class.
• Employee management systems where Manager and Developer extend a common Employee class.
• Java's own class library, e.g., ArrayList extends AbstractList.
8. Real-Time Example
A 'Vehicle' class can have common properties like speed and fuel. 'Car' and 'Bike' classes can inherit from
Vehicle, reusing its features while adding their own specific ones (e.g., Car has 'numberOfDoors').

9. Diagram

[DIAGRAM] Inheritance Diagram (UML): An arrow with a hollow triangular arrowhead points from the child
class box up to the parent class box, indicating the 'extends' relationship.

10. Types
• Single Inheritance – one subclass inherits from one superclass.
• Multilevel Inheritance – a class inherits from a class that itself inherits from another class.
• Hierarchical Inheritance – multiple subclasses inherit from a single superclass.
• Multiple Inheritance – a class inherits from more than one class (achieved in Java only via interfaces).
• Hybrid Inheritance – a combination of two or more types (achieved via interfaces in Java).

11. Syntax

class SuperClass {
// fields and methods
}

class SubClass extends SuperClass {

// additional fields and methods
}

12. Java Program

class Animal {
void eat() {
[Link]("This animal eats food.");
}
}

class Dog extends Animal {

void bark() {
[Link]("The dog barks.");
}
}

public class InheritanceDemo {

public static void main(String[] args) {
Dog d = new Dog();
[Link](); // inherited method
[Link](); // own method
}
}
13. Output

This animal eats food.

The dog barks.

14. Program Explanation

The Dog class extends the Animal class using the 'extends' keyword, thereby inheriting the eat() method. The
object d of type Dog can call both the inherited eat() method and its own bark() method, demonstrating code
reuse through inheritance.

15. Summary

Summary: Inheritance lets a subclass reuse and extend the fields and methods of a superclass, modelled on
an IS-A relationship. It reduces duplication and forms the foundation for polymorphism in Java.
4. Polymorphism

1. Definition
Polymorphism means 'many forms'. It is the OOP feature that allows the same method name or operator to
behave differently based on the object or the number/type of arguments involved.

2. Introduction
Polymorphism enables a single interface to represent different underlying data types or behaviours. In Java, it is
achieved mainly in two ways: compile-time (static) polymorphism through method overloading, and runtime
(dynamic) polymorphism through method overriding.

3. Need / Importance
• Allows a single method name to perform different tasks, improving code readability.
• Enables flexible and extensible code design.
• Supports dynamic method dispatch, allowing programs to decide which method to call at runtime.
• Reduces the need for multiple method names for logically similar operations.

4. Characteristics
• Same method name can behave differently depending on context.
• Compile-time polymorphism is resolved by the compiler (overloading).
• Runtime polymorphism is resolved by the JVM at execution time (overriding).
• Works closely with inheritance — overriding requires a parent-child class relationship.

5. Advantages
• Improves code flexibility and reusability.
• Makes programs easier to extend with new classes without modifying existing code.
• Supports a uniform interface for different underlying implementations.
• Reduces code complexity by avoiding repetitive method names.

6. Disadvantages
• Can make debugging harder since the exact method executed is decided at runtime.
• Excessive use of overloading/overriding can reduce code clarity if not documented well.

7. Applications
• Method overloading in utility classes, e.g., [Link]() for int, double, long.
• Runtime polymorphism in frameworks where a base class reference calls overridden methods of different
subclasses (e.g., Shape reference calling draw() for Circle/Square objects).
• Operator overloading equivalent — the '+' operator working for both addition and string concatenation in
Java.
• Plug-in and driver architectures where a common interface supports multiple implementations.
8. Real-Time Example
A 'Shape' class has a method draw(). Circle, Rectangle, and Triangle classes override draw() to render themselves
differently, yet all can be called through a common Shape reference — this is polymorphism in action.

9. Diagram

[DIAGRAM] Polymorphism Diagram: A parent class 'Shape' at the top with a draw() method, and multiple
child classes (Circle, Square, Triangle) below it, each with their own version of draw(), all connected to the
parent via inheritance arrows.

10. Types
• Compile-time Polymorphism (Static Binding) – achieved through method overloading.
• Runtime Polymorphism (Dynamic Binding) – achieved through method overriding.

11. Syntax

// Overloading (compile-time)
returnType methodName(parameterList1) { }
returnType methodName(parameterList2) { }

// Overriding (runtime)
class Parent {
void show() { }
}
class Child extends Parent {
@Override
void show() { }
}

12. Java Program

class Shape {
void draw() {
[Link]("Drawing a generic shape");
}
}

class Circle extends Shape {

@Override
void draw() {
[Link]("Drawing a circle");
}
}

class Square extends Shape {

@Override
void draw() {
[Link]("Drawing a square");
}
}

public class PolymorphismDemo {

public static void main(String[] args) {
 Shape s;

s = new Circle();
[Link](); // runtime polymorphism

s = new Square();
[Link](); // runtime polymorphism
}
}

13. Output

Drawing a circle
Drawing a square

14. Program Explanation

A single reference variable 's' of type Shape is used to refer to different objects (Circle and Square) at different
times. When [Link]() is called, the JVM decides at runtime which overridden version of draw() to execute based
on the actual object type — this is dynamic method dispatch.

15. Summary

Summary: Polymorphism allows the same method to behave differently depending on the object or
arguments involved. It is achieved through method overloading (compile-time) and method overriding
(runtime), making Java programs more flexible and extensible.
5. Abstraction

1. Definition
Abstraction is the OOP principle of hiding internal implementation details and showing only the essential
features or functionality of an object to the user.

2. Introduction
Abstraction focuses on 'what' an object does rather than 'how' it does it. In Java, abstraction is achieved using
abstract classes and interfaces. The user interacts with a simplified view of a system without needing to
understand its complex internal workings.

3. Need / Importance
• Simplifies complex systems by presenting only relevant details to the user.
• Reduces the impact of changes — internal implementation can change without affecting the user's code.
• Helps in designing large systems by focusing on essential behaviour first.
• Improves security by hiding sensitive implementation logic.

4. Characteristics
• Focuses on essential qualities rather than specific implementation details.
• Achieved in Java through abstract classes (0–100% abstraction) and interfaces (100% abstraction,
traditionally).
• Abstract classes can have both abstract (unimplemented) and concrete (implemented) methods.
• Abstract classes/interfaces cannot be instantiated directly.

5. Advantages
• Reduces code complexity for the end user.
• Increases security by hiding internal logic.
• Improves maintainability since implementation changes don't affect the abstraction layer.
• Encourages a clean separation between 'what to do' and 'how to do it'.

6. Disadvantages
• Designing a good abstraction requires careful planning and experience.
• Overuse of abstraction can add unnecessary layers, making the code harder to trace.
• Abstract classes cannot support multiple inheritance the way interfaces can.

7. Applications
• Real-world example: driving a car — you use the steering wheel and pedals (abstracted interface) without
knowing the engine's internal combustion process.
• Java's own Collection interface abstracts the details of data storage from operations like add() and
remove().
 • Database drivers (JDBC) abstract the underlying database-specific implementation.
• Payment gateway systems where the user just calls pay() without knowing bank-level processing.

8. Real-Time Example
An ATM machine provides buttons for withdrawing cash, checking balance, etc. The user only interacts with this
simple interface, while the complex process of verifying the account, communicating with the bank server, and
dispensing cash is hidden.

9. Diagram

[DIAGRAM] Abstraction Diagram: An abstract class 'Vehicle' at the top with an abstract method run(), and
concrete subclasses like Car and Bike below it, each providing their own implementation of run().

10. Types
• Partial Abstraction – achieved using abstract classes (can have both abstract and non-abstract methods).
• Full/Complete Abstraction – achieved using interfaces (traditionally, all methods are abstract; Java 8+
interfaces can also have default/static methods).

11. Syntax

abstract class ClassName {

abstract returnType methodName(); // no body

void concreteMethod() {
// has a body
}
}

12. Java Program

abstract class Vehicle {

abstract void run(); // abstract method - no body

void fuel() {
[Link]("Vehicle needs fuel to run.");
}
}

class Car extends Vehicle {

@Override
void run() {
[Link]("Car runs on four wheels.");
}
}

public class AbstractionDemo {

public static void main(String[] args) {
Vehicle v = new Car();
[Link]();
[Link]();
}
 }

13. Output

Car runs on four wheels.

Vehicle needs fuel to run.

14. Program Explanation

Vehicle is declared abstract and contains an abstract method run() with no implementation, along with a
concrete method fuel(). The Car class extends Vehicle and provides the actual implementation of run(). The user
only needs to call [Link]() without knowing internal details — this hides complexity, i.e., abstraction.

15. Summary

Summary: Abstraction hides unnecessary implementation details and exposes only essential functionality.
In Java, it is implemented using abstract classes and interfaces, simplifying interaction with complex
systems.
6. Encapsulation

1. Definition
Encapsulation is the OOP mechanism of binding data (fields) and the methods that operate on that data into a
single unit (class), while restricting direct access to the internal data using access modifiers.

2. Introduction
Encapsulation is often called 'data hiding'. In Java, it is achieved by declaring the fields of a class as private and
providing public getter and setter methods to access and modify those fields in a controlled manner. This
protects the internal state of an object from unintended or unauthorized changes.

3. Need / Importance
• Protects sensitive data from unauthorized or accidental modification.
• Provides control over how fields are accessed and updated (e.g., validation in setters).
• Increases flexibility since internal implementation can change without breaking external code.
• Makes the class self-contained and easier to test and maintain.

4. Characteristics
• Fields are typically declared private.
• Access to fields is provided through public getter and setter methods.
• Achieves data hiding — internal representation is hidden from the outside world.
• Improves modularity since each class manages its own data.

5. Advantages
• Enhances security by restricting direct access to data.
• Allows validation logic to be added inside setters before updating a field.
• Improves code maintainability and flexibility.
• Makes the class easier to reuse without exposing implementation details.

6. Disadvantages
• Requires writing additional getter/setter code, which can increase code length.
• If overused for very simple classes, it may add unnecessary boilerplate.

7. Applications
• Java Bean classes, which strictly use private fields with public getters/setters.
• Banking applications where balance fields are private and modified only through controlled methods like
deposit() and withdraw().
• User authentication systems where password fields are hidden and only accessible through secure
methods.
• Any real-world POJO (Plain Old Java Object) used in enterprise applications.
8. Real-Time Example
A capsule/medicine cover encloses multiple ingredients so they cannot be accessed directly by hand; similarly,
an ATM hides the account balance field and only allows access through specific operations like 'check balance' or
'withdraw', ensuring the balance cannot be modified directly.

9. Diagram

[DIAGRAM] Encapsulation Diagram: A capsule-shaped or rectangular boundary representing the class, with
'private data' shown inside and 'public getter/setter methods' shown as gateways on the boundary through
which the outside world interacts.

10. Types
• Read-Only Encapsulation – class provides only getter methods, no setters.
• Write-Only Encapsulation – class provides only setter methods, no getters.
• Read-Write Encapsulation – class provides both getter and setter methods (most common form).

11. Syntax

class ClassName {
private dataType fieldName;

public dataType getFieldName() {

return fieldName;
}

public void setFieldName(dataType value) {

fieldName = value;
}
}

12. Java Program

class Account {
private double balance; // private field - hidden from outside

public double getBalance() {

return balance;
}

public void deposit(double amount) {

if (amount > 0) {
balance = balance + amount;
}
}
}

public class EncapsulationDemo {

public static void main(String[] args) {
Account acc = new Account();
[Link](5000);
[Link]("Balance: " + [Link]());
}
 }

13. Output

Balance: 5000.0

14. Program Explanation

The 'balance' field is declared private, so it cannot be accessed directly from outside the Account class (e.g.,
[Link] = 5000; would cause a compile error). Instead, the public method deposit() is used to modify it
safely, and getBalance() is used to read it. This demonstrates controlled access to data — encapsulation.

15. Summary

Summary: Encapsulation binds data and methods together in a class and hides the internal data using
private access modifiers, exposing it only through public getters and setters. This protects data integrity and
increases flexibility and security.
7. Features of Java

1. Definition
The features of Java refer to the core characteristics that make Java a robust, portable, secure, and widely used
programming language for building platform-independent applications.

2. Introduction
Java was designed by James Gosling and his team at Sun Microsystems with the philosophy 'Write Once, Run
Anywhere' (WORA). Its features collectively make it suitable for a huge range of applications — from enterprise
software to mobile apps and embedded systems.

3. Need / Importance
• Understanding Java's features helps developers choose it for projects requiring portability and security.
• Explains why Java is preferred over many other languages for large-scale, distributed applications.
• Helps beginners understand the philosophy and design goals behind the language.
• Forms the conceptual base before learning the JVM, JDK, and bytecode.

4. Characteristics
• Simple – easy to learn syntax, similar to C/C++ but without complex pointers.
• Object-Oriented – everything is treated as an object (except primitives).
• Platform Independent – bytecode runs on any device with a JVM.
• Secure – no explicit pointers, bytecode verification, and a security manager.
• Robust – strong memory management, exception handling, and type checking.
• Multithreaded – supports concurrent execution of two or more parts of a program.
• Architecture Neutral – compiled code is not tied to a specific processor architecture.
• Portable – the same bytecode runs on Windows, Linux, Mac, etc.
• High Performance – uses Just-In-Time (JIT) compiler for faster execution.
• Distributed – supports networking and remote applications (RMI, sockets).
• Dynamic – supports dynamic loading of classes at runtime.

5. Advantages
• Platform independence allows the same code to run on any operating system.
• Strong memory management through automatic garbage collection.
• Rich set of built-in libraries (Java API) speeds up development.
• Large community support and enterprise-level frameworks (Spring, Hibernate).

6. Disadvantages
• Slower than natively compiled languages like C/C++ due to bytecode interpretation (though JIT
compensates significantly).
• Higher memory consumption because of the JVM and garbage collector.
 • Verbose syntax compared to modern languages like Python.

7. Applications
• Enterprise web applications (using Spring, Java EE).
• Android mobile application development.
• Desktop GUI applications (Swing, JavaFX).
• Big Data tools (Hadoop, Kafka are built on Java).
• Embedded systems and smart cards.

8. Real-Time Example
A Java program written and compiled on a Windows machine can be copied and executed as-is on a Linux server
or a Mac, without any modification, because the JVM on each platform interprets the same bytecode — a direct
demonstration of platform independence.

9. Diagram

[DIAGRAM] Features Diagram: A central circle labelled 'Java' with multiple surrounding nodes/branches
labelled Simple, Secure, Robust, Portable, Multithreaded, Platform-Independent, Distributed, High
Performance — connected like a mind map.

11. Syntax

// A minimal Java program demonstrating basic syntax

public class ClassName {
public static void main(String[] args) {
// statements
}
}

12. Java Program

public class FeaturesDemo {

public static void main(String[] args) {
[Link]("Java is Simple, Secure and Platform Independent!");
[Link]("This same class file can run on Windows, Linux, or
Mac.");
}
}

13. Output

Java is Simple, Secure and Platform Independent!

This same class file can run on Windows, Linux, or Mac.
14. Program Explanation
This program is compiled once using javac to produce [Link] (bytecode). This single .class file can
then be executed using 'java FeaturesDemo' on any operating system that has a JVM installed, without
recompiling — practically demonstrating Java's platform-independence feature.

15. Summary

Summary: Java's features — simplicity, platform independence, security, robustness, and multithreading
among others — make it a powerful and versatile language. These features are the reason Java remains
widely used across enterprise, mobile, and web development.
8. Bytecode

1. Definition
Bytecode is the intermediate, platform-independent code generated by the Java compiler (javac) after compiling
a .java source file. It is stored in a .class file and is understood by the Java Virtual Machine (JVM).

2. Introduction
When a Java program is compiled, it is not directly converted into machine code (as in C/C++). Instead, it is
converted into bytecode — a set of instructions that is independent of any particular computer architecture.
This bytecode is later interpreted or JIT-compiled by the JVM into native machine code for actual execution.

3. Need / Importance
• Enables platform independence — the same bytecode can run on any device with a JVM.
• Acts as a security layer since bytecode is verified before execution.
• Allows optimization by the JVM's Just-In-Time (JIT) compiler at runtime.
• Separates compilation (once) from execution (anywhere), enabling the WORA principle.

4. Characteristics
• Stored in .class files with a specific binary format.
• Platform-independent — does not depend on the underlying OS or hardware.
• Verified by the Bytecode Verifier for security before execution.
• Interpreted or compiled just-in-time by the JVM, not directly by the OS.

5. Advantages
• Provides true platform independence — 'Write Once, Run Anywhere'.
• Improves security since bytecode is verified for illegal operations before running.
• Enables performance optimization through JIT compilation at runtime.
• Makes Java programs compact and portable across networks.

6. Disadvantages
• Execution via bytecode interpretation can be slower than direct native machine code execution (mitigated
by JIT).
• Requires a JVM to be installed on every machine that runs the program.

7. Applications
• Used by the JVM to execute Java applications on any platform.
• Basis of Android's earlier Dalvik/ART bytecode execution model (derived from Java bytecode concepts).
• Enables Java applets and platform-independent enterprise applications.
• Used in tools that perform bytecode analysis, obfuscation, and optimization (e.g., ProGuard).
8. Real-Time Example
When you compile [Link] using javac, it produces [Link] containing bytecode. You can copy
this single .class file to a Windows PC, a Linux server, or a Mac, and run it directly with the 'java' command on
each — without recompiling the source code.

9. Diagram

[DIAGRAM] Bytecode Flow Diagram: Java Source Code (.java) → [javac compiler] → Bytecode (.class) →
[JVM on Windows / Linux / Mac] → Machine Code executed on each respective platform.

11. Syntax

// Compilation command that generates bytecode

javac [Link] // creates [Link] (bytecode)

// Execution command that runs bytecode

java ProgramName // JVM interprets/executes the bytecode

12. Java Program

public class BytecodeDemo {

public static void main(String[] args) {
[Link]("This program will be compiled into bytecode.");
}
}

13. Output

This program will be compiled into bytecode.

(Run "javac [Link]" to generate [Link],

then "java BytecodeDemo" to execute it via the JVM.)

14. Program Explanation

Running 'javac [Link]' converts this source file into '[Link]', which contains bytecode
instructions (not machine code). Running 'java BytecodeDemo' launches the JVM, which loads this .class file,
verifies its bytecode, and then interprets/JIT-compiles it to produce the printed output.

15. Summary

Summary: Bytecode is the intermediate, platform-independent output of Java compilation, stored in .class
files. It is the key enabler of Java's 'Write Once, Run Anywhere' capability, since it is executed by the JVM
rather than directly by the operating system.
9. JVM (Java Virtual Machine)

1. Definition
The Java Virtual Machine (JVM) is an abstract computing machine that provides a runtime environment to
execute Java bytecode. It converts bytecode into machine-specific instructions and manages memory, security,
and execution of Java programs.

2. Introduction
The JVM is the core component that makes Java platform-independent. Every operating system has its own
specific implementation of the JVM, but all of them can execute the same bytecode, producing the same result.
The JVM is part of the JRE (Java Runtime Environment).

3. Need / Importance
• Executes bytecode, enabling the 'Write Once, Run Anywhere' capability of Java.
• Provides automatic memory management through garbage collection.
• Ensures security by verifying bytecode before execution.
• Manages runtime resources like the stack, heap, and method area for running programs.

4. Characteristics
• Platform-dependent implementation, but executes platform-independent bytecode.
• Performs class loading, bytecode verification, and execution.
• Includes an interpreter and a Just-In-Time (JIT) compiler for optimized execution.
• Automatically manages memory using the Garbage Collector.

5. Advantages
• Provides platform independence for compiled Java programs.
• Automatic garbage collection reduces the burden of manual memory management.
• Improves security through bytecode verification and a restricted execution environment.
• JIT compilation improves performance by converting frequently used bytecode into native code.

6. Disadvantages
• Adds a layer of abstraction, which can make execution slower compared to purely native-compiled
languages.
• Consumes additional memory and CPU resources to run the virtual machine itself.
• Startup time can be slower due to class loading and verification steps.

7. Applications
• Runs all standard Java applications — desktop, web, and enterprise.
• Powers Android app execution (historically via Dalvik/ART, conceptually derived from the JVM model).
• Used by other JVM-based languages such as Kotlin, Scala, and Groovy to execute their compiled bytecode.
 • Enables server-side Java applications to run identically across different production environments.

8. Real-Time Example
A Java-based mobile banking backend can be developed on a Windows laptop, compiled once, and deployed on
Linux-based cloud servers — because each server runs its own JVM, which interprets the same bytecode
identically regardless of the underlying hardware or OS.

9. Diagram

[DIAGRAM] JVM Architecture Diagram: Boxes for Class Loader → Bytecode Verifier → Method Area /
Heap / Stack (Runtime Data Areas) → Execution Engine (Interpreter + JIT Compiler) → Native OS/Hardware.

10. Types
• Class Loader Subsystem – loads, links, and initializes class files.
• Runtime Data Area – includes Method Area, Heap, Stack, PC Registers, and Native Method Stack.
• Execution Engine – contains the Interpreter, JIT Compiler, and Garbage Collector.

11. Syntax

// The JVM is invoked implicitly using the 'java' command

java ClassName
// The JVM loads [Link], verifies it, and executes main()

12. Java Program

public class JVMDemo {

public static void main(String[] args) {
[Link]("JVM is executing this bytecode.");
Runtime runtime = [Link]();
[Link]("Available processors: " +
[Link]());
}
}

13. Output

JVM is executing this bytecode.

Available processors: 4

14. Program Explanation

When 'java JVMDemo' is run, the JVM's class loader loads [Link], the bytecode verifier checks it for
safety, and the execution engine interprets/JIT-compiles it. The Runtime class here is used to directly query
information from the JVM itself, such as the number of processors available to it. (The processor count shown
may vary by machine.)
15. Summary

Summary: The JVM is the runtime engine that loads, verifies, and executes Java bytecode. It is what makes
Java programs platform-independent, memory-managed, and secure, since it is present on every device
Java runs on.
10. JDK (Java Development Kit)

1. Definition
The JDK (Java Development Kit) is a complete software development kit required to develop, compile, debug,
and run Java applications. It includes the JRE (Java Runtime Environment), compiler (javac), debugger, and other
development tools.

2. Introduction
The JDK is the primary package a Java developer installs to start writing Java programs. It contains everything
needed for development: the compiler to convert source code into bytecode, the JVM (via JRE) to run programs,
and additional tools like javadoc, jar, and jdb for documentation, packaging, and debugging.

3. Need / Importance
• Required to write and compile Java source code into bytecode.
• Bundles the JRE, so developers can also run and test the programs they write.
• Provides essential development tools such as debuggers and documentation generators.
• Without the JDK, a machine can only run compiled Java programs (via JRE) but cannot develop new ones.

4. Characteristics
• Includes the compiler (javac) to convert .java files into .class bytecode files.
• Bundles the JRE, which itself includes the JVM and core class libraries.
• Provides development tools: javadoc (documentation), jar (packaging), jdb (debugger), jconsole
(monitoring).
• Platform-dependent — a separate JDK version exists for Windows, Linux, and Mac.

5. Advantages
• Provides a single, complete package for both development and execution of Java code.
• Includes powerful built-in tools that reduce dependency on external software.
• Regularly updated by Oracle/OpenJDK with performance and security improvements.
• Supports multiple versions (LTS releases) suited for different project needs.

6. Disadvantages
• Larger download and installation size compared to just the JRE.
• Not required on end-user machines that only need to run (not develop) Java applications — installing the
full JDK there is unnecessary overhead.
• Version mismatches between JDK versions used in development and deployment can occasionally cause
compatibility issues.

7. Applications
• Used by developers to write and compile enterprise applications, Android apps (via Android Studio, which
bundles a JDK), and web applications.
 • Used in Integrated Development Environments (IDEs) like Eclipse, IntelliJ IDEA, and NetBeans, which rely
on a configured JDK to build projects.
• Used in Continuous Integration/Continuous Deployment (CI/CD) pipelines to compile and package Java
applications.
• Essential for building any Java-based software product, from desktop tools to large-scale distributed
systems.

8. Real-Time Example
A software company's development team installs the JDK on their developer laptops to write and compile a
Java-based inventory management system. Once compiled and packaged into a .jar file, it can be deployed on
production servers that only need the smaller JRE (or a JDK, depending on setup) to run it.

9. Diagram

[DIAGRAM] JDK Structure Diagram: An outer box labelled 'JDK' containing an inner box labelled 'JRE' (which
itself contains the JVM and core libraries), alongside separate labelled tool icons for javac, javadoc, jar, and
jdb — showing JDK ⊃ JRE ⊃ JVM.

10. Types
• Oracle JDK – the official implementation provided and licensed by Oracle Corporation.
• OpenJDK – the free, open-source reference implementation of the Java Platform.
• Vendor-specific JDKs – such as Amazon Corretto, Eclipse Temurin (Adoptium), and Azul Zulu, which are
OpenJDK-based distributions.

11. Syntax

// Using JDK tools from the command line

javac [Link] // compiles source code (JDK compiler)
java ProgramName // runs the compiled bytecode (via JRE/JVM inside JDK)
javadoc [Link] // generates HTML documentation
jar cf [Link] *.class // packages class files into a JAR

12. Java Program

public class JDKDemo {

public static void main(String[] args) {
[Link]("Compiled using JDK's javac compiler.");
[Link]("Executed using JDK's bundled JRE/JVM.");
}
}

13. Output

Compiled using JDK's javac compiler.

Executed using JDK's bundled JRE/JVM.
14. Program Explanation
To produce this output, the developer first runs 'javac [Link]' (using the JDK's compiler) to generate
[Link], and then runs 'java JDKDemo' (using the JRE/JVM bundled inside the JDK) to execute it. This
shows the JDK's dual role in both compiling and running Java code during development.

15. Summary

Summary: The JDK is the complete toolkit needed to develop Java applications, bundling the compiler, the
JRE (with the JVM), and various supporting tools like javadoc and jar. It is essential for any machine used for
Java development, whereas machines only running Java applications need just the JRE.