DrSimple

Posted on Jun 26, 2025 Edited on Jul 3, 2025

Java Notes

#java #jvm #programming #beginners

Run Java from terminal

javac App.java
java App

Hello World

public class Main {
    public static void main(String[] args) {
        System.out.println("hello");
    }
}

Variables

public class Main {
    public static void main(String[] args) {
        int number = 90;
        double number2 = 90.90;
        float number3 = 90.90F;
        String name = "joe";
        boolean isTall = true;
        char grade = 'A';
        long myId = 90987654345678L;
        byte a = 1;

        System.out.println(a);
        System.out.println(grade);
        System.out.println(myId);
        System.out.println(number);
        System.out.println(number2);
        System.out.println(number3);
        System.out.println(name);
        System.out.println(isTall);

        System.out.println(((Object) number3).getClass().getSimpleName());
        System.out.println(((Object) isTall).getClass().getSimpleName());
    }
}

String Methods

public class Main {
    public static void main(String[] args) {

      String name = "HOLY Spirit";
        System.out.println(name.toLowerCase());
        System.out.println(name.toUpperCase());
    }

}

Enum

public class Main {
    public static void main(String[] args) {

        LEVEL levelHigh = LEVEL.HIGH;
        System.out.println(levelHigh);
        System.out.println(levelHigh.compareTo(LEVEL.LOW));
    }

    enum LEVEL{
        LOW,
        MEDIUM,
        HIGH
    }
}

Condition

public class Main {
    public static void main(String[] args) {
        int age = 90;

        if (age < 18) {
            System.out.println("Underage");
        } else if (age >= 18 && age <= 65) {
            System.out.println("Adult");
        } else {
            System.out.println("Senior");
        }
    }
}

Switch

public class Main {
    public static void main(String[] args) {

        int age = 0;
        switch (age) {
            case 1 -> System.out.println("very young");
            case 2 -> System.out.println("still too young");
            case 9 -> System.out.println("reasonable");
            default -> System.out.println("no age range selected");
        }
    }
}

For Loop

public class Main {
    public static void main(String[] args) {
       int number = 10;

       for(int i = 0; i < number; i++){
           System.out.println("Number is " + i);
       }
    }
}

While Loop

public class Main {
    public static void main(String[] args) {
       int number = 10;

       while(number < 15){
           System.out.println("incrementing with 1: " + number);
           number++;
       }
    }
}

Function

public class Main {
    public static void main(String[] args) {
        int response = addSum(2, 3);
        System.out.println(response);
        System.out.println(((Object) response).getClass().getSimpleName());
    }


    public static int addSum(int a, int b) {
        return a + b;
    }
}

Atomicity

AtomicInteger atomicInt = new AtomicInteger(0);

atomicInt.incrementAndGet(); // ++count
atomicInt.getAndIncrement(); // count++

atomicInt.decrementAndGet(); // --count

atomicInt.addAndGet(5);      // count += 5

int value = atomicInt.get(); // get the current value

boolean updated = atomicInt.compareAndSet(5, 10); 
// if current value == 5, update to 10

Array

public class Main {
    public static void main(String[] args) {

        int[] arrays = {1, 2, 3, 4};
        for (int item : arrays) {
            System.out.println("Item :" + item);
        }
    }

}

Class and Object

public class Main {
    public static void main(String[] args) {

        Person personOne =new Person("joe", 78);
        personOne.speak();
    }

}


 class Person{
    private final String name;
    private final int age;

     public Person(String name, int age) {
         this.name = name;
         this.age = age;
     }

     void speak (){
        System.out.println("Name is " + name + " and age is " + age);
    }
}

Inheritance

public class Main {
    public static void main(String[] args) {

        Person personOne =new Person("joe", 78);
        personOne.speak();
        personOne.scream();
    }

}

class Scream {
    void scream(){
        System.out.println("Ahhhhhhh!");
    }
}

 class Person extends Scream{
    private final String name;
    private final int age;

     public Person(String name, int age) {
         this.name = name;
         this.age = age;
     }

     void speak (){
        System.out.println("Name is " + name + " and age is " + age);
    }
}

Interface

public class Main {
    public static void main(String[] args) {

        Person personOne = new Person("joe");
        personOne.scream();
    }

}

interface Scream {
    void scream();
}

class Person implements Scream {

    private final String name;

    public Person(String name) {
        this.name = name;
    }

    @Override
    public void scream() {
        System.out.println(name + " screamed, Ahhhhh!!!");
    }
}

Static Method

public class Main {
    public static void main(String[] args) {
        double pi = Utils.PI;
        int square = Utils.square(3);
        System.out.println(pi);
        System.out.println(square);

    }

}


class Utils {
    static final double PI = 3.14;

    static int square(int x) {
        return x * x;
    }
}

This

public class Main {
    public static void main(String[] args) {
        Bark dog = new Bark("woof");
        System.out.println(dog.action);
        System.out.println(dog.play());

    }

}

class Bark{
    String action;

    public Bark(String action) {
        this.action = action; // refers to Bark
    }

    boolean play(){
        System.out.println("Joe is " + this.action);
        return false;
    }
}

Constructor Overloading

public class Main {
    public static void main(String[] args) {
        Bark dog = new Bark("woof");

    }

}

class Bark {
    String name;
    String color;

    public Bark(String name, String color) {
        this.name = name;
        this.color = color;
    }

    public Bark(String name){
        this.name = name;
    }
}

Override (Polymorphism)

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.sound();

    }

}

class Animal {
    void sound(){
        System.out.println("woof");
    }
}

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

Abstract

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.sound();

        Animal n = new Animal(); // abstract class cannot be instantiated
    }

}

abstract class Animal {
    void sound(){
        System.out.println("woof");
    }
}

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

super()

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
    }

}


class Animal {
    Animal() {
        System.out.println("Animal created");
    }
}

class Dog extends Animal {
    Dog() {
        super(); // calls Animal constructor
        System.out.println("Dog created");
    }
}

Wrapper Class

public class Main {
    public static void main(String[] args) {
        Integer num = 90;
        Float f1 = 90.90F;      //use wrapper class if you are working with collections, JSON serialization, null-checking
        System.out.println(num.equals(90)); //stick with primitives if you need performance and don't need object features.
    }
//  Wrapper classes provide helper methods (e.g., Integer.parseInt(), Double.compare()).
}

String Builder

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("Hi");
        sb.append(" there!");
        System.out.println(sb.toString());
    }
}

Null Pointer

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;

import static java.lang.Character.getName;

public class Main {
    public static void main(String[] args) {

        try {
            //Avoiding null NPE
            String myName = "";
            int[] myNumbers = new int[10];
            List<String> items = new ArrayList<>();
            System.out.println(myName);
            System.out.println(myNumbers);
            System.out.println(items);

            if (myName != null) {
                System.out.println("printing this");
            }

            String possiblyNullName = "";
            String nullName = possiblyNullName != null ? possiblyNullName : "Unknown";
            System.out.println(nullName);


            String name = null;
            System.out.println(name.length()); //💥 NullPointerException

            int[] numbers = null;
            System.out.println(numbers.length); // 💥 NPE
        } catch (NullPointerException e) {
            System.out.println(e.getMessage());
        }

    }

}

List

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> animals = new ArrayList<>(); //List<Object>
        animals.add("monkey");
        animals.add("lion");
        System.out.println(animals);
        for (String animal: animals){
            System.out.println("I am a/an " + animal);
        }
    }

}

HashMap

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        HashMap<String, String> response = new HashMap<>();
        response.put("message", "success");
        response.put("status", "ongoing");
        System.out.println(response);
        System.out.println(((Object) response).getClass().getSimpleName());
    }

}

LinkedMap

import java.util.LinkedHashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        // Create a LinkedHashMap
        LinkedHashMap<String, String> capitals = new LinkedHashMap<>();

        // Add key-value pairs
        capitals.put("Nigeria", "Abuja");
        capitals.put("USA", "Washington D.C.");
        capitals.put("France", "Paris");
        capitals.put("Japan", "Tokyo");

        // Iterate in insertion order
        System.out.println("Countries and their Capitals (in insertion order):");
        for (Map.Entry<String, String> entry : capitals.entrySet()) {
            System.out.println(entry.getKey() + " → " + entry.getValue());
        }

        // Access a value
        System.out.println("\nCapital of Japan is: " + capitals.get("Japan"));

        // Check if a key exists
        if (capitals.containsKey("France")) {
            System.out.println("France is in the map.");
        }

        // Remove an entry
        capitals.remove("USA");
        System.out.println("\nAfter removing USA:");
        System.out.println(capitals);
    }
}

Stream

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);

        List<Integer> response = numbers.stream()
                .filter(i -> i % 2 == 0)
                .toList();

        System.out.println(response);
    }

}

Stream

import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
        List<Integer> response = numbers.stream()
                .filter(i -> i % 2 == 0)
                .toList();

        System.out.println(response);
    }

}

Exception

public class Main {
    public static void main(String[] args) {

        try {
            int response = 10 / 0;
            System.out.println(response);
        }catch (ArithmeticException e){
            System.out.println("Oops!, Error");
        }
    }

}

I/O

import java.io.*;

public class Main {
    public static void main(String[] args) {
        try {
            BufferedReader reader = new BufferedReader(new FileReader("C:\\Users\\CAPTAIN ENJOY\\Downloads\\JavaNote\\src\\text.txt"));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
            reader.close();

            BufferedWriter writer = new BufferedWriter(new FileWriter("C:\\Users\\CAPTAIN ENJOY\\Downloads\\JavaNote\\src\\text.txt"));
            writer.write("ner");
            writer.close();
        } catch (IOException e) {
            System.out.println(e.getMessage());
        }
    }
}

Lambda

import java.io.*;
import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {

        List<String> names = Arrays.asList("john", "wick", "doe");
        names.forEach(name -> System.out.println("my name is " + name));
    }
}

Constants

public class Main {
    public static void main(String[] args) {

        final int MAX_ATTEMPTS = 909090;
        // MAX_ATTEMPTS = 200; // ❌ Will cause error
        System.out.println(MAX_ATTEMPTS);
    }
}

SOLID

SOLID Principles (OOP Best Practices) S — Single Responsibility Principle (SRP) Each class should have one job. Example: A UserService should only handle user logic, not email sending.

class UserService {
    void registerUser(User user) { /* ... */ }
}

class EmailService {
    void sendWelcomeEmail(User user) { /* ... */ }
}

O — Open/Closed Principle (OCP)
Classes should be open for extension, but closed for modification.
Example:
Instead of modifying payment logic, extend it:

interface Payment {
    void pay();
}

class CreditCardPayment implements Payment {
    public void pay() { /* ... */ }
}

class UpiPayment implements Payment {
    public void pay() { /* ... */ }
}

L — Liskov Substitution Principle (LSP)
Subclasses should replace base classes without breaking behavior.
Example:
If Bird can fly, then Penguin shouldn't extend Bird if it can't fly.

I — Interface Segregation Principle (ISP)
Don’t force classes to implement unnecessary methods.
Bad:

interface Animal {
    void fly(); // forces Dog to implement this unnecessarily
}

Good:

interface Bird { void fly(); }
interface Dog { void bark(); }

D — Dependency Inversion Principle (DIP)
Depend on abstractions, not concrete classes.

class NotificationService {
    private MessageSender sender;

    NotificationService(MessageSender sender) {
        this.sender = sender;
    }

    void notify(String msg) {
        sender.send(msg);
    }
}

DEV Community

Java Notes

Run Java from terminal

Hello World

Variables

String Methods

Enum

Condition

Switch

For Loop

While Loop

Function

Atomicity

Array

Class and Object

Inheritance

Interface

Static Method

This

Constructor Overloading

Override (Polymorphism)

Abstract

super()

Wrapper Class

String Builder

Null Pointer

List

HashMap

LinkedMap

Stream

Stream

Exception

I/O

Lambda

Constants

SOLID

Top comments (0)