How to count objects created in Java with a simple trick

🚀 Heads-up Java devs: the entry point just got a makeover If you thought every Java program had to start with public static void main(String[] args), the times are changing. With Java SE 21 and onward, the rules around the main() method have been relaxed. Medium+2 🔍 What’s new Java can now use instance main() methods (without static) or even main() with no parameters, in implicitly declared classes. You can skip writing the outer public class HelloWorld { … } in some contexts ("compact source files"). These features started as preview in Java 21 (JEP 445) and later became re-preview in Java 22 (JEP 463). 👍 Why this matters Less boilerplate: Faster to spin up a quick demo or script. Cleaner code: More readable, especially for newbies or quick utilities. Modernised Java: Aligns Java more with scripting or lightweight languages for rapid dev. 📣 Want to try it? // Java 21+ preview mode or above void main() { IO.println("Hello, world!"); } Yep — no public, no static, no args array. Though note: preview features may need enabling until finalised. 🗣 Let’s talk Have you experimented with this new main method style? Would you adopt it in production code, or is it just for demos & quick scripts? What’s a change in Java you wish would come next? Drop your thoughts below — and if you found this useful, hit Follow for more Java/Spring/tech-deep dives. #Java #Java21 #ProgrammingLanguages #SoftwareEngineering #DeveloperNews #SpringBoot #JobOpportunity

🚀 Methods vs. Constructors: Unpacking Key Differences in Java 🚀 New to Java or looking for a quick refresher? Understanding the distinction between Methods and Constructors is fundamental! While both contain blocks of code, they serve very different purposes. Let's break it down with a simple comparison: Constructors: The Blueprint Initializers 🏗️ Purpose: Primarily used to initialize new objects. Think of them as setting up the initial state when an object is first created. Name: Must have the same name as the class itself. Return Type: No return type (not even void). Invocation: Called automatically when you use the new keyword to create an object. Example: new Employee(101, "Alice"); Methods: The Action Performers ⚙️ Purpose: Used to perform actions or operations on an object, or to retrieve information from it. Name: Can have any valid name (following Java naming conventions). Return Type: Must have a return type (e.g., void, int, String, Employee, etc.). Invocation: Called explicitly using the object reference, like object.methodName(). Example: employee.getDetails(); or employee.calculateBonus(); In essence: Constructors build and set up your object. Methods make your object do things. Understanding this distinction is crucial for writing clean, efficient, and object-oriented Java code! Thanks Anand Kumar Buddarapu #Java #Programming #SoftwareDevelopment #OOP #Constructors #Methods #CodingTips

💡 Immutability in Java — why it matters and how to use it effectively Immutability is one of those concepts that makes your Java code safer, cleaner, and easier to reason about. But what does “immutable” really mean? 👇 🧩 What is immutability? An immutable object is one whose state cannot change after it’s created. Once you build it, its data stays the same forever. This prevents unexpected side effects, race conditions, and bugs caused by shared mutable state — especially in multithreaded systems. 🧠 The classic example: String All String objects in Java are immutable. The classic example: String All String objects in Java are immutable String name = "Java"; name.concat(" Rocks!"); System.out.println(name); // "Java" ✅ Even though we called .concat(), it didn’t modify the original string. It returned a new String. ⚙️ final keyword Declaring a variable as final means you can’t reassign the reference — but it doesn’t make the object itself immutable. final List<String> list = new ArrayList<>(); list.add("A"); // ✅ allowed list = new ArrayList<>(); // ❌ not allowed 🧱 record — immutability made easy Since Java 16, record is the easiest way to create immutable data carriers: public record Person(String name, int age) {} Records automatically make fields private and final, and generate constructors, getters, equals(), hashCode(), and toString(). No setters. No mutability. Pure data. 🚀 Why use immutability Makes code thread-safe without synchronization Easier to debug and test Predictable state — no “who changed this object?” moments Simplifies functional programming with Streams and Lambdas 💬 Conclusion: String → always immutable final → prevents reassignment, not mutation record → immutable data structure made simple Immutability is not about restrictions — it’s about predictability and safety. #Java #Backend #CleanCode #Programming #SpringBoot #SoftwareEngineer #DeveloperTip

🧠 Static vs Instance in Java: The Real Difference Explained Understanding the difference between static and instance members is crucial to mastering Java’s memory model and writing clean, efficient code. Here’s what you’ll uncover in this guide: ▪️Static Members → Belong to the class, not objects. Shared across all instances and accessed without creating objects. ▪️Instance Members → Belong to each object individually. Every instance gets its own copy of the variable. ▪️Variables & Methods → Learn how static methods differ from instance methods and what they can access. ▪️Real-World Example → See how a shared static variable (wheels) differs from instance data like color. ▪️When to Use Each → Static for constants and utility logic; instance for unique, object-level data. ▪️Common Pitfalls → Avoid referencing instance variables inside static methods and overusing static data. ▪️Interview Q&A → Covers static blocks, memory efficiency, and key differences tested in real Java interviews. Knowing when to use static vs instance members is what separates beginner code from production-grade design. 📌 Like, Share & Follow CRIO.DO for more practical Java concepts explained visually. 💻 Learn Java the Crio Way At CRIO.DO, you’ll build real-world Java applications mastering concepts like static memory, OOP design, and concurrency through hands-on projects. 🚀 Join our FREE trial today - https://lnkd.in/g9hMB7mM and level up your backend skills! #Java #OOP #CrioDo #SoftwareDevelopment #LearnCoding #StaticVsInstance #JavaBasics #ProgrammingTips #BackendEngineering

☕ Java Execution Made Simple Have you ever wondered how your Java code actually runs behind the scenes? Let’s break it down step by step 👇 🧩 1️⃣ Source Code (.java) You write code in your IDE — it’s human-readable and logical. 👉 Example: System.out.println("Hello Java!"); ⚙️ 2️⃣ Java Compiler (javac) It converts your .java file into a .class file — called bytecode. 🗂️ Bytecode isn’t tied to any OS or processor. 📦 3️⃣ Bytecode (.class) This is platform-independent. You can run (Java fileName) it on any system that has JVM — that’s Java’s “write once, run anywhere” magic! ✨ 🧠 4️⃣ JVM (Java Virtual Machine) JVM takes care of everything at runtime: Class Loader → Loads classes Bytecode Verifier → Checks safety Interpreter → Executes bytecode line by line 🚀 5️⃣ JIT Compiler (Just-In-Time) JIT notices which parts of your code run frequently (called hotspots). It then converts those into machine code for faster execution. ⚡ 6️⃣ Cached Execution Next time the same code runs, JVM uses the cached native code — making it super fast! -- #Java #LearningTogether #CodingSimplified #ProgrammingTips #JVM #SoftwareEngineering

Java Agents and Bytecode Manipulation: Practical Insights for Observability and Control 💡 Java agents are tiny programs that ride along the JVM, shaping how your code runs by touching bytecode as it’s loaded. They hook into the Instrumentation API via premain or agentmain, and they can add a bytecode transformer that rewrites methods on the fly or even redefines already‑loaded classes. 🧰 The core power lies in dynamic observability and behavior enhancement: you can inject timing data, log calls, or enforce constraints without changing your source. Libraries like ByteBuddy provide a safer, expressive way to describe transformations and minimize boilerplate. ⚠️ But there are trade‑offs: instrumentation adds overhead and can complicate debugging if not done carefully. Class‑loading boundaries, security policies, and startup sequencing can limit what you can safely modify in production. Start with targeted transforms and rigorous validation. 🚀 Real‑world patterns include profiling, tracing, and feature toggles. Keep transforms opt‑in and modular; prefer pre‑main agents when you need early instrumentation, and avoid sweeping changes that affect all classes. 🎯 Takeaways: align your goals, measure impact, and keep changes isolated. Pilot in staging, use feature flags, and document governance around live instrumentation. What’s your take? In what scenario would you consider using a Java agent, and what guardrails would you put in place? #Java #Bytecode #InstrumentationAPI #SoftwareEngineering #Observability

🚀 Java 8 — The Update That Changed Everything! Java 8 wasn’t just another update — it was a paradigm shift that redefined how we write Java code. It brought modern functional programming to the mainstream and gave us tools that still shape clean, efficient code today. 💡 Let’s look back at some of its most revolutionary features: 1️⃣ Lambda Expressions — The star of the show! Treat functions as method arguments and eliminate boilerplate. Cleaner, functional, and elegant. 2️⃣ Functional Interfaces — The backbone of Lambdas. Think Runnable, Comparator, or even your own single-method interfaces! 3️⃣ Stream API — A declarative and powerful way to process collections. Filter, map, reduce, and sort data seamlessly — in parallel too! ⚡ 4️⃣ Date & Time API (java.time) — Goodbye java.util.Date chaos 👋 Immutable, thread-safe, and beautifully designed for modern needs. 5️⃣ Default Methods — Backward compatibility done right. Add new methods to interfaces without breaking old code. 6️⃣ Method References — The concise cousin of lambdas. Cleaner syntax when all you need is to call an existing method. 7️⃣ Optional Class — The end of NullPointerException nightmares! ☠️ Forces explicit handling of missing values = more robust code. 8️⃣ CompletableFuture — A game changer for async programming. Compose, chain, and combine asynchronous tasks easily. 9️⃣ Nashorn JavaScript Engine — Better integration between Java & JavaScript for embedded scripting. 💬 Java 8 empowered developers with tools that made Java expressive, efficient, and future-ready. 👉 Which of these features do you still find indispensable in your daily coding life? Let’s discuss in the comments! 👇 #Java #Java8 #Programming #SoftwareDevelopment #Tech #Coding #Developer #FunctionalProgramming #CodeQuality #JavaDeveloper

💡A method is a function that settled down , inside a class, or wherever belonging felt right. Most languages let you write free-floating functions, but Java doesn’t really have them. The Java Language Specification (JLS) never even uses the word “function.” Instead, it uses the word “method” - behavior that must always belong to something. That’s why in Java you can’t just write println("Hello, World"); Every piece of behavior needs a home, System.out.println("Hello, World"); Or in newer versions such as Java 25, IO.println("Hello, World"); It still belongs to something - a class, an object, or a type reference. 🏠 However, with java.util.function, Java introduced a new way to act functional without ever changing its true nature. These aren’t real functions; they’re functional interfaces, single-method contracts. 🧾 When you write a lambda like x -> x * 2 you’re not creating a standalone function , you’re creating an object that behaves like one. The JVM quietly builds a lightweight instance that points to an underlying method, keeping it anchored in Java’s object-oriented structure. #Java #Programming #Coding #ObjectOriented #SoftwareDevelopment #TechExplained #LearnJava #CodingLife

Blog: What if Java Collections had Eager Methods for Filter, Map, FlatMap? "I encourage folks to check out the code in the experiment and maybe try some experiments of their own with Covariant Return Types, Default and Static methods for Interfaces, and Sealed Classes." https://lnkd.in/embc2rTs