DEV Community: MOHAMED ABDULLAH

Introduction to HTML

MOHAMED ABDULLAH — Tue, 08 Jul 2025 13:28:46 +0000

HTML (HyperText Markup Language) is the standard language used to create webpages. It tells the browser how to display text, images, links, and other content on a webpage.

HTML is not a programming language; it's a markup language. It uses tags to describe the structure of content.

Basic Structure of an HTML Page

<!DOCTYPE html>

Payilagam Official Webpage

Welcome to My Website

This is my first webpage using HTML!

<!DOCTYPE html>: Declares that this is an HTML5 document.

: The root element of an HTML page.

: Contains meta-information like the title. : Contains the visible content on the page

Tag	Description
`<h1>` to `<h6>`	Headings (h1 is the largest, h6 is the smallest)
`<p>`	Paragraph
`<a href="">`	Anchor (link to other pages or websites)
`<img src="">`	Displays an image
`<ul>`, `<ol>`, `<li>`	Lists: unordered, ordered, and list items
`<div>`	A container used to group elements
`<br>`	Line break

HTTP vs HTTPS

When visiting websites, you may notice URLs starting with http:// or https://. Let’s understand the difference:

HTTP (HyperText Transfer Protocol)
Protocol used to transfer data over the web.

Data is not encrypted, which means it's less secure.

Suitable for non-sensitive browsing like reading blogs or news.

HTTPS (HTTP Secure)
The secure version of HTTP.

Uses SSL/TLS encryption to protect data between your browser and the server.

Ensures data privacy, integrity, and security.

Indicated by a padlock icon 🔒 in the browser address bar.

🔐 Always prefer HTTPS for logging in, online payments, or sensitive transactions.

What Happens When You Visit an HTML Page?
You enter a URL (like https://example.com).

The browser sends an HTTP/HTTPS request to the web server.

The server responds with an HTML page.

The browser renders the HTML into visual content.

Official HTML Reference :

    1 : https://www.w3.org/TR/html/

Arrays in Java

MOHAMED ABDULLAH — Fri, 27 Jun 2025 10:00:16 +0000

In Java, an array is a powerful and foundational data structure that allows to store multiple values of the same type in a single variable. Arrays provide a systematic way to manage large collections of data efficiently, especially when the number of elements is known in advance.

An array in Java is a container object that holds a fixed number of elements of a single data type. Each element in the array is accessed using its index, which starts from 0.

Syntax:

dataType[] arrayName = new dataType[size];

Example:

int[] scores = new int[5]; // Declaration with size 5
scores[0] = 85;

Types of Arrays
Java supports two primary types of arrays:

Single-Dimensional Arrays

A linear list of elements.

Example: int[] numbers = {1, 2, 3, 4};

Multi-Dimensional Arrays

Arrays of arrays (e.g., 2D arrays or matrices).

Example: int[][] matrix = new int[3][3];

Array Initialization Methods

Static Initialization:
String[] fruits = {"Apple", "Banana", "Cherry"};

Dynamic Initialization:
double[] prices = new double[3];
prices[0] = 9.99;

Accessing Array Elements

Elements are accessed by their index position:

System.out.println(scores[2]); // Prints the 3rd element

Common Operations on Arrays
Traversal using for or for-each loop

Sorting using Arrays.sort(array)

Searching using Arrays.binarySearch(array, key)

Cloning with array.clone()

public class ArrayExample {
public static void main(String[] args) {
int[] numbers = {10, 20, 30, 40, 50};

    for (int i = 0; i < numbers.length; i++) {
        System.out.println("Element at index " + i + ": " + numbers[i]);
    }
}

}

OUTPUT:
Element at index 0: 10
Element at index 1: 20
Element at index 2: 30
Element at index 3: 40
Element at index 4: 50

Key Characteristics
Arrays in Java are objects.

The length of an array is fixed and cannot be changed once declared.

The property array.length gives the total number of elements.

Java automatically initializes array elements with default values:

0 for numeric types

false for boolean

null for reference types

Official reference link:
1 :https://docs.oracle.com/javase/tutorial/java/nutsandbolts/arrays.html

8 key features of Java

MOHAMED ABDULLAH — Mon, 23 Jun 2025 12:42:45 +0000

Object-Oriented
Everything in Java is treated as an object.

Supports concepts like Encapsulation, Inheritance, Polymorphism, and Abstraction.

Platform Independent
Java code is compiled into bytecode, which runs on any system that has a Java Virtual Machine (JVM).

"Write Once, Run Anywhere" (WORA) capability.

Simple and Easy to Learn
Syntax is clean and similar to C/C++ but removes complex features like pointers and operator overloading.

Secure
No direct memory access (no pointers).

Uses bytecode verification, exception handling, and access modifiers for secure execution.

Robust
Strong memory management (Garbage Collection).

Exception handling and type checking help build reliable applications.

Multithreaded
Supports multiple threads of execution using the Thread class or Runnable interface.

Helps in developing concurrent and responsive applications.

High Performance
Although slower than C/C++, Java’s performance is improved using JIT (Just-In-Time) compiler.

Distributed
Java provides APIs like RMI (Remote Method Invocation) and Socket Programming to build distributed systems (network-based applications).

prime numbers in java

MOHAMED ABDULLAH — Fri, 20 Jun 2025 12:05:32 +0000

A prime number is a number greater than 1 that has only two factors 1 and itself.

For example:

5 is prime → factors: 1, 5

6 is not prime → factors: 1, 2, 3, 6

a Java program to print whether each number from 150 to 300 is a prime number or not.

public class Numbers {

// Method to check if a number is prime
public void CheckPrime(int j) {
    int i = 1;          // Start checking from 1
    int count = 0;      // Counter to count number of factors

    while (i <= j) {
        if (j % i == 0) {       // If j is divisible by i
            count = count + 1;  // Increase the count
        }
        i++;                    // Move to next i
    }

    // After loop ends, check if the number has exactly 2 factors
    if (count == 2) {
        System.out.println(j + " is a prime number");
    } else {
        System.out.println(j + " is not a prime number");
    }
}

// Main method to check numbers from 150 to 300
public static void main(String[] args) {
    Numbers num = new Numbers(); // Create object of the class
    int j = 150;

    while (j <= 300) {
        num.CheckPrime(j); // Call the CheckPrime method
        j++;               // Move to the next number
    }
}

}

OUTPUT Sample:

150 is not a prime number

151 is a prime number

152 is not a prime number

...

199 is a prime number

...

300 is not a prime number

Step-by-Step Explanation

public void CheckPrime(int j)
A method that takes one number j and checks if it is prime.

Uses a while loop to check how many numbers divide j completely (using j % i == 0).

If count == 2, it's a prime number.

Loop from 150 to 300

int j = 150;
while (j <= 300) {
num.CheckPrime(j);
j++;
}
This loop goes through each number from 150 to 300, calling the CheckPrime() method on each value of j.

Sum of Digits in Java

MOHAMED ABDULLAH — Thu, 19 Jun 2025 11:34:50 +0000

What is "Sum of Digits"?
The Sum of Digits of a number means adding all individual digits of that number.

Example:

Input: 123

Calculation: 1 + 2 + 3 = 6

Key Concepts Used

Concept Description
Modulo % Gives the last digit of a number. 123 % 10 = 3
Division / Removes the last digit. 123 / 10 = 12
Loops Used to keep dividing and summing digits until the number
becomes 0
Type Works best with int, but can be extended to long,
BigInteger, etc.

Algorithm Steps
Initialize a variable to store the sum (e.g., sum = 0)

Use a while loop to repeat until the number becomes 0

In each iteration:

Get the last digit using number % 10

Add the digit to sum

Remove the last digit using number = number / 10

Print or return the result

example:

public class SumOfDigits {

public static void main(String[] args) {
    int number = 12345; // Example input
    int sum = 0;

    while (number != 0) {
        int digit = number % 10; // Get last digit
        sum += digit;            // Add to sum
        number = number / 10;    // Remove last digit
    }

    System.out.println("Sum of digits: " + sum);
}

}

flag Using boolean in Java

MOHAMED ABDULLAH — Wed, 18 Jun 2025 10:55:11 +0000

In Java programming, a flag is often a boolean variable (true or false) used to track or control the flow of logic in loops and conditions.

It's like raising a "red flag" to say something happened.

What is a Flag?

A flag is a temporary indicator.

It’s usually declared like this:

boolean flag = true; // or false

We change this flag based on a condition, then check its value after a loop or block to decide what to do next.

STRUCTURE:

// 1. Declare and initialize
boolean flag = true; // or false

// 2. Run your loop or logic
while (condition) {
if (someConditionIsMet) {
flag = false; // or true
break;
}
}

// 3. Use the flag in if-else
if (flag) {
// Do something if the flag is true
} else {
// Do something else if the flag is false
}

exapmle :

public class PrimeChecker {
public static void main(String[] args) {
int num = 29;
int i = 2;
boolean flag = true; // Assume prime

    while (i <= num / 2) {
        if (num % i == 0) {
            flag = false; // Found a factor, not prime
            break;
        }
        i++;
    }

    if (flag && num > 1) {
        System.out.println(num + " is a prime number");
    } else {
        System.out.println(num + " is not a prime number");
    }
}

}

output :

29 is a prime number

reference link:
1: https://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html

2: https://docs.oracle.com/javase/tutorial/java/nutsandbolts/while.html

while Loop in Java

MOHAMED ABDULLAH — Fri, 13 Jun 2025 15:55:53 +0000

What is a while Loop?

A while loop is used to repeat a block of code as long as a specified condition is true. It checks the condition before executing the loop body, which makes it an entry-controlled loop.

structure:
initialization; // Step 1

while (condition) { // Step 2
// code block to be executed // Step 3

increment/decrement;  // Step 4

}
public class WhileExample {
public static void main(String[] args) {
int i = 1; // Initialization

    while (i <= 5) { // Condition
        System.out.println(i); // Code block
        i++; // Increment – very important!
    }
}

}

Explanation of the 4 Parts:

Initialization: int i = 1;

Condition: i <= 5

Action (body): System.out.println(i);

Increment/Decrement: i++ (so the loop moves forward)

Without Increment/Decrement – Infinite Loop Danger

int i = 1;

while (i <= 5) {
System.out.println(i); // No increment here
}
This will print 1 forever! Because i never changes, the condition i <= 5 stays true

With Decrement Example – Countdown

int count = 5;

while (count > 0) {
System.out.println("Countdown: " + count);
count--; // Decrement
}

reference link :

1: https://docs.oracle.com/javase/tutorial/java/nutsandbolts/while.html

How to Use .gitignore in Git

MOHAMED ABDULLAH — Fri, 13 Jun 2025 11:10:19 +0000

When working with Git, you might have files (like .class, .log, or temp files) that you don’t want to upload to GitLab or GitHub. That’s where .gitignore comes in handy.

What is .gitignore?
The .gitignore file tells Git which files or folders to ignore (not track).

How to Set Up .gitignore

Create a .gitignore file In your project root folder (same place where .git is), create a new file:

.gitignore

Add file patterns to ignore
Example .gitignore:

*.class # ignore all Java compiled class files
*.log # ignore all log files
/temp/ # ignore temp folder

Remove already tracked files (if needed)

If .class files are already tracked, Git won't ignore them just by adding to .gitignore.

Run this to remove them from tracking:

git rm --cached *.class

Commit and push

git add .gitignore
git commit -m "Added .gitignore file"

git push
Done! Git will now ignore those files in future commits.

referel links :

1 :Link: https://git-scm.com/docs/gitignore
2 : Link: https://github.com/github/gitignore

if-else in Java

MOHAMED ABDULLAH — Wed, 11 Jun 2025 06:05:05 +0000

In Java programming, making decisions is essential. That’s where if-else statements come in! They help your program make choices based on certain conditions.

if-else is a control flow statement that tells your program:

“Do this if a condition is true. Otherwise, do something else.”

Syntax of if-else in Java

if (condition) {
// Executes if condition is true
} else {
// Executes if condition is false
}

example :

public class Bignumber {
int a ;
int b ;

Bignumber (int a, int b){
 this.a = a;
 this.b = b;

}
public void findbig (){
    if (a>b){
        System.out.println("a is big ");
    }
    else{
        System.out.println("b is big");
    }
}
public static void main(String[] args) {
    Bignumber big = new Bignumber(100,200 );
    big.findbig();

}

}

output:

b is big

if-else-if is a control flow statement that allows your program to choose between multiple conditions.

It tells your program:

“Check this first. If it’s true, do it.
If not, check the next one.
If nothing is true, do the final else.”

Syntax of if-else-if in Java

if (condition1) {
// Executes if condition1 is true
} else if (condition2) {
// Executes if condition2 is true
} else {
// Executes if none are true
}

EXAMPLE:

public class Bignumber {
int a;
int b;
int c;

Bignumber(int a, int b, int c) {
    this.a = a;
    this.b = b;
    this.c = c;
}

public void findbig() {
    if (a > b && a > c) {
        System.out.println("a is big");
    } else if (b > a && b > c) {
        System.out.println("b is big");
    } else if (c > a && c > b) {
        System.out.println("c is big");
    } 

}

public static void main(String[] args) {
    Bignumber big = new Bignumber(100, 200, 150);
    big.findbig();
}

}

Output:

b is big

referel links :

1 : https://docs.oracle.com/javase/tutorial/java/nutsandbolts/if.html
2 : https://docs.oracle.com/javase/specs/jls/se17/html/jls-14.html#jls-14.9

swapping

MOHAMED ABDULLAH — Wed, 11 Jun 2025 05:50:52 +0000

Swapping means exchanging the values of two variables.
For example:

Before swap: a = 10, b = 20

After swap: a = 20, b = 10

public class Swapping {

int a ;
int b ;

Swapping (int a , int b ){

    this.a = a;
    this.b = b;


}

public void swap(){
    int temp;
     temp  = a ;
    a = b ;
     b = temp ;

}
public static void main(String[] args) {
    Swapping big = new Swapping (10,20);
   System.out.println("before swap");
   System.out.println(big.a);
   System.err.println(big.b);
   big.swap();
    System.out.println("after swap");
   System.out.println(big.a);
   System.err.println(big.b);
}

}

Explanation
int a, b: These are instance variables used to store the values.

Swapping(int a, int b): This is a constructor that sets the initial values of a and b.

swap(): A method that uses a temporary variable to swap the values of a and b.

main(): The program execution starts here. It creates an object and demonstrates the swap.

Output

Before swap:
a = 10
b = 20

After swap:
a = 20
b = 10

Encapsulation

MOHAMED ABDULLAH — Tue, 10 Jun 2025 06:04:52 +0000

Encapsulation is the process of hiding the internal details of a class and only showing essential information through methods. It’s like putting important data inside a capsule and giving access through controlled ways.

Key Features of Encapsulation

Data members (variables) are marked private

Access to them is given through public getter and setter methods

Helps to maintain control over data

Improves modularity and code security

Structure of Encapsulation

class ClassName {
// 1. Private variables (hidden from outside)
private DataType variable;

// 2. Public getter method
public DataType getVariable() {
    return variable;
}

// 3. Public setter method
public void setVariable(DataType value) {
    this.variable = value;
}

}

Benefits of Encapsulation

Security Data is not directly accessible by outside classes

Control You decide how data is accessed or modified

Flexibility Easy to change one part of the code without affecting
others

Reusability Encapsulated classes are easier to reuse in otherprograms

EXAMPLE:

public class Student {
private String name;
private int age;

// Getter for name
public String getName() {
    return name;
}

// Setter for name
public void setName(String name) {
    this.name = name;
}

// Getter for age
public int getAge() {
    return age;
}

// Setter for age
public void setAge(int age) {
    this.age = age;
}

}
public class Main {
public static void main(String[] args) {
Student student = new Student();
student.setName("Abdullah");
student.setAge(22);

    System.out.println("Student Name: " + student.getName());
    System.out.println("Student Age: " + student.getAge());
}

}
output:

Student Name: Abdullah
Student Age: 22

referel links :

1 : https://docs.oracle.com/javase/tutorial/java/javaOO/encaps.html
2 : https://www.w3schools.com/java/java_encapsulation.asp

Constructor

MOHAMED ABDULLAH — Fri, 06 Jun 2025 05:17:58 +0000

Constructors are special methods in Java used to initialize objects. Unlike regular methods, constructors have the same name as the class and do not have a return type.

A constructor is automatically called when an object is created. It sets initial values for object attributes.

Key Points:
Constructor name = class name

No return type (not even void)

Called automatically when an object is created

Can be default, no-argument, or parameterized

Default Constructor (Provided by Compiler)
Explanation:
If you don’t write any constructor, Java automatically adds a no-argument constructor called the default constructor.

It does nothing but allows object creation.

When to use:
When no special initialization is needed for the object.

Default Constructor (Provided by Compiler) Structure: You don’t need to write this. If no constructor is defined, Java will create this for you behind the scenes.

structure:

class MyClass {
// No constructor defined, so compiler adds:
// MyClass() { }
}

Used like this:

MyClass obj = new MyClass(); // compiler-created default constructor

Example:

class Book {
void show() {
System.out.println("This is a book.");
}
}

public class Main {
public static void main(String[] args) {
Book b1 = new Book(); // default constructor is used
b1.show();
}
}

Output:
This is a book.

No-Argument Constructor (User-defined) Explanation: This is a constructor you write yourself with no parameters.

You can add custom logic inside it (like printing or initializing values).

When to use:
When you want to execute some logic when the object is created, but no input is needed.
Structure:

class MyClass {
MyClass() {
// constructor body
System.out.println("No-arg constructor called");
}
}
Used like this:

MyClass obj = new MyClass(); // calls no-arg constructor

Example:

class Car {
Car() {
System.out.println("Car is ready!");
}
}

public class Main {
public static void main(String[] args) {
Car c1 = new Car(); // no-arg constructor is called
}
}

Output:

Car is ready!

Parameterized Constructor Explanation: This constructor accepts parameters so you can initialize object variables during object creation.

Useful for setting different values for different objects.

When to use:
When you want to assign values to object fields at the time of creation.

Parameterized Constructor
Structure:

class MyClass {
int x;

MyClass(int value) {
    x = value;
}

}
Used like this:

MyClass obj = new MyClass(10); // calls parameterized constructor

Example:

class Student {
String name;
int age;

Student(String n, int a) {
    name = n;
    age = a;
}

void display() {
    System.out.println("Name: " + name + ", Age: " + age);
}

}

public class Main {
public static void main(String[] args) {
Student s1 = new Student("Abdullah", 22);
s1.display();
}
}

Output:

Name: Abdullah, Age: 22

reference link 1 :
https://docs.oracle.com/javase/tutorial/java/javaOO/constructors.html

reference link 2:
https://docs.oracle.com/javase/specs/jls/se17/html/jls-8.html#jls-8.8

reference link 3 :
https://www.geeksforgeeks.org/constructors-in-java/