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();
}
}
}
