INDEX

S.No. Topic

1. Sum of first 10 natural numbers

2. Calculate the Area of Rectangle and the Area of the

circle

3. Implementing static functions and static methods

4. Calculate the perimeter of Circle, Rectangle and

Square

5. Implement the Abstract class

6. Program to show the Access Specifiers in Java

7. Implement the Dynamic Method Dispatch in Java

8. Implementing the final variable and final class in

java

9. Java program implementing the var args

10. Java Program implementing the Exception Handling code

11. Java Program to implement the String operations

12. Program to copy bytes from one file to another file.

13. Program to read bytes from the file and display the
content on the screen.

14. Stream class to copy the contents of a file from one

to another

15. Multi Thread program in which every thread increment

the shared variable

16. Create a package and use it

1. Program to give sum of first 10 natural numbers.

Code:-

public class SumOfNaturalNumbers {

public static void main(String[] args) {
int sum = 0;
int n = 10; // Number of natural numbers to sum up

for (int i = 1; i <= n; i++) {

sum += i;
}

System.out.println("The sum of the first " + n + " natural numbers

is: " + sum);
}
}

Output:-

2. Program to calculate the Area of Rectangle and the Area of the circle.

Code:-

public class SimpleAreaCalculator {

public static void main(String[] args) {

double length = 5.0; // Length of the rectangle

double width = 3.0; // Width of the rectangle

// Calculate the area of the rectangle

double rectangleArea = length * width;
 System.out.println("The area of the rectangle is: " +
rectangleArea);

// Predefined value for the circle

double radius = 4.0; // Radius of the circle

// Calculate the area of the circle

double circleArea = 3.14 * radius * radius;
System.out.println("The area of the circle is: " + circleArea);
}
}

Output:-

3. Program implementing static functions and static methods.

Code:-

public class StaticExample {

// Static variable
static int counter = 0;

// Static method to increment the counter

public static void incrementCounter() {
counter++;
}

// Static method to display the counter

public static void displayCounter() {
 System.out.println("Counter value: " + counter);
}

public static void main(String[] args) {

// Call static methods
StaticExample.incrementCounter();
StaticExample.displayCounter();

StaticExample.incrementCounter();
StaticExample.displayCounter();
}
}

Output:-

4. Program to calculate the perimeter of Circle, Rectangle and Square.

Code:-

public class PerimeterCalculator {

// Method to calculate the perimeter of a rectangle

public static double calculateRectanglePerimeter(double length, double
width) {
return 2 * (length + width);
}

// Method to calculate the perimeter of a square

public static double calculateSquarePerimeter(double side) {
return 4 * side;
 }

// Method to calculate the perimeter of a circle

public static double calculateCirclePerimeter(double radius) {
return 2 * Math.PI * radius;
}

public static void main(String[] args) {

// Predefined values
double length = 5.0; // Length of the rectangle
double width = 3.0; // Width of the rectangle
double side = 4.0; // Side of the square
double radius = 6.0; // Radius of the circle

// Calculate and display the perimeters

double rectanglePerimeter = calculateRectanglePerimeter(length,
width);
System.out.println("The perimeter of the rectangle is: " +
rectanglePerimeter);

double squarePerimeter = calculateSquarePerimeter(side);

System.out.println("The perimeter of the square is: " +
squarePerimeter);

double circlePerimeter = calculateCirclePerimeter(radius);

System.out.println("The perimeter of the circle is: " +
circlePerimeter);
}
}

Output:-
5. Program to implement the Abstract class.

Code:-

abstract class Shape {

// Abstract method for calculating the area
abstract double calculateArea();

// Abstract method for calculating the perimeter

abstract double calculatePerimeter();

// Concrete method for displaying shape details

public void display() {
System.out.println("Area: " + calculateArea());
System.out.println("Perimeter: " + calculatePerimeter());
}
}

// Subclass Rectangle extending Shape

class Rectangle extends Shape {
private double length;
private double width;

public Rectangle(double length, double width) {

this.length = length;
this.width = width;
}

// Implementing the abstract method calculateArea

@Override
double calculateArea() {
return length * width;
}

// Implementing the abstract method calculatePerimeter

@Override
double calculatePerimeter() {
return 2 * (length + width);
}
}
// Subclass Circle extending Shape
class Circle extends Shape {
private double radius;

public Circle(double radius) {

this.radius = radius;
}

// Implementing the abstract method calculateArea

@Override
double calculateArea() {
return Math.PI * radius * radius;
}

// Implementing the abstract method calculatePerimeter

@Override
double calculatePerimeter() {
return 2 * Math.PI * radius;
}
}

public class AbstractClassExample {

public static void main(String[] args) {
// Create a rectangle and a circle
Shape rectangle = new Rectangle(5.0, 3.0);
Shape circle = new Circle(4.0);

// Display the details of the rectangle

System.out.println("Rectangle:");
rectangle.display();

// Display the details of the circle

System.out.println("Circle:");
circle.display();
}
}
Output:-

6. Program to show the Access Specifiers in Java

Code:-

class AccessSpecifierExample {
// Public variable - accessible from anywhere
public int publicVar = 10;

protected int protectedVar = 20;

private int privateVar = 30;

int defaultVar = 40;

// Public method - accessible from anywhere

public void showPublic() {
System.out.println("Public Method. PublicVar: " + publicVar);
}

// Protected method - accessible within the same package and subclasses

protected void showProtected() {
System.out.println("Protected Method. ProtectedVar: " +
protectedVar);
}

// Private method - accessible only within this class

 private void showPrivate() {
System.out.println("Private Method. PrivateVar: " + privateVar);
}

// Package-private (default) method - accessible within the same

package
void showDefault() {
System.out.println("Default Method. DefaultVar: " + defaultVar);
}

// Method to demonstrate access to private method

public void accessPrivate() {
showPrivate();
}
}

// Another class in the same package

public class AccessSpecifierDemo {
public static void main(String[] args) {
AccessSpecifierExample example = new AccessSpecifierExample();

// Accessing public variable and method

System.out.println("Public Variable: " + example.publicVar);
example.showPublic();

// Accessing protected variable and method

System.out.println("Protected Variable: " + example.protectedVar);
example.showProtected();

// Accessing private method through a public method

example.accessPrivate();

// Accessing default/package-private variable and method

System.out.println("Default Variable: " + example.defaultVar);
example.showDefault();
}
}

Output:-
7. Program to Implement the Dynamic Method Dispatch in Java

Code :-

// Superclass
class Animal {
// Overridden method
void sound() {
System.out.println("Animal makes a sound");
}
}

// Subclass Dog
class Dog extends Animal {
// Overriding method
@Override
void sound() {
System.out.println("Dog barks");
}
}

// Subclass Cat
class Cat extends Animal {
// Overriding method
@Override
void sound() {
System.out.println("Cat meows");
}
}

public class DynamicMethodDispatch {

public static void main(String[] args) {
// Reference of type Animal and object of type Animal
Animal myAnimal = new Animal();
myAnimal.sound(); // Outputs: Animal makes a sound

// Reference of type Animal and object of type Dog

myAnimal = new Dog();
myAnimal.sound(); // Outputs: Dog barks

// Reference of type Animal and object of type Cat

myAnimal = new Cat();
myAnimal.sound(); // Outputs: Cat meows
}
}

Output:-

8. Program implementing the final variable and final class in java

Code:-

final class FinalClass {

// Final variable
final int finalVariable;

// Constructor to initialize the final variable

public FinalClass(int value) {
this.finalVariable = value;
 }

// Method to display the value of the final variable

public void display() {
System.out.println("The value of the final variable is: " +
finalVariable);
}

// Method that cannot be overridden

public final void finalMethod() {
System.out.println("This is a final method and cannot be
overridden.");
}
}

public class FinalVariableAndClass {

public static void main(String[] args) {
// Creating an instance of FinalClass
FinalClass finalClassInstance = new FinalClass(10);

// Displaying the value of the final variable

finalClassInstance.display();

// Calling the final method

finalClassInstance.finalMethod();

// Demonstrating final local variable

final int localFinalVariable = 20;
System.out.println("The value of the local final variable is: " +
localFinalVariable);
}
}
Output:-
9. Java program implementing the var args

Code:-

public class VarArgsExample {

// Method to calculate the sum of integers using varargs

public static int sum(int... numbers) {
int total = 0;
for (int num : numbers) {
total += num;
}
return total;
}

public static void main(String[] args) {

// Calling the sum method with different numbers of arguments
System.out.println("Sum of 1, 2, 3: " + sum(1, 2, 3));
System.out.println("Sum of 10, 20, 30, 40, 50: " + sum(10, 20, 30,
40, 50));
System.out.println("Sum of no arguments: " + sum());
System.out.println("Sum of 7: " + sum(7));
}
}

Output:-

10. Java Program implementing the Exception Handling code

Code:-

import java.util.Scanner;

public class ExceptionHandlingExample {

public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Enter numerator: ");
int numerator = scanner.nextInt();
System.out.print("Enter denominator: ");
int denominator = scanner.nextInt();

try {
// Attempting to divide numerator by denominator
int result = divide(numerator, denominator);
System.out.println("Result of division: " + result);
} catch (ArithmeticException e) {
// Catching arithmetic exceptions (e.g., division by zero)
System.out.println("Error: " + e.getMessage());
} catch (Exception e) {
// Catching any other exceptions
System.out.println("An error occurred: " + e.getMessage());
} finally {
// Closing resources or doing cleanup tasks
scanner.close();
System.out.println("Program execution completed.");
}
}

// Method to perform division

public static int divide(int numerator, int denominator) {
// Division operation
return numerator / denominator;
}
}

Output:-
11. Java Program to implement the String operations

Code:-

public class StringOperationsExample {

public static void main(String[] args) {
// Example strings
String str1 = "Hello";
String str2 = "World";
String str3 = "hello";
String str4 = "Hello";

// Concatenation
String concatenatedString = str1 + " " + str2;
System.out.println("Concatenated String: " + concatenatedString);

// Length
System.out.println("Length of str1: " + str1.length());

// Comparison
System.out.println("Comparison of str1 and str2: " +
str1.equals(str2)); // false
System.out.println("Comparison of str1 and str4: " +
str1.equals(str4)); // true
System.out.println("Case insensitive comparison of str1 and str3: "
+ str1.equalsIgnoreCase(str3)); // true

// Substring
String substr = str1.substring(1, 3); // from index 1 to 2
System.out.println("Substring of str1: " + substr);
 // Uppercase and lowercase
System.out.println("Uppercase of str1: " + str1.toUpperCase());
System.out.println("Lowercase of str2: " + str2.toLowerCase());

// Index of
System.out.println("Index of 'e' in str1: " + str1.indexOf('e'));
// returns first occurrence

// Replace
String replacedString = str1.replace('l', 'w');
System.out.println("String after replacement: " + replacedString);

// Trim
String str5 = " Hello ";
System.out.println("Trimmed String of str5: " + str5.trim());

// Split
String sentence = "Java is a powerful programming language";
String[] words = sentence.split(" ");
System.out.println("Words in the sentence:");
for (String word : words) {
System.out.println(word);
}
}
}

Output:-
12. Write a program to copy bytes from one file to another file.

Code:-

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class CopyBytesFromFile {

public static void main(String[] args) {
// Specify the source and destination file paths
String sourceFilePath = "source.txt";
String destinationFilePath = "destination.txt";

// FileInputStream to read the source file

FileInputStream fileInputStream = null;
// FileOutputStream to write to the destination file
FileOutputStream fileOutputStream = null;

try {
 fileInputStream = new FileInputStream(sourceFilePath);
fileOutputStream = new FileOutputStream(destinationFilePath);

// Buffer to hold bytes during the copying process

byte[] buffer = new byte[1024];
int bytesRead;

// Read from the source file and write to the destination file
while ((bytesRead = fileInputStream.read(buffer)) != -1) {
fileOutputStream.write(buffer, 0, bytesRead);
}

System.out.println("File copied successfully.");

}
catch (IOException e) {
// Handle possible I/O errors
System.err.println("Error during file copy: " +
e.getMessage());
}
finally {
// Close the FileInputStream and FileOutputStream
try {
if (fileInputStream != null) {
fileInputStream.close();
}
if (fileOutputStream != null) {
fileOutputStream.close();
}
} catch (IOException e) {
System.err.println("Error closing files: " +
e.getMessage());
}
}
}
}

Output:-
13. Write a program to read bytes from the file and display the content on
the screen.

Code:-

import java.io.FileInputStream;
import java.io.IOException;

public class ReadBytesFromFile {

public static void main(String[] args) {
// Specify the path to the file
String filePath = "example.txt";

// FileInputStream to read the file

FileInputStream fileInputStream = null;

try {
fileInputStream = new FileInputStream(filePath);

// Read bytes from the file and display them

int byteData;
while ((byteData = fileInputStream.read()) != -1) {
// Convert byte to character and print it
System.out.print((char) byteData);
}
}
catch (IOException e) {
// Handle possible I/O errors
System.err.println("Error reading the file: " +
e.getMessage());
}
finally {
 // Close the FileInputStream
if (fileInputStream != null) {
try {
fileInputStream.close();
} catch (IOException e) {
System.err.println("Errorclosingthefile: " +
e.getMessage());
}
}
}
}
}

Output:-

14. Using Stream class to copy the contents of a file from one to another.

Code:-

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

public class FileCopyExample {

public static void main(String[] args) {
// Source and destination file paths
Path sourceFile = Paths.get("source.txt");
Path destinationFile = Paths.get("destination.txt");

// Copy file using streams

try {
 // Ensure the destination file exists (create if it does not)
if (!Files.exists(destinationFile)) {
Files.createFile(destinationFile);
}

// Copy the content from source to destination

Files.copy(sourceFile, destinationFile,
java.nio.file.StandardCopyOption.REPLACE_EXISTING);

System.out.println("File copied successfully!");

} catch (IOException e) {
System.err.println("I/O Error: " + e.getMessage());
}
}
}

Output:-

15. Multi Thread program in which every thread increment the shared
variable

Code:-

class SharedResource {
private int counter = 0;

// Method to increment the counter

public synchronized void increment() {
counter++;
}

// Method to get the counter value

 public synchronized int getCounter() {
return counter;
}
}

class IncrementThread extends Thread {

private final SharedResource sharedResource;

public IncrementThread(SharedResource sharedResource) {

this.sharedResource = sharedResource;
}

@Override
public void run() {
for (int i = 0; i < 1000; i++) {
sharedResource.increment();
}
}
}

public class MultithreadIncrement {

public static void main(String[] args) {
SharedResource sharedResource = new SharedResource();
int numThreads = 10;

// Create and start threads

Thread[] threads = new Thread[numThreads];
for (int i = 0; i < numThreads; i++) {
threads[i] = new IncrementThread(sharedResource);
threads[i].start();
}

// Wait for all threads to complete

for (int i = 0; i < numThreads; i++) {
try {
threads[i].join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
 // Print the final value of the counter
System.out.println("Final counter value: " +
sharedResource.getCounter());
}
}

Output:-

16. Create a package and use it

Code:-

// File: Emp.java
package employee;

public class Emp {

private String name;

private int empid;
private String category;
private double bpay;
private double hra;
private double da;
private double npay;
private double pf;
private double grosspay;
private double incometax;
private double allowance;
 public Emp(String name, int empid, String category, double bpay, double
hra, double da) {
this.name = name;
this.empid = empid;
this.category = category;
this.bpay = bpay;
this.hra = hra;
this.da = da;
}

public void calculateNetPay() {

grosspay = bpay + hra + da;
pf = 0.12 * grosspay;
incometax = 0.1 * grosspay;
allowance = 0.05 * grosspay;
npay = grosspay - (pf + incometax - allowance);
}

public void printPayrollDetails() {

System.out.println("Employee Name: " + name);
System.out.println("Employee ID: " + empid);
System.out.println("Category: " + category);
System.out.println("Basic Pay: " + bpay);
System.out.println("HRA: " + hra);
System.out.println("DA: " + da);
System.out.println("Gross Pay: " + grosspay);
System.out.println("PF: " + pf);
System.out.println("Income Tax: " + incometax);
System.out.println("Allowance: " + allowance);
System.out.println("Net Pay: " + npay);
}
}

// Importing the above package

import employee.Emp;

public class Emppay {

 public static void main(String[] args) {

Emp e = new Emp("RAJ", 1001, "Regular", 50000, 20000, 15000);

e.calculateNetPay();

e.printPayrollDetails();
}
}

Output:-