DEV Community: Mohan Mogi

Java Constructor Programming Examples for Beginners

Mohan Mogi — Thu, 09 Jul 2026 08:08:06 +0000

What is Constructor?

1.Constructorin java is special method that is used to initailze objects.
2.It is automatically called when an object of a class is created.
3.It is used to set initial values for object attributes.

Rules of Constructor:

◆ Constructor name must be the same as the class name.
◆ Constructor has no return type (not even void).
◆ Constructor is called automatically when using the new keyword.
◆ Constructors can be overloaded.

Types of Constructors:

Default Constructor
No-Argument Constructor
Parameterized Constructor

Important Keywords:

◆ new → Creates an object and calls the constructor.
◆ this() → Calls another constructor in the same class.
◆ super() → Calls the parent class constructor.

Create a constructor:

Explanation:
*Creates a class named Main.
public class Main {

*Declares an instance variable x.
int x;

*Declares an instance variable x.
public Main() {
x = 5;
}

◆ This is the constructor.
◆ It has the same name as the class (Main).
◆ It has no return type.
◆ It runs automatically when an object is created.
◆ It initializes x to 5.

Main myObj = new Main();

◆ Creates a new object.
◆ Automatically calls the constructor.
◆ The constructor sets x = 5.

System.out.println(myObj.x);
◆ Prints the value of x.

output: 5

Java Static Variable vs Non-Static Variable (Beginner Guide)

Mohan Mogi — Tue, 07 Jul 2026 07:07:50 +0000

A variable in Java stores data. Variables can be of two types:
1.Static Variable (Class Variable)
2.Non-Static Variable (Instance Variable)

1.Static Variable:

Belongs to *A static variable belongs to the class, not to any individual object.

2.Keyword
*A static variable is declared using the static keyword.

Number of Copies
*Only one copy of the static variable exists, and it is shared by all objects.
Memory Creation
*Memory for a static variable is created once when the class is loaded into memory.
Access
*A static variable is usually accessed using the class name, for example: Student.college.
Shared
*A static variable is shared by all objects of the class.
Use
*A static variable is used to store common data that is the same for every object, such as a company name or college name.

2.Non-Static Variable:

Belongs to *A non-static variable belongs to an object (instance) of the class.

2.Keyword
*A non-static variable is declared without the static keyword.

Number of Copies
*Every object has its own separate copy of the non-static variable.
Memory Creation
*Memory for a non-static variable is created each time a new object is created.
Access
*A non-static variable is accessed using an object, for example: student.name.
Shared
*A non-static variable is not shared. Each object has its own value.
Use
*A non-static variable is used to store individual object data, such as a student's name, roll number, or age.

Introduction to Java (Beginner Guide)

Mohan Mogi — Tue, 07 Jul 2026 06:36:17 +0000

1. What is Java?
Java is a high-level, object-oriented, platform-independent programming language that allows developers to write code once and run it anywhere using the Java Virtual Machine (JVM).Java
developed by Sun Microsystems in 1995 (now owned by Oracle).

Java is used to build:

Web Applications
Desktop Applications
Android Applications
Enterprise Software
Banking Systems
Cloud Applications

2. Why Learn Java?
Java is one of the most popular programming languages because it is:

Easy to learn
Secure
Fast
Platform Independent
Object-Oriented

Understanding the Platform Architecture of Java, JavaScript, and Python

Mohan Mogi — Fri, 26 Jun 2026 06:23:07 +0000

Java Platform Architecture

Java Source Code (.java)
│
▼
Java Compiler (javac)
│
▼
Bytecode (.class)
│
▼
Java Virtual Machine (JVM)
│
▼
Machine Code
│
▼
Output

Explanation:
*Write code in .java files.
*javac compiles it into bytecode.
*The JVM converts bytecode into machine code.
*The program runs on any operating system with a JVM.

Advantage
Platform Independent ("Write Once, Run Anywhere")

JavaScript Platform Architecture

JavaScript Code (.js)
│
▼
JavaScript Engine
(V8 / SpiderMonkey / JavaScriptCore)
│
▼
Machine Code
│
▼
Output

Explanation:
*JavaScript does not need compilation like Java.
*It runs inside a JavaScript Engine.
*Browsers use different engines:
*Google Chrome → V8
*Mozilla Firefox → SpiderMonkey
*Safari → JavaScriptCore
*Node.js also uses the V8 engine.

Advantage
*Fast execution.
*Runs directly in browsers.

Python Platform Architecture

Python Source Code (.py)
│
▼
Python Interpreter
│
▼
Bytecode (.pyc)
│
▼
Python Virtual Machine (PVM)
│
▼
Machine Code
│
▼
Output

Explanation:
*Write code in .py files.
*The Python interpreter converts it to bytecode.
*The Python Virtual Machine (PVM) executes the bytecode.
*The operating system runs the machine code.

Advantage
*Easy to write and understand.
*Portable across operating systems with a Python interpreter.

Java Error Messages Explained with Examples

Mohan Mogi — Wed, 24 Jun 2026 06:42:38 +0000

Game.java:6: error: ';' expected
*Game.java → File name
*6 → Error is on line 6
*';' expected → Java expected a semicolon

System.out.println("Hello world");
*System → Built-in Java class
*out → Output stream object
*. → Access operator
*println() → Prints text and moves to the next line

The dots are very important:
System.out.println("Hello");
↑ ↑

Without the second dot:
System.out println("Hello");

Java cannot understand the statement.

The parameter is missing a variable name.
In Java, method parameters need both a type and a name.

*String[] → Type
*args → Parameter name (identifier)

The problem is that after public static, Java expects a return type and a method name.

Java expects class, interface, enum, or record after public.

useMemo Hook in React

Mohan Mogi — Wed, 10 Jun 2026 07:01:51 +0000

useMemo:

useMemo is a React Hook used for performance optimization.
It returns a memoized value by storing the result of an expensive calculation in memory (cache) and reusing it during rerenders.
React recalculates the value only when one of its dependencies changes, helping avoid unnecessary calculations and improve application performance.

syntax:
const memoizedValue = useMemo(() => {
return calculation;
}, [dependencies]);

useRef Hook

Mohan Mogi — Tue, 09 Jun 2026 08:01:03 +0000

useRef Hook:
useRef is a React Hook.Access and manipulate DOM elements directly.
Store values without causing a component re-render.

Syntax:
import { useRef } from "react";

function App() {
const inputRef = useRef(null);

return ;
}

output:

React useReducer Explained with Simple Examples

Mohan Mogi — Fri, 05 Jun 2026 07:30:15 +0000

useReducer Hook:
The useReducer Hook is similar to the useState Hook.Track of multiple pieces of state that rely on complex logic, useReducer may be useful.

Syntax
The useReducer Hook accepts three arguments.

useReducer(reducer, initialState, init)

Understanding the Parameters and Return Values of useReducer:

reducer
The reducer is a function that defines how the state should change in response to an action. It receives the current state and an action object as arguments and returns the next state.
initialState
The initialState is the value used to determine the initial state of the reducer. It can be any data type, such as a number, object, array, or string.

3.dispatch
The dispatch function is returned by useReducer and is used to send actions to the reducer. Whenever an action is dispatched, React executes the reducer, calculates the new state.The action object typically contains a type property and may include additional data.

4.state
The state value represents the current state managed by the reducer. It starts with the initial state and updates whenever an action is dispatched.

example:

output:

React Hooks Explained in Simple Terms

Mohan Mogi — Tue, 02 Jun 2026 10:28:11 +0000

React Hooks:
Hooks are built-in React functions that allow Functional Components to use React features such as state management, lifecycle methods, context, references, and performance optimizations without writing Class Components.Hooks were introduced in React 16.8.

Why Use Hooks?

Reusing stateful logic between components
Managing complex component lifecycle code
Reducing the need for Class Components
Making components simpler and easier to understand.

Before Hooks, Functional Components could only receive props and render UI. They could not manage state or lifecycle behavior. Hooks changed that.

1.useState Hook:
The React useState Hook allows us to track state in a function component.State generally refers to data or properties that need to be tracking in an application.

Import useState
To use the useState Hook, first need to import it into component.

Example:
At the top of component, import the useState Hook.
import { useState } from "react";

useState accepts an initial state and returns two values:

*The current state.
*A function that updates the state.

import { useState } from "react";

function FavoriteColor() {
const [color, setColor] = useState("red");
}

explanation;
The first value, color, is current state.
The second value, setColor, is the function that is used to update state.

Read State explample:

output:

Update State

output:

2.useEffect Hook:

The useEffect Hook allows to perform side effects in components.
Some examples of side effects are: fetching data, directly updating the DOM, and timers.
useEffect accepts two arguments. The second argument is optional. useEffect(, )

Understanding useEffect in React:

Mohan Mogi — Fri, 29 May 2026 08:05:09 +0000

useEffect:
useEffect is a React Hook that lets you perform side effects in a functional component.
Common side effects are:
Fetching data from an API,Updating the document title,Setting timers (setInterval, setTimeout),Adding event listeners,Accessing local storage.useEffect accepts two arguments. The second argument is optional.useEffect(, ).

Understanding React Hooks with Practical Examples

Mohan Mogi — Thu, 28 May 2026 07:25:51 +0000

what is a hook in react?
A Hook is a special React function that allows functional components to use React features such as state, lifecycle behavior, refs, and context without using class components.
They provide a more direct API to React concepts like props, state, context, refs, and lifecycle.
Before Hooks, state and lifecycle methods could only be used in class components.
Hooks were introduced in React 16.8 to make functional components more powerful.

1.React useState hook:
The react usestate hook allows us to track state in a functional components.
State generally refers to data or properties that need to be tracking in an application.
useState is a React Hook used to store and update data (state) in a functional component.

syntax
const [state, setState] = useState(initialValue);

code

output
three times click button.

How it works
Initial value:
count = 0

When button is clicked:
setCount(count + 1);

Value becomes:
count = 1
count = 2
count = 3

Why use useState?
React updates the screen whenever the state changes.Data changes, React automatically re-renders the component and updates the UI.

Understanding Closures in JavaScript: A Complete Beginner Guide

Mohan Mogi — Wed, 27 May 2026 06:20:41 +0000

closure;
In Javascript,closure is a feature.Closure is an inner function is retains accces to the variables of its outer(enclosing) function,even after that outer function has finished executing.A closure is the combination of a function and the lexical environment in which it was declared.

output:

Explanation:
Step 1:
outerFunction() runs
let count = 0;

Variable count is created.

Memory:

count = 0

Step 2:
innerFunction is created
function innerFunction() {
count++;
console.log("Count:", count);
}

innerFunction uses count from its parent function.

Step 3:
Return inner function
return innerFunction;
const counter = outerFunction();

Now counter stores innerFunction.

Normally outerFunction() would finish and remove its variables from memory.

But because innerFunction still needs count, JavaScript keeps count alive.

This is called Closure.

Step 4:
First call
counter();

Runs:

count++;

Before:

count = 0

After:

count = 1

Output:

Count: 1

flow view:
outerFunction()
|
count = 0
|
return innerFunction
|
counter()
|
count = 1

counter()
|
count = 2

counter()
|
count = 3

counter()
|
count = 4