Unit Two - Java Architecture and OOPS

flutterjunction.co
Unit 2
Java Architecture and OOPS

flutterjunction.co
flutterjunction.co
m
flutterjunction.com

flutterjunction.co
Java Architecture
Java is based on the concept of Write Once, Run Anywhere (WORA). The architecture
allows Java programs to run on any device that has a Java Virtual Machine (JVM).
Java architecture defines how the Java platform works, from writing code to executing it.
It includes:
● Java Language – The programming language you write code in.
● Java Compiler (javac) – Converts .java files into bytecode .class files.
● Java Virtual Machine (JVM) – Executes the bytecode.
● Java Runtime Environment (JRE) – Contains JVM + libraries to run Java applications.
● Java Development Kit (JDK) – Includes JRE + development tools (compiler, debugger,
etc.).

flutterjunction.co
⚙️Main Components of Java Architecture
a) Java Source Code (.java)
● Written by the developer.
● Contains classes, methods, and logic.
a) Java Compiler (javac)
● Converts .java files into bytecode (.class files).
● Ensures code syntax is correct.

flutterjunction.co
c) Bytecode
● Intermediate code.
● Platform-independent.
● Understood by the Java Virtual Machine (JVM).
d) Java Virtual Machine (JVM)
● Executes the bytecode (.class files).
● Manages memory, security, garbage collection, and execution.
● JVM is Platform-Dependent but provides platform independence

flutterjunction.co
e) Java Runtime Environment (JRE)
● Contains JVM + libraries.
● Required to run Java applications.
● JRE = JVM + Libraries
● Like a playground for Java programs
f) Java Development Kit (JDK)
● Contains JRE + tools (e.g., compiler, debugger).
● Required to develop and run Java applications.
● JDK = JRE + Tools(compiler, debugger)
● JDK is Platform-Dependent

flutterjunction.co
📦 What Happens Internally?
public class Hello {
public static void main(String[] args) {
Message msg = new Message();
msg.sayHello(); }
}
class Message {
public void sayHello() {
System.out.println("Hello from Java!");
}
}

flutterjunction.co
1. Compilation
● javac Hello.java generates:
○ Hello.class
○ Message.class
2. Class Loading
● The Class Loader loads Hello.class into JVM memory.
● When it encounters new Message(), it loads Message.class.

flutterjunction.co
3. Linking Steps
a) Verification
○ JVM checks if Message.class is valid bytecode.
○ Ensures no illegal bytecode instructions are present.
b) Preparation
○ JVM allocates memory for static variables.
c) Resolution
○ The call msg.sayHello() refers to Message.sayHello() method.
○ JVM resolves this symbolic reference to an actual method location in memory.

flutterjunction.co
4. Execution
● The method sayHello() is executed.

flutterjunction.co
Class
● A class is a blueprint for creating objects.
● It defines the attributes (fields) and behaviors (methods).
class Car {
String color;
void drive() {
System.out.println("Driving...");
}
}

flutterjunction.co
Object
● An object is an instance of a class.
● It represents a real-world entity.
● Created using the new keyword.
● Can be tangible (car, animal etc) or intangible (banking system)
Car myCar = new Car();
myCar.drive();

flutterjunction.co
Class Methods
● Belongs to the class, not objects.
● Declared using the static keyword.
● Can be called without creating an object.
● Useful for utility functions.
class MathUtils {
static int square(int x) {
return x * x;
}
}
MathUtils.square(5); // 25

flutterjunction.co
Instance Methods
● Belongs to an object.
● Can access instance variables and methods.
● Requires an object to call.
class Person {
String name;
void sayHello() {
System.out.println("Hello " + name);
}
}
// Access Person As
Person p = new Person();
p.name = "Alice";
p.sayHello();

flutterjunction.co
Inheritance
● One class inherits properties of another.
● Promotes code reusability.
● Reduces redundancy.
● Use the extends keyword.
● Represents Java IS-A type of Relationship i.e parent child relationship
class Animal {
void sound() {
System.out.println("Animal sound");
}
}
class Dog extends Animal {
void bark() {
System.out.println("Dog barks");
}
}

flutterjunction.co
Types of Inheritance
1. Single Inheritance
2. Multilevel Inheritance
3. Hierarchical Inheritance
4. Multiple Inheritance
5. Hybrid Inheritance

flutterjunction.co
Single Inheritance
● One child class inherits from one parent class.
● Simplest form of inheritance.
● Promotes code reusability and clarity.
● Example: Dog inherits from Animal.

flutterjunction.co
Multilevel Inheritance
● A class inherits from a child class which in turn inherits from another
parent class.
● Forms a chain of inheritance.
● Animal → Mammal → Dog

flutterjunction.co
Hierarchical Inheritance
● Multiple child classes inherit from a single parent class.
● Common features of the parent are shared with all child classes.
● Example: Dog, Cat, and Cow all inherit from Animal.

flutterjunction.co
Multiple Inheritance
● A single class inherits from two or more parent classes.
● Can lead to ambiguity if parents have methods with the same name
(handled differently in each language).
● Example: FlyingCar inherits from both Car and Aeroplane.

flutterjunction.co
Hybrid Inheritance
● A combination of two or more types of inheritance.
● Can involve multiple and hierarchical inheritance together.
● Needs careful design to avoid complexity and ambiguity.
● In Java, we can achieve hybrid inheritance only through Interfaces

flutterjunction.co
Polymorphism
● Ability to take many forms.
● Improves flexibility and reusability.
● Enables dynamic method binding.
Types
1. Method Overloading (Compile-Time Polymorphism)
2. Method Overriding (Run-Time Polymorphism)

flutterjunction.co
Method Overloading
● Same method name, different parameters.
● Resolved at compile-time.
● Java determines which method to call based on the arguments passed to it.
class Calc {
public void add(int a, int b) {
System.out.println("Sum Int" + (a+b));
}
public void add(double a, double b) {
System.out.println("Sum doubles: " + (a+b));
}
}
public class Main {
Calc calc = new Calc();
calc.add(5, 10);
calc.add(5.5, 10.5);
}
}

flutterjunction.co
Method Overriding
● Occurs when a subclass has a method with the same name and
signature as a method in its superclass.
● Subclass can override the method to provide its own implementation.
● Method that gets called is determined at runtime based on the object
that the method is called on.

flutterjunction.co
Method Overriding Example
class Animal {
public void makeSound() {
System.out.println("Animal Sound");
}
}
class Dog extends Animal {
@Override
System.out.println("Bark");
}
}
class Cat extends Animal {
@Override
System.out.println("Meow");
}
}

flutterjunction.co
Method Overriding Example
public class Main {
Animal animal=new Animal();
Animal animal1 = new Dog();
Animal animal2 = new Cat();
animal.makeSound();
animal1.makeSound();
animal2.makeSound();
}
}

flutterjunction.co
Interface
● Interface is a contract: it defines what a class must do, but not how.
● All methods are abstract by default (Java 8+ allows default/static methods).
● Supports multiple inheritance and abstraction.
● Helps in achieving loose coupling.
interface Animal {
void makeSound();
}
class Dog implements Animal {
System.out.println("Bark");
}
}

flutterjunction.co
Abstract Class
● A class that cannot be instantiated.
● Can contain both abstract and concrete methods.
● Used to provide common base functionality.
● Use abstract keyword.
abstract class Shape {
abstract void draw();
void display() {
System.out.println("Shape");
}
}
class Circle extends Shape {
void draw() {
System.out.println("Drawing Circle");
}
}

flutterjunction.co
Thank You !!!

Unit Two - Java Architecture and OOPS

More Related Content

What's hot

Similar to Unit Two - Java Architecture and OOPS

More from Nabin Dhakal

Recently uploaded

Unit Two - Java Architecture and OOPS

Editor's Notes