DEV Community: Sakthi S

Java Packages?

Sakthi S — Tue, 21 Apr 2026 06:33:40 +0000

Packages

A packages in java is used to group related classes.Think of it as a folder in a file directory.And to write a better maintainable code.
Providing access control using public, protected, and default access.
It Avoiding name conflicts (two classes with the some name can exist in different packages).

Packages are divided into two categories:

Built-in packages
(packages from the Java API)
User-defined Packages
(create your own packages)

Built-in packages

The Java API is a library of prewritten classes, that are free to use, included in the Java Development Environment.
The library contains components for managing input, database programming, and much much more.
The library is divided into packages and classes. Meaning you can either import a single class (along with its methods and attributes), or a whole package that contain all the classes that belong to the specified package.

Syntax:

import package.name.Class;   // Import a single class
import package.name.*;   // Import the whole package

User-defined Packages

User-defined packages are those packages that are designed or created by the developer to categorize classes and packages.
It can be imported into other classes and used in the same way as we use built-in packages.
But if we omit the package statement, the class names are put into the default package, which has no name.

Syntax:

package package-name;

What is Constructor in java?

Sakthi S — Fri, 17 Apr 2026 18:08:28 +0000

Constructor

In Java, a constructor is a block of codes similar to the method. It is called when an Object of the class is created.
It is a special type of method which is used to initialize the object.

Rule of Constructor

There are two rules defined for the constructor.

The Constructor has the same name as the class.
A Constructor must have no explicit return type.
The constructor is called automatically every time you make an object.

Syntax

class Classname{
    Classname(){
        // constructor body
    }
}

Example

class Student {

    // Constructor
    public Student() {
       System.out.println("Constructor");
    }

    public static void main(String[] args) {
        System.out.println("Method");

        Student s1 = new Student();

    }
}

Difference between static and non-static in java?

Sakthi S — Thu, 16 Apr 2026 18:22:36 +0000

Static

A static member (variable or method) belongs to the class itself, not to individual objects.
A static method in Java is associated with the class, not with any object or instance.
It can be accessed by all instances of the class, but it does not rely on any specific instance.
Static methods can access static variables directly without the need for an object.

Non-Static (Instance)

An instance method belongs to an object of a class and requires an instance to be called. It can access and modify the object’s instance variables and can also call other instance or static methods.
Can access and modify instance variables (object state).
Can accept parameters and return a value.
Can call other instance methods or static methods.
Supports encapsulation and object-oriented design.
Follows the divide-and-conquer principle in larger applications.

What is a Server?

Sakthi S — Wed, 15 Apr 2026 16:43:02 +0000

Server

The term "server" comes from the world of computing and refers to a piece of computer software or hardware that offers its services to other devices or programs, referred to as "clients."
Servers provide a wide variety of services, including the execution of calculations and the distribution of resources and data to several clients at the same time.
The size of the organization's network, the storage capacity, the accessibility needs, the number of users, and other factors, among others, can all influence the formation of a server that will control many different functions on the network.

Types of Servers

Mail Server − A server that administers and regulates the distribution of emails within an organization is known as a mail server. It is responsible for both receiving and sending emails on time.
Printer Server − The printing done by users is managed by a Print server, which also synchronizes all connected printers.
FTP Server − Files may be moved more quickly and easily with the assistance of an FTP server, which also serves as a repository for the files.
*Web Server *− Interaction and accessibility with the material on the web are both governed by what is known as a web server.
File Server − It is the responsibility of a file server to store all of the user files and network data files.
Database Server − A database server is responsible for managing many databases.
Single Server − In addition, a single server has the capability of managing a multitude of functions simultaneously, given that the hardware conditions are adequate to match the requirements of the network.

History of Java?

Sakthi S — Sat, 11 Apr 2026 18:28:30 +0000

Java

Java was initiated in 1991 by James Gosling at Sun Microsystems (the "Green Team") to develop a platform-independent language for embedded devices.
Originally named Oak, it was renamed Java in 1995
After exploring C++ (which proved too heavy and too closely tied to platform dependencies), the team embarked on an entirely new project codenamed the “Green Project”.
From the outset Java was built around key design goals: robustness, portability, platform independence, high performance, and multithreading.
Over the years the Java Class Library expanded from only a few hundred classes to thousands and the platform grew to support
enterprise, mobile, and cloud applications.

What is Java Programming?

Sakthi S — Fri, 10 Apr 2026 15:47:48 +0000

Java

Java is a high-level, Object-oriented programming language developed by James Gosling at Sun Microsystems (now owned by Oracle Corporation).
Java programming is the use of the Java language to create software applications. It’s one of the most widely used programming languages in the world.

Where is Java Used?
Java is used to build many types of applications:

Mobile apps (especially Android apps)
Web applications
Desktop software
Enterprise systems (banking, e-commerce)
Games and backend systems

Example
When we learn any programming language, the first step is writing a simple program to display "Hello World". So, here is a simple Java program that displays "Hello World" on the screen.

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

Output

Hello World!

What is Method Overloading in Java?

Sakthi S — Wed, 08 Apr 2026 18:14:48 +0000

Method Overloading

In java is a feature that allows a class to have multiple methods with the same name, provide they have different parameter lists
It is a form of compile-time polymorphism also known as static polymorphism or early binding
Methods can share the same name if their parameter lists differ.
Cannot overload by return type alone; parameters must differ.
The compiler chooses the most specific match when multiple methods could apply.

class Product{

public int multiply(int a, int b){

    int prod = a * b;
    return prod;
}


public int multiply(int a, int b, int c){

    int prod = a * b * c;
    return prod;
}

}

class Geeks{

public static void main(String[] args)
{

    Product ob = new Product();


    int prod1 = ob.multiply(1, 2);


    System.out.println(
        "Product of the two integer value: " + prod1);


    int prod2 = ob.multiply(1, 2, 3);


    System.out.println(
        "Product of the three integer value: " + prod2);
}

Output

Product of the two integer value: 2
Product of the three integer value: 6

What is Hook ?

Sakthi S — Sun, 29 Mar 2026 12:02:13 +0000

React Hooks
are functions that allow you to use state and other React features, such as lifecycle methods and context, within functional components.
Hooks let you use different React features from your components. You can either use the built-in Hooks or combine them to build your own. This page lists all built-in Hooks in React.

*Commonly Used Built-in Hooks *

useState: Adds state variables to a functional component and provides a function to update that state.
useEffect: Manages side effects, such as data fetching, subscriptions, or manual DOM updates
useContext: Allows components to subscribe to React's Context API, making it easier to share data across the component tree without "prop drilling".
useReducer: A more advanced state management Hook for handling complex state logic, often as an alternative to useState.
useRef: Returns a mutable ref object that can persist values across renders or directly access DOM elements.
useMemo / useCallback: Performance optimization Hooks that memoize expensive calculations or function definitions, preventing unnecessary re-renders of components.

What is UseEffect ?

Sakthi S — Sat, 28 Mar 2026 16:03:53 +0000

In simple terms, useEffect allows you to run code after a component renders.

Purpose and Usage

useEffect is crucial because functional components are intended to be pure functions (predictable output given the same input).
Operations that interact with the "outside world" need a designated place to run without disrupting the rendering process. Before hooks, these tasks were handled in class components using lifecycle methods.
like componentDidMount, componentDidUpdate, and componentWillUnmount.

Typical uses:

Fetching data from APIs
Updating the DOM
Setting up subscriptions (e.g., WebSocket)
Timers (setTimeout, setInterval)

UseEffect Code

import { useEffect, useState } from "react";

function Count() {
    const [count, setCount] = useState(0)
    function incre() {
        setCount(count + 1)
        console.log(count);

    }
    useEffect(() => {
        const interval = setInterval(() => {
            console.log("working");
        }, 1000);

        return (() => {
            clearInterval(interval)
        })
    })
    return (
        < div >
            <h1>{count}</h1>
            <button onClick={incre}>+</button>
        </div >
    )

}
export default Count;

What is Use State?

Sakthi S — Sat, 28 Mar 2026 15:28:34 +0000

The useState hook is a fundamental function in React that allows you to add state variables to functional components.
State refers to data or properties that need to be tracked and updated in an application, and useState enables components to "remember" information between re-renders, making the user interface dynamic and interactive.
const [state, setState] = useState(initialState)

useState(initialState)

Call useState at the top level of your component to declare a state variable.


`import { useState } from 'react';

function MyComponent() {
  const [age, setAge] = useState(28);
  const [name, setName] = useState('Taylor');
  const [todos, setTodos] = useState(() => createTodos());`