1.

Sum of command line arguments

public class SumCommandLine {
public static void main(String[] args) {
int sum = 0;

for(int i = 0; i < args.length; i++) {

try {
sum += Integer.parseInt(args[i]);
} catch(NumberFormatException e) {
System.out.println("Error: " + args[i] + " is not a valid
integer.");
}
}

System.out.println("Sum of command line arguments: " + sum);

}
}

2. Factorial of a number
import java.util.Scanner;

public class Factorial {

public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);

System.out.print("Enter a number to find its factorial: ");

int number = scanner.nextInt();

long factorial = 1;
for(int i = 1; i <= number; i++) {
factorial *= i;
}

System.out.println("Factorial of " + number + " is: " + factorial);

scanner.close();
}
}

3. Single-dimensional array defined dynamically

import java.util.Scanner;

public class DynamicArray {

public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);

System.out.print("Enter the size of the array: ");

int size = scanner.nextInt();

int[] array = new int[size];

System.out.println("Enter " + size + " elements:");

for(int i = 0; i < size; i++) {
array[i] = scanner.nextInt();
}
 System.out.println("Elements of the array are:");
for(int i = 0; i < size; i++) {
System.out.print(array[i] + " ");
}

scanner.close();
}
}

4. Two-dimensional array and length property

public class TwoDimensionalArray {
public static void main(String[] args) {
int[][] array = {
{1, 2, 3},
{4, 5},
{6, 7, 8, 9}
};

System.out.println("Number of rows: " + array.length);

for(int i = 0; i < array.length; i++) {

System.out.println("Length of row " + i + ": " +
array[i].length);
}

System.out.println("\nPrinting all elements:");

for(int i = 0; i < array.length; i++) {
for(int j = 0; j < array[i].length; j++) {
System.out.print(array[i][j] + " ");
}
System.out.println();
}
}
}

5. Decimal to binary conversion

import java.util.Scanner;

public class DecimalToBinary {

public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);

System.out.print("Enter a decimal number: ");

int decimal = scanner.nextInt();

String binary = "";

int temp = decimal;

while(temp > 0) {
binary = (temp % 2) + binary;
temp = temp / 2;
}

// Handle case when input is 0

if(decimal == 0) {
 binary = "0";
}

System.out.println("Binary representation of " + decimal + " is: "

+ binary);
scanner.close();
}
}

6. Check if a number is prime

import java.util.Scanner;

public class PrimeNumber {

public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);

System.out.print("Enter a number to check if it's prime: ");

int number = scanner.nextInt();

boolean isPrime = true;

if(number <= 1) {
isPrime = false;
} else {
for(int i = 2; i <= Math.sqrt(number); i++) {
if(number % i == 0) {
isPrime = false;
break;
}
}
}

if(isPrime) {
System.out.println(number + " is a prime number.");
} else {
System.out.println(number + " is not a prime number.");
}

scanner.close();
}
}

7. Sum of integers with count from command line

import java.util.Scanner;

public class InteractiveSum {

public static void main(String[] args) {
if(args.length < 1) {
System.out.println("Please provide the count of integers as a
command line argument.");
return;
}

int count = Integer.parseInt(args[0]);

int sum = 0;
Scanner scanner = new Scanner(System.in);
 System.out.println("Enter " + count + " integers:");
for(int i = 0; i < count; i++) {
System.out.print("Enter integer #" + (i+1) + ": ");
sum += scanner.nextInt();
}

System.out.println("Sum of the " + count + " integers: " + sum);

scanner.close();
}
}

8. String and StringBuffer functions

public class StringFunctions {
public static void main(String[] args) {
// String methods
String str1 = "Hello";
String str2 = "World";

System.out.println("String concatenation using concat(): " +

str1.concat(" " + str2));
System.out.println("String equals(): " + str1.equals(str2));
System.out.println("String equals() with same value: " +
"Hello".equals(str1));

// StringBuffer methods
StringBuffer buffer = new StringBuffer("Hello");
System.out.println("Original StringBuffer: " + buffer);

// setCharAt()
buffer.setCharAt(1, 'a');
System.out.println("After setCharAt(1, 'a'): " + buffer);

// append()
buffer.append(" World");
System.out.println("After append(' World'): " + buffer);

// insert()
buffer.insert(5, " Java");
System.out.println("After insert(5, ' Java'): " + buffer);

// setLength()
buffer.setLength(10);
System.out.println("After setLength(10): " + buffer);
}
}

9. Distance class with 'this' pointer

class Distance {
private int feet;
private int inches;

public void setFeetAndInches(int feet, int inches) {

this.feet = feet;
this.inches = inches;
normalizeDistance();
 }

private void normalizeDistance() {

if(this.inches >= 12) {
this.feet += this.inches / 12;
this.inches = this.inches % 12;
}
}

public void displayDistance() {

System.out.println("Distance: " + this.feet + " feet and " +
this.inches + " inches");
}
}

public class DistanceDemo {

public static void main(String[] args) {
Distance distance = new Distance();
distance.setFeetAndInches(5, 14);
distance.displayDistance();
}
}

10. Distance class with constructor, reference, and cloning

class Distance {
private int feet;
private int inches;

// Constructor for assigning values

public Distance(int feet, int inches) {
this.feet = feet;
this.inches = inches;
normalizeDistance();
}

// Copy constructor for cloning

public Distance(Distance d) {
this.feet = d.feet;
this.inches = d.inches;
}

private void normalizeDistance() {

if(this.inches >= 12) {
this.feet += this.inches / 12;
this.inches = this.inches % 12;
}
}

public void displayDistance() {

System.out.println("Distance: " + this.feet + " feet and " +
this.inches + " inches");
}
}

public class DistanceConstructorDemo {

public static void main(String[] args) {
// First object
Distance distance1 = new Distance(5, 14);
System.out.print("Distance 1 - ");
 distance1.displayDistance();

// Second object as reference to first

Distance distance2 = distance1;
System.out.print("Distance 2 (reference to Distance 1) - ");
distance2.displayDistance();

// Third object as clone of first

Distance distance3 = new Distance(distance1);
System.out.print("Distance 3 (clone of Distance 1) - ");
distance3.displayDistance();
}
}

11. Function overloading with automatic type conversion

public class FunctionOverloading {
public static void display(int num) {
System.out.println("Method with int argument: " + num);
}

public static void display(double num) {

System.out.println("Method with double argument: " + num);
}

public static void display(String str) {

System.out.println("Method with String argument: " + str);
}

public static void main(String[] args) {

// Direct matching
display(10); // Will call display(int)
display(10.5); // Will call display(double)
display("Hello"); // Will call display(String)

// Automatic type conversion (from lower to higher)

short s = 10;
display(s); // Will call display(int) - automatic conversion
from short to int

char c = 'A';
display(c); // Will call display(int) - automatic conversion
from char to int
}
}

12. Public vs Private access and final keyword

class AccessDemo {
private int privateVar = 10;
public int publicVar = 20;

private void privateMethod() {

System.out.println("This is a private method.");
}

public void publicMethod() {

System.out.println("This is a public method.");
 System.out.println("privateVar = " + privateVar);
privateMethod();
}
}

public class AccessSpecifierDemo {

public static void passPrimitive(int x) {
x = x + 10;
System.out.println("Inside passPrimitive, x = " + x);
}

public static void passObject(AccessDemo obj) {

obj.publicVar = obj.publicVar + 10;
System.out.println("Inside passObject, publicVar = " +
obj.publicVar);
}

public static void main(String[] args) {

AccessDemo demo = new AccessDemo();

// Public access
System.out.println("publicVar = " + demo.publicVar);
demo.publicMethod();

// Private access (uncomment to see compilation error)

// System.out.println("privateVar = " + demo.privateVar);
// demo.privateMethod();

// Pass by value for primitive types

int num = 50;
System.out.println("Before passPrimitive, num = " + num);
passPrimitive(num);
System.out.println("After passPrimitive, num = " + num);

// Pass by reference for objects

System.out.println("Before passObject, publicVar = " +
demo.publicVar);
passObject(demo);
System.out.println("After passObject, publicVar = " +
demo.publicVar);

// Final keyword
final int finalInt = 100;
// finalInt = 200; // Uncomment to see compilation error

final AccessDemo finalObj = new AccessDemo();

// finalObj = new AccessDemo(); // Uncomment to see compilation
error
finalObj.publicVar = 30; // This is allowed as the object's
contents can change
}
}

13. Static functions and variable-length arguments

public class StaticAndVarArgs {
// Static variable
private static int staticVar = 10;

// Static method
 public static void displayStatic() {
System.out.println("Static variable value: " + staticVar);
}

// Instance method
public void displayInstance() {
System.out.println("Accessing static variable from instance method:
" + staticVar);
}

// Method with variable-length arguments

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

public static void main(String[] args) {

// Accessing static method without instance
StaticAndVarArgs.displayStatic();

// Static variable can be accessed from static context

System.out.println("Static variable accessed directly: " +
staticVar);

// Creating instance to call instance method

StaticAndVarArgs obj = new StaticAndVarArgs();
obj.displayInstance();

// Calling method with variable-length arguments

System.out.println("Sum of no arguments: " + sum());
System.out.println("Sum of 5: " + sum(5));
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));
}
}

14. Boxing and unboxing

public class BoxingUnboxing {
public static void main(String[] args) {
// Boxing - converting primitive to wrapper
int primitiveInt = 10;
Integer boxedInt = Integer.valueOf(primitiveInt); // Explicit
boxing
Integer autoBoxedInt = primitiveInt; // Auto-boxing

System.out.println("Primitive int: " + primitiveInt);

System.out.println("Boxed Integer: " + boxedInt);
System.out.println("Auto-boxed Integer: " + autoBoxedInt);

// Unboxing - converting wrapper to primitive

Integer wrapperInteger = Integer.valueOf(20);
int unboxedInt = wrapperInteger.intValue(); // Explicit
unboxing
int autoUnboxedInt = wrapperInteger; // Auto-unboxing
 System.out.println("Wrapper Integer: " + wrapperInteger);
System.out.println("Unboxed int: " + unboxedInt);
System.out.println("Auto-unboxed int: " + autoUnboxedInt);

// Boxing/Unboxing in expressions
Integer num1 = 30;
Integer num2 = 40;
int sum = num1 + num2; // Auto-unboxing occurs before addition

System.out.println("Sum of boxed values: " + sum);

}
}

15. Multi-file program

File: MessageInput.java

import java.util.Scanner;

public class MessageInput {

public static String getMessage() {
Scanner scanner = new Scanner(System.in);
System.out.print("Enter a message: ");
String message = scanner.nextLine();
scanner.close();
return message;
}
}

File: MessageDisplay.java

public class MessageDisplay {

public static void displayMessage(String message) {
System.out.println("Your message is: " + message);
}
}

File: MultiFileProgram.java

public class MultiFileProgram {

public static void main(String[] args) {
String message = MessageInput.getMessage();
MessageDisplay.displayMessage(message);
}
}

16. Multilevel package with Fibonacci series

File: fibonacci/FibonacciGenerator.java

package fibonacci;

public class FibonacciGenerator {

public static int[] generateFibonacci(int n) {
if(n <= 0) {
return new int[0];
 }

int[] fibSeries = new int[n];

fibSeries[0] = 0;

if(n > 1) {
fibSeries[1] = 1;

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

fibSeries[i] = fibSeries[i-1] + fibSeries[i-2];
}
}

return fibSeries;
}
}

File: fibonacci/util/FibonacciDisplay.java

package fibonacci.util;

public class FibonacciDisplay {

public static void displayFibonacci(int[] fibSeries) {
System.out.println("Fibonacci Series:");
for(int i = 0; i < fibSeries.length; i++) {
System.out.print(fibSeries[i] + " ");
}
System.out.println();
}
}

File: FibonacciDemo.java

import fibonacci.FibonacciGenerator;
import fibonacci.util.FibonacciDisplay;
import java.util.Scanner;

public class FibonacciDemo {

public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);

System.out.print("Enter the number of Fibonacci terms to generate:

");
int n = scanner.nextInt();

int[] fibSeries = FibonacciGenerator.generateFibonacci(n);

FibonacciDisplay.displayFibonacci(fibSeries);

scanner.close();
}
}

17. Protection levels in classes/subclasses

File: protection/Base.java

package protection;
public class Base {
private int privateVar = 10;
protected int protectedVar = 20;
public int publicVar = 30;
int defaultVar = 40; // package-private (default)

private void privateMethod() {

System.out.println("Private method in Base");
}

protected void protectedMethod() {

System.out.println("Protected method in Base");
}

public void publicMethod() {

System.out.println("Public method in Base");
}

void defaultMethod() {
System.out.println("Default method in Base");
}

public void accessBaseMembers() {

System.out.println("Accessing members from Base class:");
System.out.println("privateVar = " + privateVar);
System.out.println("protectedVar = " + protectedVar);
System.out.println("publicVar = " + publicVar);
System.out.println("defaultVar = " + defaultVar);
privateMethod();
protectedMethod();
publicMethod();
defaultMethod();
}
}

File: protection/SubClass.java

package protection;

public class SubClass extends Base {

public void accessInheritedMembers() {
System.out.println("Accessing inherited members from SubClass:");
// System.out.println("privateVar = " + privateVar); // Cannot
access
System.out.println("protectedVar = " + protectedVar);
System.out.println("publicVar = " + publicVar);
System.out.println("defaultVar = " + defaultVar);
// privateMethod(); // Cannot access
protectedMethod();
publicMethod();
defaultMethod();
}
}

File: otherpackage/OtherSubClass.java

package otherpackage;

import protection.Base;
public class OtherSubClass extends Base {
public void accessInheritedMembers() {
System.out.println("Accessing inherited members from
OtherSubClass:");
// System.out.println("privateVar = " + privateVar); // Cannot
access
System.out.println("protectedVar = " + protectedVar); // Can access
protected
System.out.println("publicVar = " + publicVar);
// System.out.println("defaultVar = " + defaultVar); // Cannot
access
// privateMethod(); // Cannot access
protectedMethod(); // Can access protected
publicMethod();
// defaultMethod(); // Cannot access
}
}

File: otherpackage/OtherClass.java

package otherpackage;

import protection.Base;

public class OtherClass {

public void accessBaseMembers() {
Base base = new Base();
System.out.println("Accessing Base members from OtherClass:");
// System.out.println("privateVar = " + base.privateVar); // Cannot
access
// System.out.println("protectedVar = " + base.protectedVar); //
Cannot access
System.out.println("publicVar = " + base.publicVar);
// System.out.println("defaultVar = " + base.defaultVar); // Cannot
access
// base.privateMethod(); // Cannot access
// base.protectedMethod(); // Cannot access
base.publicMethod();
// base.defaultMethod(); // Cannot access
}
}

File: ProtectionDemo.java

import protection.Base;
import protection.SubClass;
import otherpackage.OtherSubClass;
import otherpackage.OtherClass;

public class ProtectionDemo {

public static void main(String[] args) {
Base base = new Base();
SubClass subClass = new SubClass();
OtherSubClass otherSubClass = new OtherSubClass();
OtherClass otherClass = new OtherClass();

base.accessBaseMembers();
System.out.println();

subClass.accessInheritedMembers();
 System.out.println();

otherSubClass.accessInheritedMembers();
System.out.println();

otherClass.accessBaseMembers();
}
}

18. DivideByZero with ArithmeticException

import java.util.Scanner;

public class DivideByZero {

public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);

System.out.print("Enter numerator (a): ");

int a = scanner.nextInt();

System.out.print("Enter denominator (b): ");

int b = scanner.nextInt();

try {
int result = divide(a, b);
System.out.println("Result of " + a + " / " + b + " = " +
result);
} catch(ArithmeticException e) {
System.out.println("Error: " + e.getMessage());
System.out.println("Cannot divide by zero!");
}

scanner.close();
}

public static int divide(int a, int b) {

return a / b; // This will throw ArithmeticException if b is 0
}
}

19. Nested try statements

public class NestedTryDemo {
public static void main(String[] args) {
try {
System.out.println("Outer try block starts");

int[] arr = {1, 2, 3};

try {
System.out.println("Inner try block 1 starts");
int result = arr[5] / 0; // ArrayIndexOutOfBoundsException
& ArithmeticException
System.out.println("Result: " + result);
System.out.println("Inner try block 1 ends");
} catch(ArithmeticException e) {
System.out.println("Inner catch block 1: " +
e.getMessage());
 }

try {
System.out.println("Inner try block 2 starts");
String str = null;
System.out.println("String length: " + str.length()); //
NullPointerException
System.out.println("Inner try block 2 ends");
} catch(NullPointerException e) {
System.out.println("Inner catch block 2: " +
e.getMessage());
}

System.out.println("Outer try block ends");

} catch(ArrayIndexOutOfBoundsException e) {
System.out.println("Outer catch block: " + e.getMessage());
} catch(Exception e) {
System.out.println("Generic exception caught: " +
e.getMessage());
} finally {
System.out.println("Finally block executed");
}

System.out.println("Program continues after exception handling");

}
}

20. Custom exception types

// Custom exception class
class InvalidAgeException extends Exception {
public InvalidAgeException(String message) {
super(message);
}
}

class AgeVerifier {
public static void verifyAge(int age) throws InvalidAgeException {
if(age < 0) {
throw new InvalidAgeException("Age cannot be negative");
} else if(age < 18) {
throw new InvalidAgeException("Age should be at least 18");
} else if(age > 120) {
throw new InvalidAgeException("Age seems too high to be
valid");
}
System.out.println("Age verification successful: " + age);
}
}
public class CustomExceptionDemo {
public static void main(String[] args) {
int[] ages = {-5, 16, 25, 150};

for(int age : ages) {

try {
System.out.println("Verifying age: " + age);
AgeVerifier.verifyAge(age);
} catch(InvalidAgeException e) {
System.out.println("InvalidAgeException: " +
e.getMessage());
 }
System.out.println();
}
}
}