DEV Community: VINOTH

Java Constructors

VINOTH — Fri, 25 Sep 2026 01:25:46 +0000

A Java constructor is a special block of code inside a class that is automatically invoked when a new instance (object) of that class is created using the new keyword. Its primary purpose is to initialize the state of the newly created object by assigning values to its instance variables.

Key Characteristics of Java Constructors

Same Name as Class
A constructor is called automatically when an object is created using new.
Constructors can have parameters and can be overloaded.

Types of Constructors

1.Default (No-Argument) Constructor

If you do not define any constructor in your class, the Java compiler automatically generates a hidden, no-argument default constructor for you. It initializes object references to null and numeric primitive types to 0.

public class Car {
    String brand;
    int speed;

    // The compiler automatically creates this behind the scenes:
    // public Car() {}
}

// Usage
Car myCar = new Car(); // brand will be null, speed will be 0

2.Parameterized Constructor

You can write a custom constructor that accepts arguments. This provides the flexibility to assign specific, custom values to your object's attributes at the moment it is created.

public class Car {
    String brand;
    int speed;

    // Parameterized constructor
    public Car(String brand, int speed) {
        this.brand = brand; // "this" resolves naming conflicts between parameters and fields
        this.speed = speed;
    }
}

// Usage
Car myCar = new Car("Toyota", 120);

3.Copy Constructor

Unlike C++, Java does not have a built-in copy constructor. However, you can easily create your own by writing a constructor that takes an object of the same class as a parameter to copy its values.

public Car(Car otherCar) {
    this.brand = otherCar.brand;
    this.speed = otherCar.speed;
}

Constructor Overloading

Just like methods, constructors can be overloaded. This means a single class can have multiple constructors, provided they have different parameter lists (different number, order, or types of parameters). The compiler automatically decides which constructor to execute based on the arguments passed.

public class Car {
    String brand;
    int speed;

    // Constructor 1: No arguments
    public Car() {
        this.brand = "Unknown";
        this.speed = 0;
    }

    // Constructor 2: One argument
    public Car(String brand) {
        this.brand = brand;
        this.speed = 0;
    }

    // Constructor 3: Two arguments
    public Car(String brand, int speed) {
        this.brand = brand;
        this.speed = speed;
    }
}

Java Data Types

VINOTH — Wed, 23 Sep 2026 15:31:03 +0000

Java data types are mainly divided into two categories:

1.Primitive Data Types:

Some commonly used primitive data types are:

int
float
double
char
boolean
byte
short
long

Primitive data types are the basic data types provided by Java. They are used to store simple values such as numbers, characters, and boolean values.

Example:

int age = 25;
double salary = 35000.50;
char grade = 'A';
boolean isActive = true;

2.Non-Primitive Data Types:

Non-primitive data types are also called reference types.

They are used to store references to objects rather than directly storing the actual value.

String
Arrays
Classes
Objects
Interfaces

Example:

String name = "Vinoth";

int[] marks = {90, 85, 95};

Here, String and int[] are non-primitive data types.

We can also create our own class:

class Student {
String name;
int age;
}

Then create an object:

Student student = new Student();

Here:

Student → Class
student → Reference variable
new Student() → Object

Java Introduction

VINOTH — Wed, 23 Sep 2026 15:20:37 +0000

Java is one of the most popular and widely used programming languages in the world. It is a high-level, object-oriented programming language that is used to build different types of applications such as web applications, desktop applications, mobile applications, enterprise software, and backend systems.

Java is a platform-independent language, which means code written in Java can run on any device that supports the Java Virtual Machine (JVM).
Syntax and structure are similar to C-based languages like C++ and C#.

What is Java?

Java is a programming language developed by Sun Microsystems in 1995. It was originally created by James Gosling and his team.

One of the most important features of Java is:

"Write Once, Run Anywhere."

This means that Java code can run on different operating systems as long as the system has a Java Virtual Machine (JVM).

Features of Java

Java has several important features:

1.Simple

Java syntax is relatively easy to understand, especially for developers who already know programming concepts.

2.Object-Oriented

Java follows the Object-Oriented Programming (OOP) approach.

The major OOP concepts are:

Class
Object
Inheritance
Polymorphism
Encapsulation
Abstraction

3.Platform Independent

Java source code is compiled into bytecode.

This bytecode can run on any system that has a JVM.

The basic flow is:

Java Code → Compiler → Bytecode → JVM → Output

4.Secure

Java provides several security features such as bytecode verification and controlled memory access.

5.Robust

Java has features such as strong type checking, exception handling, and automatic memory management, which help developers build reliable applications.

6.Multithreaded

Java supports multithreading, which allows multiple tasks to execute concurrently within a program.

How Does Java Work?

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

The Java compiler converts this source code into bytecode.

Hello.java
    ↓
Java Compiler (javac)
    ↓
Hello.class
    ↓
Bytecode
    ↓
JVM
    ↓
Output

JVM – Java Virtual Machine

JVM is responsible for executing Java bytecode.

JRE – Java Runtime Environment

JRE provides the environment required to run Java applications. It includes the JVM and required runtime libraries.

JDK – Java Development Kit

JDK is used to develop Java applications.

It includes tools such as the Java compiler along with the runtime environment.

The relationship can be understood as:

JDK → JRE → JVM

Credit Card Validation Using Python While Loop – Luhn Algorithm

VINOTH — Fri, 28 Aug 2026 16:17:43 +0000

How to Validate a Credit Card Number Using Python and the Luhn Algorithm?

no = 4532015112830366

total = 0
count = 0

while no > 0:
    digit = no % 10
    no = no // 10


    if count % 2 == 1:
        digit = digit*2


        if digit > 9:
            digit = digit % 10 + digit // 10

    total += digit
    count += 1

if total % 10 == 0:
    print("Valid credit card")    
else:
    print("Invalid credit card")

o/p:

Valid credit card

Write a Python program to validate a credit card number using the Luhn Algorithm. The program should process the digits from right to left, double every second digit, reduce two-digit results by adding their digits, calculate the total, and determine whether the credit card number is valid.

Python Lcm,Hcf Learn

VINOTH — Thu, 27 Aug 2026 03:49:02 +0000

1)There are four Mobile Phones in a house. At 5 a.m, all the four Mobile Phones will ring together. Thereafter, the first one rings every 15 minutes, the second one rings every 20 minutes, the third one rings every 25 minutes and the fourth one rings every 30 minutes. At what time, will the four Mobile Phones ring together again?

def find_lcm(num1, num2, num3, num4):
    lcm = num1
    while True:
        if lcm % num1 == 0 and lcm % num2 == 0 and lcm % num3 == 0 and lcm % num4 == 0:
            return lcm


        lcm +=1


num1 = 15
num2 = 20
num3 = 25
num4 = 30

result = find_lcm(num1, num2, num3, num4)
print(result)

o/p:

2)A book seller has 175 English books, 245 Science books and 385 Mathematics books. He wants to sell the books in a box, subject-wise in equal numbers. What will be the greatest number of the boxes required? Also find the number of books for each subject in a box.

def find_hcf(num1, num2, num3):
    div = 1
    hcf = 1

    while div <= num1:
        if num1 % div == 0 and num2 % div == 0 and num3 % div == 0:
            hcf = div

        div +=1

    return hcf        

num1 = 175
num2 = 245
num3 = 385

result = find_hcf(num1, num2, num3)
print(result)
print("Greatest number of boxes:", result)
print("English in each boxes:", num1 // result)
print("Science in each boxes:", num2 // result)
print("Mathematics in each boxes:", num3 // result)

0/p:

35
Greatest number of boxes: 35
English in each boxes: 5
Science in each boxes: 7
Mathematics in each boxes: 11

3)Two numbers are said to be amicable numbers if the sum of the factors of one number (except the number itself) gives the other number.
The numbers 220 and 284 are amicable, since the sum of the factors of 220 (except 220) i.e., 1+2+4+5+10+11+20+22+44+55+110 = 284 and the sum of the factors of 284 (except 284) i.e., 1+2+ 4+71+142 = 220. Check whether 1184 and 1210 are amicable numbers.

def find_factors(no):

    div = 1
    total = 0

    while div < no:

        if no % div == 0:
            # print(f'{div} is a factors of {no}')

            total += div

        div +=1

    return total        

# result = find_factors(1184)

# print( result)


num1 = 1184
num2 = 1210

sum1 = find_factors(num1)
sum2 = find_factors(num2)

#print(sum1)
#print(sum2)
print("num1:1184 =",sum1)
print("num2:1210 =",sum2)

o/p:

num1:1184 = 1210
num2:1210 = 1184

React useState Hook - Day1

VINOTH — Wed, 26 Aug 2026 13:34:57 +0000

1) Toggle Button:
You build a button that switches between:
"ON" ↔ "OFF"
What type of state should you use?
What is the best initial value?

import { useState } from "react"

function Toggle() {

  const [status, setStatus] = useState("OFF");

    function togglebtn() {

            if (status === "OFF") {
                setStatus("ON");
            }else{
                setStatus("OFF");
            }
    }

    return(
        <div>
            <h1>{status}</h1>
            <button onClick={togglebtn}>Toggle</button>
        </div>
    )
}

export default Toggle

2) Input Field Value:
You have a text input.
User types name and you want to display:
Hello, Vinoth
Why must the input value be stored in useState?
What happens if you use a normal variable?

import { useState } from "react"

function Name() {

    const [name, setName] = useState("");

    function handle(e) {

        setName(e.target.value);

    }

    return(
        <div>
            <input 

                 value={name}
                 onChange={handle}
            />
            <h1>Hello, {name}</h1>
        </div>
    )
}

export default Name

3) Show/Hide Text:
You want to show paragraph only when button is clicked.
What kind of state works best?
Why boolean is suitable here?

import { useState } from "react"

function Text() {

  const [show, setShow]= useState(false);

    function handle () {

        if (show === false) {
            setShow(true)
        }else{
            setShow(false)
        }

    }

    return(
        <div>
           <button onClick={handle}>
            show / hide
           </button>

           {show && <p>Hello! This is my paragraph.</p>}
        </div>
    )
}

export default Text

4) Character Counter:
User types in textarea. You show number of characters.
How do you track text length?
Should you store both text and length in state?

import { useState } from "react"

function Count() {

  const [text, setText]= useState("");



    return(
        <div>
          <textarea 

          value={text}
          onChange={(e)=>setText(e.target.value)}

          />

          <p>Characters: {text.length}</p>
        </div>
    )
}

export default Count

5) Form with Multiple Inputs
You have 5 input fields (name, email, phone, city, password).
Better to use:
5 separate useState?
OR one object state?
Why?
What problem happens if you update object state incorrectly?

import { useState } from "react";

function FormHandling() {


 const [form, setForm] = useState({
name: "",
email:"",
phone:"",
city:"",
password:""
})

function handle(e) {
    setForm({...form, [e.target.name]: e.target.value })
    console.log(e.target.value);

}


    return(
        <div>

            <form >

                <label htmlFor="name">name</label>
                <input type="text" id="name" name = "name" onChange={handle}/>

                <label htmlFor="email">email</label>
                <input type="email" id="email" name="email" onChange={handle}/>

                <label htmlFor="phone">phone</label>
                <input type="phone" id="phone" name="phone" onChange={handle}/>

                <label htmlFor="city">city</label>
                <input type="city" id="city" name="city" onChange={handle}/>

                <label htmlFor="password">pass</label>
                <input type="password" id="password" name="password" onChange={handle}/>

            </form>
            <h1>{`Name: ${form.name}, Email: ${form.email}, phone: ${form.phone}, city: ${form.city} ,password: ${form.password}`}</h1>

        </div>
    )
}

export default FormHandling;

6) Checkbox Selection List
User can select multiple skills:
☐ React
☐ Node
☐ Java
☐ SQL
What should be the state type?
How will you add/remove values from state array?

import { useState } from "react"

function Checkbox() {

    const [skills, setSkills] = useState([])

    function handle(e) {


        if (e.target.checked) {
            setSkills([...skills, e.target.value])
        } else {
            // skills.filter((skill) => e.target.value != skill)
            setSkills(
                skills.filter((skill) => skill !== e.target.value)
            );
        }
    }

    return (
        <div>

            <input type="checkbox" value={"sql"} onChange={handle} />sql <br />
            <input type="checkbox" value={"java"} onChange={handle} /> java  <br />
            <input type="checkbox" value={"node"} onChange={handle} /> node  <br />
            <input type="checkbox" value={"react"} onChange={handle} /> react


            <h2>Selected Skills:</h2>

            {skills.map((skill) => {
                return <p key={skill}>{skill}</p>;
            })}

        </div>
    )
}

export default Checkbox;

React useState Hook

VINOTH — Wed, 26 Aug 2026 13:24:55 +0000

The useState hook allows functional components in React to store and manage data that can change over time. It is simple to use and ideal for handling basic state updates within a component.

It lets you add state variables to functional components.
It is best suited for simple and straightforward state updates.
The hook must be imported from React before using it.

Syntax

const [state, setState] = useState(initialState)

state: It is the value of the current state.
setState: It is the function that is used to update the state.
initialState: It is the initial value of the state.

Example:

import { useState } from "react"

function Count() {

  const [count, setCount] = useState(0);

    function incerement () {
        setCount(count+1)
    }

    function decerement() {
        setCount(count-1)
    }

    function reset() {
        setCount(0)
    }
    return(
        <div>
            <h1>Counter app</h1>
            <h3>count: {count}</h3>
            <button onClick={incerement}>+</button>
            <button onClick={decerement}>-</button>
            <button onClick={reset}>reset</button>
        </div>
    )
}

export default Count

Closure in JavaScript

VINOTH — Mon, 24 Aug 2026 16:30:54 +0000

A closure is created when a function remembers the variables from its outer scope, even after the outer function has finished executing.

How Closures Work

An outer function creates a local variable.
An inner function inside the outer function uses that variable.
The outer function returns the inner function.
The variable stays in memory because the inner function still needs it.

 <script>

        function bank() {

            let min_balance = 500;

            const actions = {

                deposit: function (amt) {
                    min_balance = min_balance + amt;
                },

                withdraw: function (amt) {
                    min_balance = min_balance - amt;
                },
                checkbalance: function () {
                    console.log(min_balance);

                }



            }
            return actions;
        }

        const customer1 = bank();
        customer1.deposit(100);
        customer1.checkbalance();
        customer1.withdraw(200);
        customer1.checkbalance();

    </script>

Synchronous vs Asynchronous vs Promise in JavaScript

VINOTH — Sun, 23 Aug 2026 11:48:13 +0000

In JavaScript, synchronous means code runs line-by-line in order, asynchronous means code can start a long-running task and move on immediately without waiting, and a Promise is a modern JavaScript object used to manage those asynchronous tasks cleanly.

Think of it like ordering food at a restaurant:

Synchronous: You stand in line, order, and wait at the register until your food is cooked. The line behind you is completely blocked.
Asynchronous: You order, get a buzzer, and sit down. You can check your phone while your food cooks.
Promise: The buzzer itself. It is a token that represents the future delivery of your meal.

1. Synchronous JavaScript (Sync):

JavaScript is synchronous and single-threaded.
It executes one command at a time in a strict sequence.
If a line of code takes 10 seconds to compute, the entire browser freezes and waits.

Characteristics: Sequential, predictable, blocking.

console.log("A");
console.log("B");
console.log("C");

o/p:

A
B
C

Flow:

A → finish
    ↓
B → finish
    ↓
C → finish

2. Asynchronous JavaScript (Async):

Asynchronous programming allows JavaScript to offload long-running tasks (like fetching data from a server or waiting for a timer) to the browser background.
The main program keeps running without stalling.

Characteristics: Non-blocking, handles concurrent actions, relies on a callback queue.

console.log("A");

setTimeout(() => {
    console.log("B");
}, 2000);

console.log("C");

o/p:

A
C
B

Why?

A → executes immediately

setTimeout → waits for 2 seconds

C → executes immediately

After 2 seconds → B executes

3. Promises (The Async Manager):

Historically, asynchronous tasks used basic callback functions. However, nesting multiple callbacks inside each other created unreadable code known as "Callback Hell".
A Promise is a placeholder for a value that you don't have yet but will receive in the future.

A Promise always exists in one of three states:

Pending: The background task is still working.
Fulfilled: The task completed successfully, and you get the result.
Rejected: The task failed, and you get an error message.

For example, imagine ordering food:

Order food
    ↓
Pending
    ↓
Food ready → Success
    OR
Problem → Failure

A Promise has three states:

Pending
   ↓
   ├── Fulfilled ✅
   │
   └── Rejected ❌

Example:

const promise = new Promise((resolve, reject) => {

    let success = true;

    if (success) {
        resolve("Success");
    } else {
        reject("Failed");
    }

});

4. Handling a Promise:

We can use .then() and .catch().

promise
    .then((result) => {
        console.log(result);
    })
    .catch((error) => {
        console.log(error);
    });

.then()

Used when the Promise is successful.

.catch()

Used when the Promise fails.

5. Promise with fetch():

fetch() is commonly used to get data from an API.

fetch("https://fakestoreapi.com/products")
    .then((response) => response.json())
    .then((data) => {
        console.log(data);
    })
    .catch((error) => {
        console.log(error);
    });

Flow:

fetch()
   ↓
Promise
   ↓
Server Response
   ↓
response.json()
   ↓
Data

Easy way to remember:

Synchronous
→ WAIT → NEXT

Asynchronous
→ DON'T WAIT → NEXT

Promise
→ RESULT WILL COME LATER

async/await
→ EASY WAY TO HANDLE PROMISE

Python - Neon, Strong, Duck, and Spy Number programs

VINOTH — Sun, 23 Aug 2026 05:52:26 +0000

Neon Number

1)Write a Python program to check whether a given number is a Neon Number or not.

Example:

9 × 9 = 81

8 + 1 = 9

def sum_of_digits(no):
    sum = 0
    while no > 0:
        sum = sum + no%10
        no = no//10
    return sum

number = 9 
square = number ** 2 #number * number 
sum = sum_of_digits(square)
if number == sum: 
    print('Neon Number')

o/p:

Neon Number

Strong Number

2)Write a Python program to check whether a given number is a Strong Number or not.

    def find_factorial(no):
     factorial = 1
    while no > 0:
        factorial *= no #factorial = factorial * no
        no-=1 #   no = no - 1

    return factorial 

def digits(no): #145
    total = 0
    while no > 0:
        digit = no % 10
        factorial = find_factorial(digit) 
        total += factorial #total = total + factorial
        #print(f'factorial of {digit} is {factorial}')
        no = no//10
    return total 

number = int(input("Enter no. "))
result = digits(number) 
if result == number: 
    print("Strong Number")

o/p:

Strong Number

Duck Number

3) Write a Python program to check whether a given number is a Duck Number or not.

    no = input("Enter no.")
if no[0] == '0':
    print('Not a Duck Number')
else:
    if '0' in no:
        print("Duck Number")

o/p:

Duck Number

Spy Number

4) Write a Python program to check whether a given number is a Spy Number or not.

 def sum_of_digits(no):
    sum = 0
    multiply = 1

    while no > 0:
        sum = sum + no % 10
        multiply = multiply * (no % 10)
        no = no // 10

    return sum, multiply

no = 1411
result1, result2 = sum_of_digits(no)
print('Spy Number: ', result1==result2)

o/p:

Spy Number:  False

Software Testing Life Cycle (STLC)

VINOTH — Thu, 20 Aug 2026 11:05:02 +0000

The Software Testing Life Cycle (STLC) is a step-by-step process used by quality assurance teams to test software. It has six main phases: Requirement Analysis, Test Planning, Test Case Development, Test Environment Setup, Test Execution, and Test Closure.

1. Requirement Analysis:

Read the project rules and documents.
Find out what features to test.
Talk to the team if anything is unclear.

2. Test Planning:

Write down the test strategy and scope.
Guess how much time and money it will take.
Pick tools and assign tasks.

3. Test Case Development:

Write clear test steps and expected results.
Prepare test data.
Check the tests with team leads.

4. Test Environment Setup:

Build the hardware and software systems for testing.
Prepare test servers and databases.
Check if the environment is ready.

5. Test Execution:

Run the tests.
Match real results with expected results.
Write bug reports when things fail.

6. Test Closure:

Make sure all bugs are fixed or tracked.
Write a final test summary report.
Clean up the test area.

Python Practice Program

VINOTH — Wed, 19 Aug 2026 16:18:39 +0000

1) Write a Python program to check whether the next number after a given number is a prime number or not.

def find_prime(no):
    div = 2
    while div <= no//2:
        if no % div == 0:
            return False
        div+=1
    else:
        return True

prime1 = 7
prime2 = prime1+1

result = find_prime(prime1+1)

if result == True:
    print(result)

else:
    print(f"{prime2} is not a prime number.")

o/p:

8 is not a prime number.