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