DEV Community: Jeeva Aj

Methods in Java

Jeeva Aj — Thu, 31 Jul 2025 05:39:35 +0000

Method :

Set of instructions for achieving a specific-tasks - with a name (or) with or without arguments (or) with or without return datatype.
If we do not return any value, we should mention “void” before method name.
Modularity
Code Reusability

employee1.enquiry();
employee1.enquiry(1234);
}

private void enquiry(int accNo) {
    System.out.println("Balance enquiry");

}

private void enquiry() {
    System.out.println("General enquiry");

}

Same method name with different number of arguments is called Method overloading.

employee1.enquiry(15.3f);
private void enquiry(float gold) {
System.out.println("Gold rate please");
Same method name with different type of arguments is also known as Method overloading.
Another name called Compile time polymorphism.

Bank Project using Java

Jeeva Aj — Thu, 31 Jul 2025 05:38:03 +0000

Bank project:
New keyword allocates a memory space  bank employee1 = new bank ();
Bank => class
Syntax for object creation: class name ref.name = new class name ();
() => constructor
Object => employee
Employee  min balance, details, sat & sun leave details = called states
Employee  debit card, credit card, loan sanctions = called behaviour.
So, object is known as combination of states & behaviours.
Object is a memory reference of a class.
Object is a physical entity.
Object represents the class.
Object is an instance of a class. ( it occupies a space in the logic entity that is bank).
Example 1  Robot robot1
Robot.getGrocery (200); 1.getGrocery (packet owner-cash){}
( 200 ) => argument/parameter 2.getGrocery(bag grocery amount){}
getGrocery => method or actions

Cash => packet
Change => bag
200 => int
200.5 => float
Packet, bag, int, float are called containers because they occupy a storage.

Example 2  Robot getJuice (100);
Bottle.getJuice ( int amount){
1.amount
2.juice
Return juice
}
Example 3  getFood (200);
Bag.getFood ( int amount) {
1.amount
2.food
Return food
}

Action => getFood
200rs (input) => int
Here, robot deposited the amount but did not bring anything back to home. So it will call it as void. No return => void.

Our project code in eclipse for understanding:
package bank.loan;

public class Bank {

public static void main(String[] args) {

    Bank employee1 = new Bank(); //allocates a memory space
    employee1.deposit(100,1111); //method calling statement
    //method name: deposit
    //arguments: 2
    //arguments(100,1111)--> parameters

Storing container => bag

So, food is an action and the corresponding storage or datatype is bag. Write in a meaningful way that matches the corresponsing actions to container.

Example 4  robot.withdraw(1234);
Int Withdraw(int pin) {
1.
2.
Return amount
}
Here, returning amount will be an integer so it is called as int.

Example 5  robot.deposit (100);
Robot. Deposit (100, 12345);
void.deposit (int amnt, int accNo){
1.

}
int money = employee1.withdraw(100,1111);
System.out.println(money);

}

private int withdraw(int cash, int accno) {
return 100;

}

private void deposit(int amount, int accNo) //method signature
{
//method body or method definition
System.out.println ( "Deposit" + 100);
System.out.println ("in acc no:" + accNo);

}

}

Arrays in Java

Jeeva Aj — Thu, 31 Jul 2025 05:31:43 +0000

Arrays

Group of similar elements is called array. Array occupies continuous memory. Arrays are index based. Also unused memory filled with default values depending on the name of the datatype.

Int [ ] marks = new int [3];
Marks [0] = 80;
Marks [1] = 90;
Marks [2] = 100;
Int (i = 0, i<marks.length, i++){
System.out.println ( marks[i] );
}
Or
Int i = 0;
While (i<marks.length){
System.out.println ( marks[i] );
i++;
}

2-D Array
Int [ ] m1 = { 34, 47, 87 } ;
Int [ ] m2 = { 26, 76, 90 } ;
Int [ ] m3 = { 45, 64, 59 } ;
Int [ ] [ ] a = { m1, m2, m3 };

System.out.println ( a [0] [0] ); System.out.println ( a [1] [0] );
System.out.println ( a [0] [1] ); System.out.println ( a [1] [0] );
System.out.println ( a [0] [2] ); System.out.println ( a [1] [0] );
Int i = 0;
For ( j =0, j<3, j++ );
System.out.println ( a [i] [j] );
i++;
For ( j =0, j<3, j++ );
System.out.println ( a [i] [j] );
i++;
For ( j =0, j<3, j++ );
System.out.println ( a [i] [j] );
Or
For (i = 0, i<3, i++); {
For (j=0, j<3, j++);
{ System.out.println ( a [i] [j] ) + “ “ ); }
System.out.println ();
}

Output : 34 47 87
26 76 90
45 64 59

Control statements in Java

Jeeva Aj — Thu, 31 Jul 2025 05:28:29 +0000

Decision making  if else if, switch
Repetitive making  while do while for
Decision Making

int h1 = 170, h2 = 175;
if (h1>h2) {
System.out.println (h1);
}
else if (h2>h1) {
System.out.println (h2);
}
else {
System.out.println (“Same”);
}

Conditional statements:

If, if else, else, switch case, nested

Nested condition : if inside if inside if, can write n number of if and then else etc

Switch condition : case 1 break; case 2 break; case 3 break; finally default and print statement. Datatypes used: [ int, string, enum ]

2.Repetitive Making

While loop – Entry criteria looping

Int no =1; count =1;
While (count <= 5) {
System.out.println (no);
Count++;
}

Do while loop – Exit Criteria Looping

Int no =1; count =1;
Do{
System.out.println (no);
Count++;
While (count <= 5);
}

     For Loop
     Int no = 1;
    for (int count = 1, count <=10, count ++) {
    system.out.println (no);
    }

Operators in Java

Jeeva Aj — Thu, 31 Jul 2025 05:26:28 +0000

Operators  +, -, *, /, ++, --, etc.
Separators  all symbols that divide everything are called separators. Example: {}, [], comma, dot, (), etc.

Unary Operators

Increment Operator (Post)

Int no = 5;
System.out.println(no++);
Output = 5.

Decrement Operator (Post)

System.out.println(no--);
Output = 5.
Pre-increment operator

Int no = 5;
System.out.println(++no);
Output = 6.

Pre-decrement operator

System.out.println(--no);
Output = 4.
Pre-increment operator

Int no = 5;
System.out.println(++no);
Output = 6.

Pre-decrement operator

System.out.println(--no);
Output = 4.

How to create a project in Java?

Jeeva Aj — Thu, 31 Jul 2025 05:24:25 +0000

File  New  Java Project

Project names should be connected with underscores.

Java keywords always start with small letters. You can learn the keywords through oracle docs.com

Identifiers: Example: int no1  no1 is the identifier.

Always starts with alphabets
Starts with $ or _
No space or special characters should be allowed.

Objects & Classes in Java

Jeeva Aj — Thu, 31 Jul 2025 05:22:39 +0000

What are objects?

Objects are real-time entities. Entity means Porul in Tamil.
It is a combination of states & behaviors.

What is Class?

Class is a template or blueprint. It means logical entity.

How do we create an object in a class?

Class bike {
Bike active = new bike();
Bike pulsar = new bike();
}
Bike – Logical entity
Active – Physical entity
Class Actor {
Actor Rajni = new Actor();
Actor Vijay = new Actor();
}
Actor is a template for eg: dance, sing, act
Whereas Rajni is an object in the class named “actor” here.

File = Class
Folder = Package
Drive = Project

Java Datatypes

Jeeva Aj — Thu, 31 Jul 2025 05:19:58 +0000

What are Datatypes?

Data type is a reference variables used to identify the data inside the container.

Types of Datatypes

                      Primitive datatypes

Byte – It stores 1 bytes – 8bits – 2^8
Short – stores 2 bytes
Int – stores 4 bytes
Long – stores 8 bytes
Float – 2 bytes
Double – 4 bytes
Char – 2 bytes
Boolean – stores true or false value

                   Non-Primitive Datatypes

String, Array, Class, Interface

Features of Java Program

Jeeva Aj — Thu, 31 Jul 2025 05:18:28 +0000

Features of Java
• Java is platform independent
• Java is robust. Robust means powerful.
• Why is it powerful?
• Because java works in multiple platforms like linux, windows, etc
• Memory allocation and it will automatic collects the garbage
• Error handling or exceptional handling
• Java is secured because compile-time checks work perfectly
• No pointers concept in java and security APIs
• Java is distributed because it can be connected with two or three devices at the same time, but Java can be performed in multiple systems.
• Java is multithreading, which means it can perform without affecting any tasks and performs very fast
• Java is mainly an OOPs programming language [class, objects, inheritance, polymorphism, abstraction, encapsulation, interface].

Java—Oops Concept

Jeeva Aj — Wed, 16 Jul 2025 07:11:53 +0000

Object means a real-world entity such as a mobile, book, table, computer, watch, etc. Object-Oriented Programming is a methodology or paradigm to design a program using classes and objects. It simplifies software development and maintenance by providing some concepts.

Java OOPs (Object-Oriented Programming) Concepts

Class
Object
Inheritance
Polymorphism
Abstraction
Encapsulation

Class

In object-oriented programming, a class is a blueprint from which individual objects are created (or, we can say a class is a data type of an object type). In Java, everything is related to classes and objects. Each class has its methods and attributes that can be accessed and manipulated through the objects.

Examples of Class

If you want to create a class for students. In that case, "Student" will be a class, and student records (like student1, student2, etc.) will be objects.

// create a Student class
public class Student {
// Declaring attributes
String name;
int rollNo;
String section;

// initialize attributes
Student(String name, int rollNo, String section){
this.name= name;
this.rollNo = rollNo;
this.section = section;
}
// print details

public void printDetails() {
System.out.println("Student Details:");
System.out.println(this.name+ ", "+", " + this.rollNo + ", " + section);
}
}

Object

In object-oriented programming, an object is an entity that has two characteristics (states and behavior). Some of the real-world objects are books, mobiles, tables, computers, etc. An object is a variable of the type class; it is a basic component of an object-oriented programming system. A class has the methods and data members (attributes); these methods and data members are accessed through an object. Thus, an object is an instance of a class.

Example of Objects

Continuing with the example of students, let's create some students as objects and print their details.

// create a Student class
public class Student {
// Declaring attributes
String name;
int rollNo;
String section;

// initialize attributes
Student(String name, int rollNo, String section){
this.name= name;
this.rollNo = rollNo;
this.section = section;
}
// print details

public void printDetails() {
System.out.print("Student Details: ");
System.out.println(this.name+ ", " + this.rollNo + ", " + section);
}

public static void main(String[] args) {
// create student objects

Student student1 = new Student("Robert", 1, "IX Blue");
Student student2 = new Student("Adam", 2, "IX Red");
Student student3 = new Student("Julie", 3, "IX Blue");

  // print student details
  student1.printDetails();
  student2.printDetails();
  student3.printDetails();

}
}

Inheritance

In object-oriented programming, inheritance is a process by which we can reuse the functionalities of existing classes to new classes. In the concept of inheritance, there are two terms base (parent) class and derived (child) class. When a class is inherited from another class (base class), it (derived class) obtains all the properties and behaviors of the base class.

Example of Inheritance
Continuing with the example of students, let's make student a derived class of person class. Person class will have a single field name and student class will inherit the same as shown below:

// base class for all students
class Person {
String name;

Person(String name){
this.name = name;
}
}

// create a Student class
public class Student extends Person {
// Declaring attributes
int rollNo;
String section;

// initialize attributes
Student(String name, int rollNo, String section){
super(name);
this.rollNo = rollNo;
this.section = section;
}
// print details

public void printDetails() {
System.out.print("Student Details: ");
System.out.println(this.name+ ", " + this.rollNo + ", " + section);
}

  // print student details
  student1.printDetails();
  student2.printDetails();
  student3.printDetails();

}
}

Polymorphism

The term "polymorphism" means "many forms". In object-oriented programming, polymorphism is useful when you want to create multiple forms with the same name of a single entity. To implement polymorphism in Java, we use two concepts method overloading and method overriding.

The method overloading is performed in the same class where we have multiple methods with the same name but different parameters, whereas, the method overriding is performed by using the inheritance where we can have multiple methods with the same name in parent and child classes.

Example of Polymorphism

Continuing with the example of students, let's add another method printDetails() with additional parameter to modify the behavior of the method.

// create a Student class
public class Student {
// Declaring attributes
String name;
int rollNo;
String section;

// initialize attributes
Student(String name, int rollNo, String section){
this.name= name;
this.rollNo = rollNo;
this.section = section;
}
// print details

public void printDetails() {
System.out.print("Student Details: ");
System.out.println(this.name+ ", " + this.rollNo + ", " + section);
}

// print details without section if required

public void printDetails(boolean hideSection) {
System.out.print("Student Details: ");
System.out.println(this.name+ ", " + this.rollNo + ", " + (hideSection ? "" : section));
}

  // print student details
  student1.printDetails();
  student2.printDetails(true);
  student3.printDetails(false);

}
}

Abstraction

In object-oriented programming, an abstraction is a technique of hiding internal details and showing functionalities. The abstract classes and interfaces are used to achieve abstraction in Java.

The real-world example of an abstraction is a Car, the internal details such as the engine, process of starting a car, process of shifting gears, etc. are hidden from the user, and features such as the start button, gears, display, break, etc are given to the user. When we perform any action on these features, the internal process works.

Example of Abstraction

Let's create an Abstract Vehicle class and Car extending the Vehicle class. Vehicle will abstract away internal functionalities.

abstract class Vehicle {
public void startEngine() {
System.out.println("Engine Started");
}
}
public class Car extends Vehicle {
private String color;

public Car(String color) {
this.color = color;
}

public void printDetails() {
System.out.println("Car color: " + this.color);
}

public static void main(String[] args) {
Car car = new Car("White");

  car.printDetails();
  car.startEngine();

}
}

Encapsulation

In an object-oriented approach, encapsulation is a process of binding the data members (attributes) and methods together. The encapsulation restricts direct access to important data. The best example of the encapsulation concept is making a class where the data members are private and methods are public to access through an object. In this case, only methods can access those private data.

Example of Objects

Continuing with the example of students, let's create some students as objects and print their details.

// create a Student class
public class Student {
// Declaring private attributes
private String name;
private int rollNo;
private String section;

// initialize attributes
Student(String name, int rollNo, String section){
this.name= name;
this.rollNo = rollNo;
this.section = section;
}
// print details

public void printDetails() {
System.out.print("Student Details: ");
System.out.println(this.name+ ", " + this.rollNo + ", " + section);
}

  // print student details
  student1.printDetails();
  student2.printDetails();
  student3.printDetails();

}
}

Advantages of Java OOPs

The following are the advantages of using the OOPs in Java:

The implementations of OOPs concepts are easier.
The execution of the OOPs is faster than procedural-oriented programming.
OOPs provide code reusability so that a programmer can reuse an existing code.
OOPs help us to keep the important data hidden.

TBC...

Java features an Overview

Jeeva Aj — Thu, 10 Jul 2025 17:04:44 +0000

Java is a high-level, object-oriented programming language. This language is very easy to learn and widely used. It is known for its platform independence, reliability, and security. It follows one principle, that is, the "Write Once, Run Anywhere" principle. It supports various features like portability, robustness, simplicity, multithreading, and high performance, which makes it a popular choice for beginners as well as for developers.

Simple Syntax

Java syntax is very straightforward and very easy to learn. Java removes complex features like pointers and multiple inheritance, which makes it a good choice for beginners.

Example: Basic Java Program

import java.io.*;

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

2.2. Object-Oriented

Java is a pure object-oriented language. It supports core OOP concepts like,

Class
Objects
Inheritance
Encapsulation
Abstraction
Polymorphism

Example: The below Java program demonstrates the basic concepts of OOPs.

// Java program to demonstrate the basic concepts of oops
// like class, object, constructor, and method
import java.io.*;

class Student {
int age;
String name;
public Student(int age, String name)
{
this.age = age;
this.name = name;
}

// This method display the details of the student
void display()
{
    System.out.println("Name is: " + name);
    System.out.println("Age is: " + age);      
}

}

class Geeks {
public static void main(String[] args)
{
Student student = new Student(22, "GFG");
student.display();
}
}

Platform Independent

Java is platform-independent because of the Java Virtual Machine (JVM).

When we write Java code, it is first compiled by the compiler and then converted into bytecode (which is platform-independent).
This byte code can run on any platform that has JVM installed.

Interpreted

Java code is not directly executed by the computer. It is first compiled into bytecode. This byte code is then understood by the JVM. This enables Java to run on any platform without rewriting code.

Scalable

Java can handle both small- and large-scale applications. Java provides features like multithreading and distributed computing that allow developers to manage loads more easily.

Portable

When we write a Java program, the code first gets converted into bytecode, and this bytecode does not depend on any operating system or any specific computer. We can simply execute this bytecode on any platform with the help of JVM. Since JVMs are available on most devices,we can run the same Java program on different platforms.

Secured and Robust

Java is a reliable programming language because it can catch mistakes early while writing the code and also keeps checking for errors when the program is running. It also has a feature called exception handling that helps deal with unexpected problems smoothly.

Memory Management

Memory management in Java is automatically handled by the Java Virtual Machine (JVM).

The Java garbage collector reclaims memory from objects that are no longer needed.
Memory for objects are allocated in the heap
Method calls and local variables are stored in the stack.

High Performance

Java is faster than old interpreted languages. A Java program is first converted into bytecode, which is faster than interpreted code. It is slower than fully compiled languages like C or C++ because of the interpretation and JIT compilation process. Java performance is improved with the help of Just-In-Time (JIT) compilation, which makes it faster than many interpreted languages but not as fast as fully compiled languages.

Multithreading

Multithreading in Java allows multiple threads to run at the same time.

It improves CPU utilization and enhances performance in applications that require concurrent task execution.
Multithreading is especially important for interactive and high-performance applications, such as games and real-time systems.
Java provides built-in support for managing multiple threads. A thread is known as the smallest unit of execution within a process.

Example: Basic Multithreading in Java

// Java program to demonstrate multithreading
class MyThread extends Thread {

public void run() {

    System.out.println("Thread is running...");
}

}

public class Geeks {

public static void main(String[] args) {
    MyThread thread = new MyThread();

    // Starts the thread
    thread.start();  
}

}

These are some of the features of Java that I have learned in my class today. Thank you for reading my blog. See you all with my next topic!!

JAVASCRIPT - DOM

Jeeva Aj — Thu, 29 May 2025 19:55:36 +0000

In JavaScript, DOM (Document Object Model) manipulation is essential for interacting with and changing HTML elements on a webpage. Here’s a simple guide to selecting, updating, creating, and removing elements using JavaScript:

📌 1. Select Elements

You can select HTML elements using several methods:

// Select by ID
let title = document.getElementById("main-title");

// Select by class
let items = document.getElementsByClassName("item");

// Select by tag
let paragraphs = document.getElementsByTagName("p");

// Modern method - querySelector (returns the first match)
let firstItem = document.querySelector(".item");

// querySelectorAll (returns all matches as a NodeList)
let allItems = document.querySelectorAll(".item");

📝 2. Update Elements

You can change text, attributes, styles, and more:

// Change text content
title.textContent = "Updated Title";

// Change inner HTML
title.innerHTML = "New HTML Content";

// Change an attribute
title.setAttribute("class", "highlighted");

// Change styles directly
title.style.color = "red";
title.style.fontSize = "24px";

🛠️ 3. Create Elements

To create a new element:

// Create a new element
let newDiv = document.createElement("div");

// Add content
newDiv.textContent = "I am a new div";

// Add class
newDiv.classList.add("new-box");

// Append to body or any other parent
document.body.appendChild(newDiv);

❌ 4. Remove Elements

To remove an existing element:

// Select the element
let unwanted = document.querySelector(".remove-me");

// Remove it from the DOM
unwanted.remove();

For older browsers:

unwanted.parentNode.removeChild(unwanted);

✅ Summary Table:

Action Method Example

Select document.querySelector("#id")
Update element.textContent = "Hello"
Create document.createElement("div")
Remove element.remove()

Thank you for reading my blog today. See ya tomorrow.