██FR█████ █INTELL███████████

Java Notes


This content originally appeared on DEV Community and was authored by DrSimple

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

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

  1. 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);
    }
}


This content originally appeared on DEV Community and was authored by DrSimple