Most Asked
Java Programming
Interview Questions

public class MainApp {
    public static void main(String[] args) {
        System.out.println("Application started successfully.");
    }
}

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

int primitiveInt = 42; // Primitive type, not an object
Integer objectInt = primitiveInt; // Autoboxed into an Integer Object

// Declaration (in Interface)
interface Calculator {
    int add(int a, int b);
}

// Definition (in Concrete Class)
class BasicCalculator implements Calculator {
    public int add(int a, int b) {
        return a + b;
    }
}

# Command-line execution in JDK:
javac MyApp.java  # Compiles to MyApp.class (requires JDK)
java MyApp        # Runs bytecode (requires JRE/JDK)

public class Dog {
    String breed; // State
    
    void bark() { // Behavior
        System.out.println("Woof!");
    }

    public static void main(String[] args) {
        Dog myDog = new Dog(); // Instantiate object
        myDog.breed = "Labrador";
        myDog.bark();
    }
}

// Blueprint Class
public class Car {
    String color;
    int maxSpeed;
    
    void drive() {
        System.out.println("Moving at speed: " + maxSpeed);
    }
}

public class User {
    String username;

    // Parameterized Constructor
    public User(String name) {
        this.username = name;
    }

    public static void main(String[] args) {
        User u = new User("Alice");
    }
}

public class Test {
    int instanceVar; // Defaults to 0

    public void run() {
        int localVar = 10; // No default, must initialize
        System.out.println(instanceVar + localVar);
    }
}

class Animal {
    void eat() { System.out.println("Eating..."); }
}

class Dog extends Animal {
    void bark() { System.out.println("Barking..."); }
}

// Reference type is Animal, object type is Dog
Animal pet = new Dog();
pet.makeSound(); // Overridden method resolved at runtime

public class MathUtils {
    int add(int a, int b) { return a + b; }
    
    // Overloaded by changing types
    double add(double a, double b) { return a + b; }
    
    // Overloaded by parameter count
    int add(int a, int b, int c) { return a + b + c; }
}

class Parent {
    void show() { System.out.println("Parent"); }
}

class Child extends Parent {
    @Override
    void show() { System.out.println("Child"); }
}

abstract class Vehicle {
    int speed = 60;
    
    // Abstract method (no body)
    abstract void start();
    
    // Concrete method
    void stop() { System.out.println("Stopped"); }
}

abstract class Shape {
    abstract double getArea(); // Implementation delegated to child classes
}

interface Printable {
    int MIN_VALUE = 5; // public static final
    void print(); // public abstract
}

public class BankAccount {
    private double balance; // Read-only from outside

    public double getBalance() {
        return this.balance;
    }

    public void deposit(double amount) {
        if(amount > 0) { // Controlled data modification
            this.balance += amount;
        }
    }
}

String name = "CareerRaah";
char[] characters = {'R', 'a', 'a', 'h'};
String copy = new String(characters);

String s1 = new String("Java");
String s2 = new String("Java");

System.out.println(s1 == s2);      // false (distinct heap objects)
System.out.println(s1.equals(s2)); // true  (identical contents)

int num = 456;
String s1 = Integer.toString(num); // Clean and descriptive
String s2 = String.valueOf(num);   // Standard valueOf conversion

String numericStr = "1234";
int primitiveInt = Integer.parseInt(numericStr); // Returns primitive int
Integer objectInt = Integer.valueOf(numericStr);  // Returns Integer object

char digitChar = '9';

// Method 1: Using character subtraction (ASCII mapping)
int val1 = digitChar - '0'; // 57 - 48 = 9

// Method 2: Standard API
int val2 = Character.getNumericValue(digitChar); // 9

public class PatternOne {
    public static void main(String[] args) {
        int rows = 5;
        for (int x = 1; x <= rows; x++) {
            for (int y = 1; y <= x; y++) {
                System.out.print(y + " ");
            }
            System.out.println();
        }
    }
}

public class StarPattern {
    public static void main(String[] args) {
        int rows = 5;
        for (int x = 0; x < rows; x++) {
            for (int y = 0; y <= x; y++) {
                System.out.print("* ");
            }
            System.out.println();
        }
    }
}

public class RightStarPattern {
    public static void main(String[] args) {
        int rows = 5;
        for (int x = 0; x < rows; x++) {
            // Print alignment spaces
            for (int y = 2 * (rows - x - 1); y >= 0; y--) {
                System.out.print(" ");
            }
            // Print stars
            for (int y = 0; y <= x; y++) {
                System.out.print("* ");
            }
            System.out.println();
        }
    }
}

public class PyramidPattern {
    public static void main(String[] args) {
        int rows = 5;
        for (int x = 0; x < rows; x++) {
            // Print spacing
            for (int y = rows - x; y > 1; y--) {
                System.out.print(" ");
            }
            // Print star columns
            for (int y = 0; y <= x; y++) {
                System.out.print("* ");
            }
            System.out.println();
        }
    }
}

public class Fibonacci {
    public static void main(String[] args) {
        int a = 0, b = 1, count = 10;
        System.out.print(a + " " + b); // Prints 0 and 1
        
        for (int i = 2; i < count; i++) {
            int next = a + b;
            System.out.print(" " + next);
            a = b;
            b = next;
        }
    }
}

public class Reverser {
    public static void main(String[] args) {
        String str = "Software Testing Material";
        
        // Method 1: Using StringBuilder
        String rev1 = new StringBuilder(str).reverse().toString();
        
        // Method 2: Manual Array Swap
        char[] chars = str.toCharArray();
        int left = 0, right = chars.length - 1;
        while (left < right) {
            char temp = chars[left];
            chars[left] = chars[right];
            chars[right] = temp;
            left++;
            right--;
        }
        String rev2 = new String(chars);
    }
}

public class MaxFinder {
    public static void main(String[] args) {
        int[] arr = {28, 3, 15, 9, 17, 4, 23, 2};
        int max = arr[0];
        
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        System.out.println("Max element: " + max);
    }
}

public class PrimePrinters {
    public static void main(String[] args) {
        StringBuilder primes = new StringBuilder();
        for (int i = 2; i <= 100; i++) {
            boolean isPrime = true;
            for (int factor = 2; factor <= Math.sqrt(i); factor++) {
                if (i % factor == 0) {
                    isPrime = false;
                    break;
                }
            }
            if (isPrime) {
                primes.append(i).append(" ");
            }
        }
        System.out.println("Primes: " + primes);
    }
}

import java.util.Scanner;

public class PrimeN {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter N: ");
        int n = scanner.nextInt();
        scanner.close();
        
        for (int i = 2; i <= n; i++) {
            boolean isPrime = true;
            for (int factor = 2; factor * factor <= i; factor++) {
                if (i % factor == 0) {
                    isPrime = false;
                    break;
                }
            }
            if (isPrime) {
                System.out.print(i + " ");
            }
        }
    }
}

import java.util.Scanner;

public class PrimeVerifier {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        System.out.print("Verify number: ");
        int num = s.nextInt();
        s.close();
        
        boolean isPrime = num > 1;
        for (int i = 2; i * i <= num; i++) {
            if (num % i == 0) {
                isPrime = false;
                break;
            }
        }
        System.out.println(num + (isPrime ? " is prime." : " is not prime."));
    }
}

public class FibMethods {
    // Dynamic recursive with memoization
    static int getFib(int n, int[] memo) {
        if (n <= 1) return n;
        if (memo[n] != 0) return memo[n];
        return memo[n] = getFib(n - 1, memo) + getFib(n - 2, memo);
    }
}

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

public class FileReaderApp {
    public static void main(String[] args) {
        String path = "data.txt";

        // Method A: Modern Java Try-With-Resources (Auto Closeable)
        try (BufferedReader br = new BufferedReader(new FileReader(path))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

int[] basicArray = new int[5]; // Fixed size, contains raw primitives
ArrayList<Integer> arrayList = new ArrayList<>(); // Resizes dynamically

class SuperClass {
    static void staticPrint() { System.out.println("Static Super"); }
    void virtualPrint() { System.out.println("Virtual Super"); }
}

interface Readable { void read(); }
interface Writeable { void write(); }

class Document implements Readable, Writeable {
    public void read() { System.out.println("Reading"); }
    public void write() { System.out.println("Writing"); }
}

public void validate(int age) throws IllegalArgumentException {
    if (age < 18) {
        throw new IllegalArgumentException("Underage user.");
    }
}