Java Practice Problems – Coding Challenges

Name: Java-Dev
Age: 20
Language: Java

void main() {
    String name = "Java-Dev";
    int age = 20;
    String language = "Java";

    // Print these three lines:
    // Name: Java-Dev
    // Age: 20
    // Language: Java
}

Why challenges?

You don't learn programming by reading — you learn it by actively solving problems. Challenges combine several concepts — just like real programming tasks.

In real life you'll never just create a single variable. You'll combine variables with output, calculations and conditions. These challenges get you ready for that.

void main() {
    for (int i = 1; i <= 20; i++) {
        // Skip numbers that are divisible by 3


        IO.print(i + " ");
    }
}

break and continue

break; exits the whole loop. continue; only skips the current pass and jumps to the next one.

In nested loops, both only affect the innermost loop. With labels you can target outer loops too: outer: for (...) { ... break outer; }

15
3
54

int calculate(int a, int b, char op) {
    // Return a+b, a-b or a*b
    // depending on op ('+', '-' or '*')
    return 0;
}

void main() {
    IO.println(calculate(10, 5, '+'));
    IO.println(calculate(10, 7, '-'));
    IO.println(calculate(6, 9, '*'));
}

char — the character type

char stores a single character in 2 bytes (strictly speaking a UTF-16 code unit — some characters like emojis need two of them). Chars go in single quotes: 'A'. Strings go in double quotes: "A".

Since char is a primitive type, you actually can use == to compare here. That doesn't work for strings!

Anna: passed
Tom: failed

void main() {
    Student a = new Student("Anna", 2);
    Student b = new Student("Tom", 5);
    IO.println(a.name + ": " + a.result());
    IO.println(b.name + ": " + b.result());
}

class Student {
    String name;
    int grade;

    // Constructor
    // Method result() -> "passed" or "failed"
}

Encapsulation

In real Java code the fields would be private and only accessible through getters/setters. That's called encapsulation — you control how the outside world gets at your data.

Example: a setter for grade could check that the value is between 1 and 6. Without encapsulation, anyone could write s.grade = -5;.

ArrayList<String> list = new ArrayList<>();
list.add("Hello");
list.add("World");
list.size(); // 2

import java.util.ArrayList;

void main() {
    ArrayList<Integer> numbers = new ArrayList<>();
    numbers.add(10);
    numbers.add(20);
    // Add 30
    IO.println(numbers.size());
}

Generics and wrapper classes

ArrayList<Integer> — the <Integer> is a generic. It fixes which type the list holds. Generics stop you from accidentally putting the wrong type in.

Why Integer instead of int? Generics only work with object types. Integer is the wrapper class for int. Java converts between the two automatically (autoboxing/unboxing).

try {
    // Code that might go wrong
} catch (Exception e) {
    // What to do if it does
}

void main() {
    String text = "abc";

    // Wrap the next line in try-catch
    // On error: print "Error!"
    int number = Integer.parseInt(text);
    IO.println(number);
}

Checked vs. unchecked exceptions

Java has two kinds: checked exceptions (e.g. IOException) must be explicitly caught or declared. Unchecked exceptions (e.g. NumberFormatException, NullPointerException) don't.

In practice, many frameworks use only unchecked exceptions. Java's checked-exception rule is controversial — other languages (Kotlin, C#) simply don't have it.

void main() {
    for (int i = 1; i <= 15; i++) {
        // Your if-else chain goes here

        IO.println(i);
    }
}

FizzBuzz — more than an exercise

FizzBuzz is famous because in job interviews it shows whether someone has the basic programming concepts down. The solution needs loops, conditions and modulo — and the right order of checks.

Fun fact: there are hundreds of creative solutions — with streams, pattern matching, or even without if/else. Google "FizzBuzz Enterprise Edition" for the wildly over-engineered version.