Java Architecture: JVM, JRE, JDK Explained

I just updated this article to add Clock to the list of old Java classes that shouldn't be used anymore since they have better replacements in the language itself. Most uses of the Clock class should be replaced by InstantSource since Java 17. https://lnkd.in/gRTyssRR

Something weird happened while I was debugging a Java program today. I had a simple program running with multiple threads, and I printed the thread names just to see what was happening. The output looked something like this: main http-nio-8080-exec-1 http-nio-8080-exec-2 ForkJoinPool.commonPool-worker-3 At first I ignored it. But then I started wondering… Where are all these threads actually coming from? I didn’t create them. After digging a bit deeper, I realized something interesting. Modern Java applications are constantly using different thread pools behind the scenes. For example: • The web server creates request threads • "CompletableFuture" uses the ForkJoinPool • Some frameworks create background worker threads • The JVM itself runs internal service threads Which means even a “simple” backend service may actually be running dozens of threads at the same time. It made me realize something: A lot of complexity in backend systems isn’t in the code we write — it’s in the systems running around our code. Now I’m a lot more curious about what’s actually happening inside the JVM when our apps run. #Java #BackendEngineering #SpringBoot #SoftwareEngineering #LearningInPublic

🚀 Day 8 — Restarting My Java Journey with Consistency Today’s topic looked familiar: 🔹 while loop 🔹 do-while loop 🔹 for loop 🔹 break & continue Most of this was already known to me. But revision with depth always reveals something new. 🔁 Loops — More Than Just Repetition We often write: for(int i = 0; i < n; i++) { // code } But today I revisited some important insights: ✔ All three parts in a for loop are optional ✔ Multiple variables can be initialized using comma separation ✔ Conditional statements rely completely on logical operators ✔ do-while is very useful in menu-driven programs (runs at least once) 🤯 Interesting Question Why don’t we usually use short instead of int in loops? Because in Java, due to type promotion, short gets promoted to int during arithmetic operations. So practically, using short in loops doesn’t provide any benefit. That’s not syntax knowledge. That’s understanding how Java works internally. 🆕 The New Concept I Learned — Labels in Java This was something I had never used before. outer: for(int i = 1; i <= 10; i++) { inner: for(int j = 1; j <= i; j++) { break outer; // breaks the outer loop directly } } 🔹 Labels allow us to control outer loops from inside inner loops 🔹 Useful in nested loop scenarios 🔹 Makes flow control very powerful (if used wisely) Learning daily with Coder Army and Aditya Tandon Bhaiya and Rohit Negi Bhaiya #Day8 #Java #Consistency #BackendDevelopment #LearningJourney #SoftwareEngineering #CoderArmy

🔥Evolution of Passing Behavior in Java 🔷 From Classes → Anonymous → Lambda Earlier in Java, if you wanted a thread to do some work, you had to: 📦 Create a separate class 🧩 Implement Runnable 🔌 Inject it into Thread 🚀 Then start execution A lot of structure… for a very small behavior. Then Java allowed anonymous classes Now the behavior lives near the usage — no extra file, less ceremony. Finally came lambda expressions The behavior itself became the parameter: new Thread(() -> System.out.println("Running")).start(); No class No boilerplate Just intent This is called: 👉 Passing behavior as data (or) 👉 Behavior Parameterization You are no longer passing objects — You are passing what the program should do. Why it matters Code moved from structure-heavy → intent-focused Class → Anonymous Class → Lambda Boilerplate → Inline behavior → Pure logic 💡 Modern Java is not about creating more classes. It is about expressing behavior directly. GitHub Link: https://lnkd.in/gXbZtwSq 🔖Frontlines EduTech (FLM) #java #coreJava #threads #BackendDevelopment #Programming #CleanCode #ResourceManagement #AustraliaJobs #SwitzerlandJobs #NewZealandJobs #USJobs #FunctionalProgramming #BehaviorParameterization #LambdaExpressions #AnonymousClasses #Runnable #Multithreading #Java8 #Refactoring #OOPDesign

🚀 Java Learning Journey – Day 5 Today was not about syntax. It was about understanding how Java really works inside the JVM. 🔎 Topics Covered: • Static vs Non-Static Methods • Stack vs Heap Memory • Compile-time vs Runtime Binding • Why NullPointerException actually happens • Calling static methods using null references One interesting realization today: Calling a static method using a null reference does NOT throw a NullPointerException. Why? Because static methods belong to the class, not the object. They are resolved at compile time — no heap lookup required. This completely changed how I think about method calls in Java. Instead of asking: 👉 “Does this compile?” I started asking: 👉 “Where is this stored in memory?” 👉 “Is this resolved at compile time or runtime?” 👉 “Does this require an object?” Learning Java logically > memorizing syntax. Day 5 complete. On to understanding dynamic binding and JVM internals next 💪 #Java #LearningJourney #JVM #OOP #BackendDevelopment #SoftwareEngineering 🤩

Method Overriding in Java - where polymorphism actually shows its power Method overriding happens when a subclass provides its own implementation of a method that already exists in the parent class. For overriding to work in Java: • The method name must be the same • The parameters must be the same • The return type must be the same (or covariant) The key idea is simple: The method that runs is decided at runtime, not compile time. This is why method overriding is called runtime polymorphism. Why does this matter? Because it allows subclasses to modify or extend the behavior of a parent class without changing the original code. This is a core principle behind flexible and scalable object-oriented design. A small keyword like @Override might look simple, but the concept behind it is what enables powerful design patterns and extensible systems in Java. Understanding these fundamentals makes the difference between just writing code and truly understanding how Java works. #Java #JavaProgramming #OOP #BackendDevelopment #CSFundamentals

🧠 Why Java Avoids the Diamond Problem Consider this scenario: Two parent classes define the same method: class Father {   void m1() { } } class Mother {   void m1() { } } Now if a child class tries to extend both: class Child extends Father, Mother { } 💥 Ambiguity! Which m1() should Java execute? This is the Diamond Problem — a classic multiple inheritance issue. 🔍 Why Java avoids this: Java does NOT support multiple inheritance with classes to prevent: ✔ Method ambiguity ✔ Tight coupling ✔ Unexpected behavior ✔ Complex dependency chains Instead, Java provides: ✅ Interfaces ✅ Default methods (with explicit override rules) ✅ Clear method resolution This design choice keeps Java applications more predictable and maintainable — especially in large-scale backend systems. As backend developers, understanding why a language is designed a certain way is more important than just knowing syntax. Clean architecture starts with strong fundamentals. #Java #OOP #SpringBoot #BackendDevelopment #SoftwareEngineering #CleanCode #InterviewPrep

I just completed an intensive session focused on the core of Java's efficiency: Immutable Strings and Memory Management. While we often use strings daily, understanding what happens under the hood is what separates a coder from a developer. Key Takeaways from the session: The Power of Command Line Arguments: We explored how the String[] args in the main method actually functions, learning how to pass dynamic data into applications via the CLI—a crucial skill for building professional-grade tools . Strings as Objects: In Java, strings aren't just data; they are objects . I learned the three distinct ways to initialize them: using the new keyword, using string literals, and converting character arrays . Memory Architecture (SCP vs. Heap): This was a game-changer. I now understand that Java optimizes memory by using the String Constant Pool (SCP) for literals to prevent duplicates, while the Heap Area allows for duplicate objects when the new keyword is used . The Comparison Trap: I finally mastered the difference between reference comparison and value comparison. Using == compares the memory address (reference), while the .equals() method compares the actual content . Immutability: We began exploring why certain data, like birthdays or names, are best handled as immutable strings—meaning they cannot be changed once created in memory . I'm looking forward to the next phase of this journey: Object-Oriented Programming (OOP)! . #Java #SoftwareDevelopment #Programming #MemoryManagement #TechLearning #JavaDeveloper #CodingJourney #Tapacadmey

🚀 Day 13— Restarting My Java Journey with Consistency Today's Learnings: 🔹 Instance Variables & Instance Methods These belong to objects and are accessed using the object reference. They help define the state and behavior of objects. 🔹 Local Variables Local variables do not get default values in Java. They must be initialized before use, otherwise the compiler throws an error. 🔹 Constructors in Java Constructors are special methods used to initialize objects at the time of creation. No return type Same name as class Example: Student s1 = new Student(); When an object is created, the constructor is automatically invoked to initialize the object. Types of constructors : • Default Constructor – No parameters • Parameterized Constructor – Accepts values to initialize object fields Important rule: If a programmer defines any constructor, Java does not create a default constructor automatically. 🔹 this Keyword this refers to the current object. It is commonly used to distinguish instance variables from local variables. 🔹 Constructor Overloading A class can have multiple constructors with different parameter lists to initialize objects in different ways. 🔹 Constructor Chaining Using this() we can call one constructor from another constructor within the same class. Important rule: The this() call must be the first statement inside a constructor. Interview Specific: 🔹 Can We Call a Constructor Manually? No. Constructors cannot be called like normal methods. They are automatically invoked when an object is created using the new keyword. 🔹 Interesting Runtime Insight When we create an object using new, Java allocates memory in the heap at runtime. But what if heap does not have enough free space, then Java will throw a runtime exception. Learning daily with Coder Army and Aditya Tandon Bhaiya and Rohit Negi Bhaiya #Day13 #Java #Consistency #BackendDevelopment #LearningJourney #SoftwareEngineering #CoderArmy

What’s changing in the Java ecosystem right now? From language features to build tooling and better ways to learn modern Java. Take a look at these sessions: Learning modern Java -> with IntelliJ tips & tricks: 👩🏻💻 Marit van Dijk & 🥼Piotr Przybył - https://lnkd.in/e7tYnKVY Engineering a Better Java Build Tool: Haoyi Li - https://lnkd.in/eMb-uYqM Java 26 is boring, which is why it is brilliant Johannes Bechberger & Lutske de Leeuw — https://lnkd.in/eqWPdxhc The Art of Java Type Patterns Simon Ritter — https://lnkd.in/e29nqzX4 Join us on April 1–2 → https://lnkd.in/e4DkX8Ht #vdams26 #java