DEV Community: Sundar Joseph

[Boost]

Sundar Joseph — Thu, 21 Aug 2025 15:51:52 +0000

Encapsulation in Java

Sundar Joseph ・ Aug 21

Encapsulation in Java

Sundar Joseph — Thu, 21 Aug 2025 15:51:32 +0000

In Java, encapsulation is one of the core concepts of Object Oriented Programming (OOP) in which we bind the data members and methods into a single unit. Encapsulation is used to hide the implementation part and show the functionality for better readability and usability. The following are important points about encapsulation.

Better Code Management:

We can change data representation and implementation any time without changing the other codes using it if we keep method parameters and return values the same. With encapsulation, we ensure that no other code would have access to implementation details and data members.

Simpler Parameter Passing:

When we pass an object to a method, everything (associated data members and methods are passed along). We do not have to pass individual members.
.

getter and setter:

getter (display the data) and setter method ( modify the data) are used to provide the functionality to access and modify the data, and the implementation of this method is hidden from the user. The user can use this method, but cannot access the data directly.

Example:

// Java program demonstrating Encapsulation
class Programmer {

private String name;

// Getter and Setter for name

// Getter method used to get the data
public String getName() { return name; }

// Setter method is used to set or modify the data
public void setName(String name) { this.name = name; }

}

public class Geeks {

public static void main(String[] args) {
    Programmer p = new Programmer();
    p.setName("Geek"); 
    System.out.println("Name=> " + p.getName());
}

}
Output:
Name=> Geek

Errors V/s Exceptions In Java:

Sundar Joseph — Mon, 11 Aug 2025 16:38:18 +0000

Java, errors and exceptions are both types of throwable objects, but they represent different types of problems that can occur during the execution of a program.

Errors are usually caused by serious problems that are outside the control of the program, such as running out of memory or a system crash. Errors are represented by the Error class and its subclasses. Some common examples of errors in Java include:

OutOfMemoryError:

Thrown when the Java Virtual Machine (JVM) runs out of memory.

StackOverflowError:

Thrown when the call stack overflows due to too many method invocations.

NoClassDefFoundError:

Thrown when a required class cannot be found. Since errors are generally caused by problems that cannot be recovered from, it's usually not appropriate for a program to catch errors. Instead, the best course of action is usually to log the error and exit the program.

Exceptions, on the other hand, are used to handle errors that can be recovered from within the program. Exceptions are represented by the Exception class and its subclasses. Some common examples of exceptions in Java include:

NullPointerException:

Thrown when a null reference is accessed.

IllegalArgumentException:

Thrown when an illegal argument is passed to a method.

IOException:

Thrown when an I/O operation fails.
Since exceptions can be caught and handled within a program, it's common to include code to catch and handle exceptions in Java programs. B
In summary, errors and exceptions represent different types of problems that can occur during program execution. Errors are usually caused by serious problems that cannot be recovered from, while exceptions are used to handle recoverable errors within a program.

In java, both Errors and Exceptions are the subclasses of java.lang.Throwable class. Error refers to an illegal operation performed by the user which results in the abnormal working of the program. Programming errors often remain undetected until the program is compiled or executed. Some of the errors inhibit the program from getting compiled or executed. Thus errors should be removed before compiling and executing. It is of three types:

Compile-time
Run-time
Logical
Whereas exceptions in java refer to an unwanted or unexpected event, which occurs during the execution of a program i.e at run time, that disrupts the normal flow of the program’s instructions.

Now let us discuss various types of errors in order to get a better understanding over arrays. As discussed in the header an error indicates serious problems that a reasonable application should not try to catch. Errors are conditions that cannot get recovered by any handling techniques. It surely causes termination of the program abnormally. Errors belong to unchecked type and mostly occur at runtime. Some of the examples of errors are Out of memory errors or System crash errors.

example runtime error:

// Java Program to Illustrate Error
// Stack overflow error via infinite recursion

// Class 1
class StackOverflow {

// method of this class
public static void test(int i)
{
    // No correct as base condition leads to
    // non-stop recursion.
    if (i == 0)
        return;
    else {
        test(i++);
    }
}

}

// Class 2
// Main class
public class GFG {

// Main driver method
public static void main(String[] args)
{
    // Testing for error by passing
    // custom integer as an argument
    StackOverflow.test(5);
}

}

example 2

// Java Program to Illustrate Run-time Errors

// Main class
class GFG {

// Main driver method
public static void main(String args[])
{

    // Declaring and initializing numbers
    int a = 2, b = 8, c = 6;

    if (a > b && a > c)
        System.out.println(a
                           + " is the largest Number");
    else if (b > a && b > c)
        System.out.println(b
                           + " is the smallest Number");

    // The correct message should have been
    // System.out.println
    // (b+" is the largest Number"); to make logic
    else
        System.out.println(c
                           + " is the largest Number");
}

}

Java Exception Handling

Sundar Joseph — Fri, 08 Aug 2025 15:37:55 +0000

Exception handling in Java is an effective mechanism for managing runtime errors to ensure the application's regular flow is maintained. Some Common examples of exceptions include ClassNotFoundException, IOException, SQLException, RemoteException, etc. By handling these exceptions, Java enables developers to create robust and fault-tolerant applications.

Example: Showing an arithmetic exception or we can say a divide by zero exception.

import java.io.*;

class Geeks {
public static void main(String[] args)
{
int n = 10;
int m = 0;

    int ans = n / m;

    System.out.println("Answer: " + ans);
}

}

Note :

When an exception occurs and is not handled, the program terminates abruptly and the code after it, will never execute.

example:

The below Java program modifies the previous example to handle an ArithmeticException using try-catch and finally blocks and keeps the program running.

import java.io.*;

class Geeks {
public static void main(String[] args)
{
int n = 10;
int m = 0;

    try {

        // Code that may throw an exception
        int ans = n / m;
        System.out.println("Answer: " + ans);
    }
    catch (ArithmeticException e) {

        // Handling the exception
        System.out.println(
            "Error: Division by zero is not allowed!");
    }
    finally {
        System.out.println(
            "Program continues after handling the exception.");
    }
}

}

output:

Error: Division by zero is not allowed!
Program continues after handling the exception.

Java Exception Hierarchy:

Java, all exceptions and errors are subclasses of the Throwable class. It has two main branches

Exception.
Error
The below figure demonstrates the exception hierarchy in Java:

Exception Hierarchy in Java
Heirarchy of

Major Reasons Why an Exception Occurs.
Exceptions can occur due to several reasons, such as:

Invalid user input
Device failure
Loss of network connection
Physical limitations (out-of-disk memory)
Code errors
Out of bound
Null reference
Type mismatch
Opening an unavailable file
Database errors
Arithmetic errors
Errors are usually beyond the control of the programmer and we should not try to handle errors.

Nested try-catch:

In Java, you can place one try-catch block inside another to handle exceptions at multiple levels.
public class NestedTryExample {
public static void main(String[] args) {
try {
System.out.println("Outer try block");
try {
int a = 10 / 0; // This causes ArithmeticException
} catch (ArithmeticException e) {
System.out.println("Inner catch: " + e);
}
String str = null;
System.out.println(str.length()); // This causes NullPointerException
} catch (NullPointerException e) {
System.out.println("Outer catch: " + e);
}
}
}

[Boost]

Sundar Joseph — Tue, 05 Aug 2025 16:31:35 +0000

Static vs Dynamic Binding in Java

Sundar Joseph ・ Aug 5

#webdev #java #beginners #tutorial

[Boost]

Sundar Joseph — Tue, 05 Aug 2025 16:31:35 +0000

Sundar Joseph

Aug 5 '25

Static vs Dynamic Binding in Java

#webdev #java #beginners #tutorial

Comments

2 min read

Static vs Dynamic Binding in Java

Sundar Joseph — Tue, 05 Aug 2025 16:31:22 +0000

There are certain key points that are needed to be remembered before adhering forward where we will be discussing and implementing static and dynamic bindings in Java later concluding out the differences.

private, final and static members (methods and variables) use static binding while for virtual methods (In Java methods are virtual by default) binding is done during run time based upon the run time object.
The static binding uses Type information for binding while Dynamic binding uses Objects to resolve to bind.
Overloaded methods are resolved (deciding which method to be called when there are multiple methods with the same name) using static binding while overridden methods use dynamic binding, i.e, at run time.

Static Binding :

The binding which can be resolved at compile time by the compiler is known as static or early binding. The binding of all the static, private, and final methods is done at compile-time.

example:

// Java Program to Illustrate Static Binding

// Main class
class NewClass {

// Static nested inner class
// Class 1
public static class superclass {

    // Method of inner class
    static void print()
    {

        // Print statement
        System.out.println(
            "print() in superclass is called");
    }
}

// Static nested inner class
// Class 2
public static class subclass extends superclass {

    // Method of inner class
    static void print()
    {

        // print statement
        System.out.println(
            "print() in subclass is called");
    }
}

// Method of main class
// Main driver method
public static void main(String[] args)
{

    // Creating objects of static inner classes
    // inside main() method
    superclass A = new superclass();
    superclass B = new subclass();

    // Calling method over above objects
    A.print();
    B.print();
}

}

Output:

print() in superclass is called
print() in superclass is called

Dynamic Binding:

In Dynamic binding compiler doesn't decide the method to be called. Overriding is a perfect example of dynamic binding. In overriding both parent and child classes have the same method

example :

// Java Program to Illustrate Dynamic Binding

// Main class
public class GFG {

// Static nested inner class
// Class 1
public static class superclass {

    // Method of inner class 1
    void print()
    {

        // Print statement
        System.out.println(
            "print in superclass is called");
    }
}

// Static nested inner class
// Class 2
public static class subclass extends superclass {

    // Method of inner class 2
    @Override void print()
    {

        // Print statement
        System.out.println(
            "print in subclass is called");
    }
}

// Method inside main class
public static void main(String[] args)
{

    // Creating object of inner class 1
    // with reference to constructor of super class
    superclass A = new superclass();

    // Creating object of inner class 1
    // with reference to constructor of sub class
    superclass B = new subclass();

    // Calling print() method over above objects
    A.print();
    B.print();
}

}

output:

print in superclass is called
print in subclass is called

Java encapsulation:

Sundar Joseph — Sun, 03 Aug 2025 17:15:09 +0000

Encapsulation in Java is a core object-oriented programming (OOP) concept that involves bundling data (variables) and the methods that operate on that data into a single unit, typically a class. It is primarily used to achieve data hiding and control access to the internal state of an object.

Here's how it's typically implemented:

Declaring fields as private:

The data members (instance variables) of a class are declared with the private access modifier. This prevents direct external access to these variables from outside the class, safeguarding their integrity.
Providing public getter and setter methods:
Public methods, known as "getter" and "setter" methods, are provided to allow controlled access to the private data.
Getter methods: (e.g., getName(), getAge()) are used to retrieve the values of the private fields.
Setter methods: (e.g., setName(String name), setAge(int age)) are used to modify the values of the private fields. These methods can include validation logic to ensure data consistency and prevent invalid values from being assigned.

Benefits of Encapsulation:

Data Hiding:
Protects the internal state of an object from unauthorized or accidental modification by external code.
Modularity and Flexibility:
Allows for changes to the internal implementation of a class without affecting external code that uses the class, as long as the public interface (getter/setter methods) remains consistent.
Improved Maintainability:
Centralizes the logic for accessing and modifying data within the class itself, making the code easier to understand, debug, and maintain.
Enhanced Security:
Provides a controlled mechanism for data access, allowing for validation and error handling before data is modified.

example :

public class Person {
private String name; // Private field
private int age; // Private field

// Public getter for name
public String getName() {
    return name;
}

// Public setter for name
public void setName(String name) {
    this.name = name;
}

// Public getter for age
public int getAge() {
    return age;
}

// Public setter for age with validation
public void setAge(int age) {
    if (age > 0) { // Basic validation
        this.age = age;
    } else {
        System.out.println("Age must be positive.");
    }
}

}

Abstraction in Java

Sundar Joseph — Tue, 29 Jul 2025 16:44:10 +0000

Abstraction in Java is the process of hiding internal implementation details and showing only essential functionality to the user. It focuses on what an object does rather than how it does it.

Key features of abstraction:

Abstraction hides the complex details and shows only essential features.
Abstract classes may have methods without implementation and must be implemented by subclasses.
By abstracting functionality, changes in the implementation do not affect the code that depends on the abstraction.

How to Achieve Abstraction in Java?

Java provides two ways to implement abstraction, which are listed below:

Abstract Classes (Partial Abstraction)
Interface (100% Abstraction)

Real-Life Example of Abstraction
The television remote control is the best example of abstraction. It simplifies the interaction with a TV by hiding all the complex technology. We don't need to understand how the tv internally works, we just need to press the button to change the channel or adjust the volume.

example :

// Working of Abstraction in Java
abstract class Geeks {
abstract void turnOn();
abstract void turnOff();
}

// Concrete class implementing the abstract methods
class TVRemote extends Geeks {
@override
void turnOn() {
System.out.println("TV is turned ON.");
}

@Override
void turnOff() {
    System.out.println("TV is turned OFF.");
}

}

// Main class to demonstrate abstraction
public class Main {
public static void main(String[] args) {
Geeks remote = new TVRemote();
remote.turnOn();

remote.turnOff();

}
}

output :

TV is turned ON.
TV is turned OFF.

Explanation :

Geeks is abstract class defining turnOn() and turnOff() methods.
TVRemote class implements the abstract methods with specific logic.
Main class uses Geeks remote = new TVRemote(); to interact without knowing the internal implementation

Abstract class :

abstract class is a way to achieve abstraction in Java. It is declared using the abstract keyword and can contain both abstract methods non abstract methods. Abstract classes cannot be instantiated directly and are meant to be extended by subclasses. Besides abstraction, abstract classes also allow code reusability through shared behavior and state.

Java OOP(Object Oriented Programming) Concepts :

Sundar Joseph — Mon, 28 Jul 2025 15:55:37 +0000

Java Object-Oriented Programming (OOPs) is a fundamental concept in Java that every developer must understand. It allows developers to structure code using classes and objects, making it more modular, reusable, and scalable.

The core idea of OOPs is to bind data and the functions that operate on it, preventing unauthorized access from other parts of the code. Java strictly follows the DRY (Don't Repeat Yourself) Principle, ensuring that common logic is written once (e.g., in parent classes or utility methods) and reused throughout the application. This makes the code:

What is OOPs and Why Do We Use it?
OOPS stands for Object-Oriented Programming System. It is a programming approach that organizes code into objects and classes and makes it more structured and easy to manage. A class is a blueprint that defines properties and behaviors, while an object is an instance of a class representing real-world entities.

example :

// Use of Object and Classes in Java
import java.io.*;

class Numbers {
// Properties
private int a;
private int b;

// Setter methods
public void setA(int a) { this.a = a; }
public void setB(int b) { this.b = b; }

// Methods
public void sum() { System.out.println(a + b); }
public void sub() { System.out.println(a - b); }

public static void main(String[] args)
{
    Numbers obj = new Numbers();

    // Using setters instead of direct access
    obj.setA(1);
    obj.setB(2);

    obj.sum();
    obj.sub();
}

}

Output :

3
-1

Java Class :

A Class is a user-defined blueprint or prototype from which objects are created. It represents the set of properties or methods that are common to all objects of one type. Using classes, you can create multiple objects with the same behavior instead of writing their code multiple times. This includes classes for objects occurring more than once in your code. In general, class declarations can include these components in order:

Java Object :

An Object is a basic unit of Object-Oriented Programming that represents real-life entities. A typical Java program creates many objects, which as you know, interact by invoking methods. The objects are what perform your code, they are the part of your code visible to the viewer/user. An object mainly consists of:

Inheritance in Java ;

Sundar Joseph — Sat, 26 Jul 2025 11:13:19 +0000

Java Inheritance is a fundamental concept in OOP(Object-Oriented Programming). It is the mechanism in Java by which one class is allowed to inherit the features(fields and methods) of another class. In Java, Inheritance means creating new classes based on existing ones. A class that inherits from another class can reuse the methods and fields of that class. In addition, you can add new fields and methods to your current class as well.

Syntax ;

class ChildClass extends ParentClass {

// Additional fields and methods

}

Why Use Inheritance in Java? ;

Code Reusability: The code written in the Superclass is common to all subclasses. Child classes can directly use the parent class code.
Method Overriding: Method Overriding is achievable only through Inheritance. It is one of the ways by which Java achieves Run Time Polymorphism.
Abstraction: The concept of abstraction where we do not have to provide all details, is achieved through inheritance. Abstraction only shows the functionality to the user.

Key Terminologies Used in Java Inheritance ;

Class: Class is a set of objects that share common characteristics/ behavior and common properties/ attributes. Class is not a real-world entity. It is just a template or blueprint or prototype from which objects are created.
Super Class/Parent Class: The class whose features are inherited is known as a superclass(or a base class or a parent class).
Sub Class/Child Class: The class that inherits the other class is known as a subclass(or a derived class, extended class or child class). The subclass can add its own fields and methods in addition to the superclass fields and methods.
Extends Keyword: This keyword is used to inherit properties from a superclass.

How Inheritance Works in Java? ;

The extends keyword is used for inheritance in Java. It enables the subclass to inherit the fields and methods of the superclass. When a class extends another class, it means it inherits all the non-primitive members (fields and methods) of the parent class and the subclass can also override or add new functionality to them.

Note: The extends keyword establishes an "is-a" relationship between the child class and the parent class. This allows a child class to have all the behavior of the parent class.

example ;

In the following example, Animal is the base class and Dog, Cat and Cow are derived classes that extend the Animal class.
inheritance-660x454

Implementation:

// Parent class

class Animal {

void sound() {

    System.out.println("Animal makes a sound");

}

}

// Child class

class Dog extends Animal {

void sound() {

    System.out.println("Dog barks");

}

}

// Child class

class Cat extends Animal {

void sound() {

    System.out.println("Cat meows");

}

}

// Child class

class Cow extends Animal {

void sound() {

    System.out.println("Cow moos");

}

}

// Main class

public class Geeks {

public static void main(String[] args) {

    Animal a;

    a = new Dog();

    a.sound();  // Output: Dog barks

    a = new Cat();

    a.sound();  // Output: Cat meows

    a = new Cow();

    a.sound();  // Output: Cow moos

}

}

Output

Dog barks
Cat meows
Cow moos

[Boost]

Sundar Joseph — Fri, 25 Jul 2025 15:47:32 +0000

Overriding in Java

Sundar Joseph ・ Jul 25

#webdev #java #beginners #devops