DEV Community: Divya Divya

why objects are passed as arguments in java

Divya Divya — Fri, 29 May 2026 07:51:43 +0000

Objects are passed as arguments in Java to send related data to a method together.It helps reduce passing many separate variables.A method can access object properties using the object reference.It makes the code cleaner and easier to manage.Objects are commonly used for real-world entities like Student, Car, or Employee.In Java, the reference of the object is passed to the method.

Throws
throws is a keyword in Java that is used in the signature of a method to indicate that this method might throw one of the listed type exceptions. The caller to these methods has to handle the exception using a try-catch block.

Declares possible exceptions.
Mainly used with checked exceptions.

Syntax
returnType methodName() throws ExceptionName


class Test {

    static void checkAge(int age) throws Exception {
        if (age < 18) {
            throw new Exception("Not Eligible");
        } else {
            System.out.println("Eligible");
        }
    }

    public static void main(String[] args) {
        try {
            checkAge(15);
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
}

Dynamic Binding in Java?

Divya Divya — Fri, 22 May 2026 16:12:50 +0000

Dynamic binding refers to the process in which linking between method call and method implementation is resolved at run time (or, a process of calling an overridden method at run time).
Dynamic binding is also known as run-time polymorphism or late binding. Dynamic binding uses objects to resolve binding.

Characteristic of Dynamic binding:

Linking − Linking between method call and method implementation is resolved at run time.

Resolve mechanism − Dynamic binding uses object type to resolve binding.

Example − Method overriding is the example of Dynamic binding.

Type of Methods − Virtual methods use dynamic binding.
package com.tutorialspoint;

Example


class Animal {
   public void move() {
      System.out.println("Animals can move");
   }
}

class Dog extends Animal {
   public void move() {
      System.out.println("Dogs can walk and run");
   }
}

public class Tester {

   public static void main(String args[]) {
      Animal a = new Animal();   // Animal reference and object
      // Dynamic Binding      
      Animal b = new Dog();   // Animal reference but Dog object

      a.move();   // runs the method in Animal class
      b.move();   // runs the method in Dog class
   }
}

Exception in java

Divya Divya — Fri, 22 May 2026 16:11:11 +0000

Exception is an Even.
Exceptions are used to detect and handle errors during program execution so the program can continue safely.

Example

package practice;

public class Home {
     static int a=10;
    static int b=0;

    public static void main(String[] args) {
        System.out.println(a/b);
    }
}

Output

Variable a is store value
Variable b is store value and then java tries to calculate.
but, 10/0 division by zero is impossible because 10/0 is Infinity. So, Java throw an exception.

Why Exception are used?
Exceptions are used in Java to handle errors safely without stopping the entire program suddenly.

Prevent program crashes
Handle runtime errors safely
Maintain normal program flow
Show meaningful error messages

Two types of Exception

Checked Exception
Unchecked Exception

String in java?

Divya Divya — Tue, 19 May 2026 13:22:22 +0000

String:

String is a sequence of character used to store text.
String is class in Java.
String package name of Java.lan.
String are immutable(create once , cannot modified).
length is one of the String method.

Two way of creating String:

1. Literal String

A literal means writing the value directly inside quotes.
Reuses existing object if same value exists.It's Stored in String Pool.Memory efficient.

Example

string s="abc";

2.Using new keyword

newkeyword is used to create a new object manually.
Creates a new object every time.It's Stored in Heap memory.Uses more Memory.

Example

String str=new string("xyz");

Interface in java?

Divya Divya — Thu, 14 May 2026 11:33:24 +0000

Interface
An interface in Java is a blueprint of a class.
It contains methods that a class must implement.

Interface mainly helps to achieve:

Abstraction → hiding implementation details
Multiple inheritance → one class can implement multiple interfaces.

A class uses the implements keyword to implement an interface.
All methods inside an interface are public and abstract by default.
Variables inside an interface are automatically:

public
static
final

Syntax

interface Animal {

    void sound();   // abstract method
}

Abstract in Java?

Divya Divya — Thu, 14 May 2026 03:25:37 +0000

Java Abstract Class

An abstract class in Java is a class declared with the abstract keyword.
It is used to achieve abstraction, which means hiding implementation details and showing only essential functionality.

Key Features of Abstract Class

Cannot create objects directly
Can contain abstract methods and normal methods
Must be inherited by another class
Used as a base class

Syntax

abstract class ClassName {

}

Main Method

Car c = new Car();

Creates object for child class, not abstract class.

Important point

Vehicle v = new Vehicle();

Because abstract class objects cannot be created.

Abstract Method in Java

An abstract method is a method declared without a body.
It contains only the method declaration, and the implementation is provided by the subclass.

Syntax

abstract void sound();

No method body
Ends with semicolon ;

Important points:

Abstract methods can only be inside an abstract class
Child class must implement the abstract method
Used to achieve abstraction.

Rule

If a class contains an abstract method, the class must be abstract.

abstract class Animal {

    abstract void sound();
}

What is Final Keyword In Java?

Divya Divya — Wed, 13 May 2026 05:37:21 +0000

In Java, the final keyword is used to restrict changes and make code more secure and predictable.
It can be applied to variables, methods, and classes to prevent modification, overriding, or inheritance.
This helps in creating constant values, stable methods, and immutable classes.

Final variable: cannot be changed once assigned

Example

class Geeks {
    public static void main(String[] args) {
        final int i;
        i = 20;
        System.out.println(i);
    }
}

Final method: cannot be overridden

Example

class A {
    final void m1() {
        System.out.println("Final method");
    }
}

class B extends A {
    void m1() { } // compile-time error
}

Final class: cannot be inherited.

Example

final class A {
    // fields and methods
}

// Illegal
class B extends A { }

What is Final Keyword?

Divya Divya — Wed, 13 May 2026 05:33:12 +0000

Final variable: cannot be changed once assigned

Example

class Geeks {
    public static void main(String[] args) {
        final int i;
        i = 20;
        System.out.println(i);
    }
}

Final method: cannot be overridden

Example

class A {
    final void m1() {
        System.out.println("Final method");
    }
}

class B extends A {
    void m1() { } // compile-time error
}

Final class: cannot be inherited.

Example

final class A {
    // fields and methods
}

// Illegal
class B extends A { }

What is POJO in Java?

Divya Divya — Tue, 12 May 2026 04:59:18 +0000

POJO(Plain Old Java Object:

A Java Programming POJO (Plain Old Java Object) is a simple normal Java class that is not connected to any special framework or restriction.Is not dependent on frameworks like EJB.
It does not need special classes, interfaces, or dependencies.
A POJO usually contains fields, constructors, getters, setters, and normal methods.

Why is POJO?

POJO is used to create simple Java classes.
It makes code easy to write and understand.
It helps to store object data like name, age, id, etc.
It improves code reusability.
It is easy to test and maintain.

Example:

class Student {
    private String name;
    private int age;

    // Constructor
    Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Getter
    public String getName() {
        return name;
    }

    // Setter
    public void setName(String name) {
        this.name = name;
    }

    public static void main(String[] args) {

        Student s1 = new Student("Divya", 20);

        System.out.println(s1.getName());
    }
}

Output

Method Overriding in Java

Divya Divya — Tue, 05 May 2026 18:49:44 +0000

When a subclass provides a specific implementation for a method that is already defined in its parent class, it is called method overriding. The overridden method in the subclass must have the same name, parameters, and return type as the method in the parent class.

Rules for Method Overriding

Name, parameters, and return type must match the parent method.
Java picks which method to run at run time, based on the actual object type, not just the reference variable type.
Static methods cannot be overridden.

Usage of Java Method Overriding

Method overriding is used for achieving run-time polymorphism.
Method overriding is used for writing specific definition of a subclass method (this method is known as the overridden method).

class Animal {

    void move(){
        System.out.println(
      "Animal is moving."); 

    }
    void eat(){

        System.out.println(
      "Animal is eating."); 

    }
}

class Dog extends Animal{

    @Override void move(){ 

      // move method from Base class is overriden in this
      // method
        System.out.println("Dog is running.");
    }
    void bark(){

        System.out.println("Dog is barking."); 

    }
}

public class Geeks {
    public static void main(String[] args)
    {
        Dog d = new Dog();
        d.move(); 
        d.eat(); 
        d.bark();
    }
}

To be discused
Output

Access Modifiers in Java

Divya Divya — Mon, 04 May 2026 18:15:00 +0000

Every Java developer writes classes, methods, and fields. But who should be allowed to use them? Access modifiers answer exactly that — they control visibility, enforce encapsulation, and form the foundation of clean API design.

Java has four:

Default (Package-private)
Private
Protected
Public

Let's break each one down.

Default Access Modifier

If no access modifier is specified, the member has default (package-private) access and can only be accessed within the same package.This means only classes within the same package can access it.
Example

class Car {
    String model; // default access
}

public class Main {

    public static void main(String[] args){

        Car c = new Car();
        c.model = "Tesla"; // accessible within the same package
        System.out.println(c.model);
    }
}

Output

Private Access Modifier

The private access modifier is specified using the keyword private. The methods or data members declared as private are accessible only within the class in which they are declared.

Example

class Person {

    // private variable
    private String name;

    public void setName(String name)  {

        this.name = name; // accessible within class
    }

    public String getName() { return name; }
}

public class Geeks {
    public static void main(String[] args)
    {

        Person p = new Person();
        p.setName("Alice");

        // System.out.println(p.name); // Error: 'name'
        // has private access
        System.out.println(p.getName());
    }
}

Output

Protected Access Modifier

The protected access modifier is specified using the keyword protected. The methods or data members declared as protected are accessible within the same package or subclasses in different packages.

Example

// File: Vehicle.java in package p1
package p1;
public class Vehicle {
    protected int speed;
}

// File: Bike.java in package p2
package p2;
import p1.Vehicle;
public class Bike extends Vehicle {
    void showSpeed() {
        speed = 100; // allowed: subclass in different package
        System.out.println(speed);
    }
}

// File: Test.java in package p2
package p2;
import p1.Vehicle;
public class Test {
    public static void main(String[] args) {
        Bike b = new Bike();
        b.showSpeed(); // prints 100

        Vehicle v = new Vehicle();
        // System.out.println(v.speed); // ERROR: cannot access protected outside package & non-subclass
    }
}

Output

Public Access Modifier

The public access modifier is specified using the keyword public. Public members are accessible from everywhere in the program. There is no restriction on the scope of public data members.

Example

class MathUtils { 

    public static int add(int a, int b) {
        return a + b;
    }
}

public class Main {

    public static void main(String[] args) {

        System.out.println(MathUtils.add(5, 10)); // accessible anywhere
    }
}

Output

Private:
The idea should be use as restrictive access as possible, so private should be used as much as possible.
Default (Package-Private):
Often used in package-scoped utilities or helper classes.
Protected:
Commonly used in inheritance-based designs like framework extensions.
Public:
This is used for API endpoints, service classes, or utility methods shared across different parts of an application.

What is package in java

Divya Divya — Mon, 04 May 2026 17:35:51 +0000

Java Package is used to group related classes .

avoiding name conflicts: (two classes with the same name can exist in different packages).
Reusability: packaged code can be imported and used anywhere. Packages are divided into two categories;

Build in packages(Packages from the java API
User-defined Packages (create your own packages)

Build in Package:
Built-in Packages comprise a large number of classes that are part of the Java API. Some of the commonly used built-in packages are:

java.lang: Contains language support classes
java.io: Contains classes for supporting input/output operations.
java.util: Contains utility classes that implement data structures such as Linked Lists and Dictionaries, as well as support for date and time operations.
java.applet: Contains classes for creating Applets.
java.awt: Contains classes for implementing the components for graphical user interfaces (like buttons, menus, etc). 6)

Example: Using java.util.Random (Built-in Package)

import java.util.Random;   // built-in package

public class GFG{

    public static void main(String[] args) {

        // using Random class
        Random rand = new Random();   

        // generates a number between 0–99
        int number = rand.nextInt(100);  

        System.out.println("Random number: " + number);
    }
}

Output

User-defined Packages

User-defined Packages are the packages that are defined by the user.

Example:

package com.myapp;

public class Helper {
    public static void show() {
        System.out.println("Hello from Helper!");
    }
}

To use it in another class:

import com.myapp.Helper;

public class Test {
    public static void main(String[] args) {
        Helper.show();
    }
}