DEV Community: Subash

Variable and Data Types in Java

Subash — Mon, 26 Oct 2026 14:00:10 +0000

In Java, there are two types of data types: Primitive and Non-Primitive (Reference) Data Types.

1. Primitive Data Types

In Java, we have 8 primitive data types:

byte
short
int
long
float
double
boolean
char

These are the basic data types available in Java.

2. Non-Primitive Data Types

In non-primitive data types, we have String, arrays, and classes that we create.

For example, if we create a class called Home, it is a user-defined class and its type is a reference type.

String name = "Stark";
Home home = new Home();

Here, String and Home are reference types.

We also use System.out.println() to print something in Java. Here, System is a predefined class in Java, and println() is a method used to print output.

3. What is a Variable?

A variable is a name given to a storage location that holds a value.

For example:

String name = "Stark";

Here, String is the data type, name is the variable, and "Stark" is the value assigned to it.

4. Types of Variables in Java

We commonly discuss local variables, instance variables, and static variables in Java.

Local Variable: A variable declared inside a method, constructor, or block. It can be accessed within its declared scope.

Instance Variable: A variable declared inside a class but outside methods and without the static keyword. Each object has its own copy of an instance variable.

Static Variable: A variable declared using the static keyword inside a class. It belongs to the class, and the class shares it among its objects.

For example:

class Home {
    static String type = "House";
    String owner = "Stark";

    void display() {
        int number = 10;
        System.out.println(number);
    }
}

In this example:

type is a static variable because it is declared using the static keyword.
owner is an instance variable because it belongs to each object.
number is a local variable because it is declared inside the display() method.

About a Programing Paradigm

Subash — Sat, 24 Oct 2026 13:03:51 +0000

Imperative Paradigms

Procedural programming Paradigm: A traditional method where code is written as a top-down list of step-by-step instructions or routines for the computer to follow.

Object Oriented Programming: A style that groups related variables and functions into everyday "objects," as covered in the earlier post.

Parallel Processing Approach: A method that divides complex tasks into smaller chunks so the computer's processors can execute them all at the exact same time.

Declarative Paradigms

Logic Programming Paradigm: A system where the programmer sets up a list of facts and rules, and the computer uses formal logic to deduce the answers.

Functional Programming: A style that treats computation like mathematical equations, strictly avoiding changing or mutating data once it is created.

Database Processing Approach: A method used for interacting with large databases, where you simply state what data you want to retrieve without writing the search algorithm.

Finding Error in a simple "Hello World!" Program.

Subash — Sat, 24 Oct 2026 10:03:49 +0000

Above is the simple Hello Universe! program and we can see how the simple syntax error cause the program to fail to run.

1)If we remove the class name Home below error occurs

2)If we remove the class form the first line below error occurs

3)If we remove the semicolon from the output line below error occurs

4)If we remove the double quotation from the string Hey Universe below error occurs

5)If we put single quotation instead of double quotation in string below error may occurs

6)If we remove the main in psvm below error occurs

It ask for identifier expected...

7)If we remove void form public static void main(psvm) below error occurs

its asks for return type...

8)If we remove the System form the code below error occurs

9)If we remove the curly braces from psvm it shows the error below:

10)If we remove println form the output line below error occurs

useEffect-Hooks

Subash — Thu, 01 Oct 2026 13:38:20 +0000

1. Run Only Once

Print "Component Mounted" only once when page loads.

- How will you write useEffect?

- What should be in dependency array? Why?

The dependency array should be an empty array [ ].

An empty dependency array tells React to run the useEffect after the component's initial render, so the effect runs only once when the component is mounted.

2. Run on Every Render

Print "Rendered" on every render.

- How will you write useEffect?

- What happens if dependency array is not provided?

If we don't provide a dependency array, the useEffect will run after every render of the component.

For example, if the component renders 5 times, the useEffect will also run 5 times.

3. Run When State Changes

const [count, setCount] = useState(0);
Log "Count changed" only when count changes.

- What should dependency array contain?

The dependency array should contain the count variable.

This means the useEffect will run whenever the count value changes.

- What happens if it is empty [ ]?

If the dependency array is empty [ ], the useEffect will run only once after the component's initial render.

It will not run again when count changes.

So, if we want the effect to run whenever count changes, we need to put count in the dependency array: [count]

4. Two States, One Effect

const [count, setCount] = useState(0);
const [name, setName] = useState("");
Run effect when count OR name changes.

- How will dependency array look?

The dependency array should contain both count and name:

This means the useEffect will run whenever count changes OR name changes.

- What if only count is added?

The useEffect will run whenever count changes.

Changes to name will not trigger this useEffect because name is not included in the dependency array.

5. Derived Logic

Show "Even Number" whenever count becomes even.

- Should this logic be inside render or useEffect? Why?

The logic is inside useEffect because we want to perform the console log when count changes. The [count] dependency makes the UseEffect to run whenever count changes, and the if condition checks whether the new count is even.

6. API Call on Mount

Fetch users when component loads.

- Why do we use [ ]?

We use an empty dependency array [ ] because we want the API call to run only after the component's initial render

- What happens if we remove [ ]?

If we remove [ ], the useEffect runs after every render. Therefore, the API call will be made after every render, which can cause unnecessary API requests and may lead to performance problems.

7. Infinite Loop Trap

useEffect(() => {

setCount(count + 1);

}, [count]);

- What will happen?

The setCount will increase the count value. Since count is in the dependency array, the useEffect will run again whenever count changes, creating an infinite loop.

- Why does this cause infinite re-render?

Since count is in the dependency array, changing count triggers the effect again, which changes count again, causing an infinite re-render loop.

8. Fix the Infinite Loop

- How can you increment count only once using useEffect?

If we give an empty dependency array [ ], the useEffect will run only once after the initial render. Therefore, setCount will increment the count only once, avoiding the infinite loop.

9. Document Title Sync

useEffect(() => {

document.title = count;

}, [?]);

- What should go inside ? Why?

We should put count inside the dependency array because whenever count changes, the useEffect will run and update the document title with the new count value.

10. Cleanup Basic

useEffect(() => {

window.addEventListener("click", handleClick);

});

- What problem may happen?

Without cleanup, a new click event listener will be added on every render. This can cause the handleClick function to run multiple times for a single click.

- How to fix properly?

- When does cleanup run?

The cleanup function runs before the effect runs again and when the component is unmounted (removed from the screen).