Understanding public static void main(String[] args) in Java

Day 20: Exploring Java Interfaces with Static, Private, and Public Methods 🧑💻 Today I practiced Java interfaces and learned: Static methods – Called using the interface name (Calculator.add(...)) Private methods – Used inside the interface to support other methods Public methods – Implemented in the class (multiply(...)) Example: int sum = Calculator.add(5, 10); SimpleCalculator calc = new SimpleCalculator(); int product = calc.multiply(5, 10); 💡 Key takeaway: Interfaces in Java can now have static, private, and default methods, making code modular and reusable. ✅ Note: Before Java 1.8, interfaces could only have abstract methods. From Java 1.8, default and static methods were introduced. From Java 1.9, private methods in interfaces became possible to help reuse code inside the interface. 10000 Coders #Java #Interface #OOps #LearningEveryDay #100DaysOfCode #Day20 #CodingJourney

💫 Object Class in Inheritance : In Java, every class directly or indirectly inherits from the Object class, which is the root of the class hierarchy. This means all classes automatically get the basic behavior provided by Object, even if we don’t explicitly extend it. ✅ Key Points: Object is the parent of all classes in Java. If a class doesn’t extend any class, Java implicitly makes it a child of Object. Provides essential methods like: 🔹 toString() → returns string representation of an object 🔹 equals() → compares two objects 🔹 hashCode() → returns hash value of object 🔹 clone() → creates object copy (if implemented) 🔹 finalize() → cleanup before garbage collection 🔹 getClass() → gets runtime class details 🔹 wait() → Causes the current thread to pause execution 🔹 notify() → The notified thread moves from waiting to runnable state 🔹 notifyAll() → Wakes all threads waiting on the object’s monitor. 🚀 Conclusion The Object class is the foundation of inheritance in Java. It standardizes behavior across all classes and enables powerful features like polymorphism. Thanks to our mentor Anand Kumar Buddarapu Sir for your guidance and support. #Java #ObjectClass #JavaProgramming #CoreJava

⚙️ Deep Dive into Java Interfaces, Exception Handling, and Collections Framework Ever wondered how Java manages polymorphism, abstraction, and safe error handling — all while keeping performance in check? 🤔 That’s exactly what I explored this week while learning Java in depth. Here’s a quick breakdown of what I learned 👇 💥 1️⃣ Exception Handling — Writing Robust Code Learned about throw, throws, and the difference between checked & unchecked exceptions. Explored how try, catch, and finally blocks work under the hood. Understood how Java ensures program stability even when errors occur. 📚 2️⃣ Collections Framework — Efficient Data Management Understood why Java Collections are used instead of arrays. Studied the time complexity and internal working of List, Set, and Map. Learned how data structures like HashMap, LinkedHashSet, and ArrayList are implemented internally. 🧩 3️⃣ Interfaces — The Power of Abstraction Understood how interfaces help achieve polymorphism and multiple inheritance in Java. Learned that interfaces can extend other interfaces but cannot implement them. Explored default methods (Java 8+), which allow method bodies inside interfaces. Attached my handwritten summary 📸 for a quick glance at these key interface concepts. 🚀 Takeaway: Understanding these topics gave me deeper insight into how Java ensures modularity, flexibility, and runtime efficiency — the backbone of backend development. #Java #BackendDevelopment #LearningJourney #JavaDeveloper #ExceptionHandling #CollectionsFramework #Interface #OOP #SpringBoot #CodingJourney #SoftwareDevelopment #TechLearning

💡 Many people code every day... but few truly know what this line actually means! Let’s fix that 👇 𝒑𝒖𝒃𝒍𝒊𝒄 𝒔𝒕𝒂𝒕𝒊𝒄 𝒗𝒐𝒊𝒅 𝒎𝒂𝒊𝒏(𝑺𝒕𝒓𝒊𝒏𝒈[] 𝒂𝒓𝒈𝒔) This tiny line is where every Java program comes to life ⚡ Here’s the breakdown: 🟢 𝐩𝐮𝐛𝐥𝐢𝐜 → Accessible from anywhere. JVM calls it from outside the class — so it must be public. 🟣 𝐬𝐭𝐚𝐭𝐢𝐜 → No need to create an object! JVM can directly run this method. 🔵 𝐯𝐨𝐢𝐝 → It returns nothing. It just starts your program — no value needed. 🟠 𝐦𝐚𝐢𝐧 → The heart of every Java program ❤️ Execution always begins here. 🟡 𝐒𝐭𝐫𝐢𝐧𝐠[] 𝐚𝐫𝐠𝐬 → Command-line inputs! If we Run this 👉 𝒋𝒂𝒗𝒂 𝑴𝒚𝑷𝒓𝒐𝒈𝒓𝒂𝒎 𝑯𝒆𝒍𝒍𝒐 𝑱𝒂𝒗𝒂 then you’ll get it as 𝘢𝘳𝘨𝘴[0] = "𝘏𝘦𝘭𝘭𝘰", 𝘢𝘳𝘨𝘴[1] = "𝘑𝘢𝘷𝘢" 💬 ✨ Next time you type 𝐩𝐮𝐛𝐥𝐢𝐜 𝐬𝐭𝐚𝐭𝐢𝐜 𝐯𝐨𝐢𝐝 𝐦𝐚𝐢𝐧(𝐒𝐭𝐫𝐢𝐧𝐠[] 𝐚𝐫𝐠𝐬), remember — it’s not just a syntax line, it’s where your Java story begins! 🚀 #Java #Coding #LearnDaily #ProgrammingBasics #CodeWithPassion Anand Kumar Buddarapu

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

💡 The final Keyword in Inheritance: Ensuring Immutability 🔒 The final keyword in Java is a powerful tool for imposing limitations and ensuring immutability. When applied in the context of inheritance, it dictates how classes and methods can be extended or modified. 1. final Classes (No Inheritance) When you declare a class as final, it cannot be inherited by any other class. Syntax: public final class ParentClass { ... } Effect: You cannot create a subclass from it (e.g., you cannot say class ChildClass extends ParentClass). Use Case: Often used for security and integrity. Core Java classes like String and wrapper classes (e.g., Integer) are final to prevent their core behavior from being altered. 2. final Methods (No Overriding) When you declare a method as final in a parent class, that method cannot be overridden by any child class. Syntax: public final void calculateSalary() { ... } Effect: Any class inheriting from the parent must use the parent's exact implementation of that method. Use Case: Used to protect critical business logic or behavior that must remain consistent across the entire hierarchy, ensuring no subclass breaks the intended functionality. 3. final Variables (No Reassignment) While not strictly an inheritance rule, final variables are crucial to understand within objects. Effect: A final variable cannot be reassigned once it has been initialized. Use Case: Used to create constants (static final PI = 3.14) or ensure that an object's state (like an id) remains unchanged after the constructor runs. Mastering the final keyword is key to designing rigid, reliable, and secure class hierarchies. Thank you sir Anand Kumar Buddarapu,Saketh Kallepu,Uppugundla Sairam,Codegnan #Java #OOP #ProgrammingTips #FinalKeyword #Inheritance #SoftwareDevelopment

💡 What I Learned Today: Heap vs Stack Memory in Java While revisiting Java memory concepts, I dived deeper into understanding the difference between Heap and Stack memory. Here are the main differences.👇 🧠 Heap Memory - Used to store objects and their instance variables. - Shared across all threads. - Managed automatically by the Garbage Collector. - Example: Person p = new Person(); → The object lives in the heap. ⚙️ Stack Memory - Used for method execution, storing local variables and references. - Each thread has its own stack, making it thread-safe. - Automatically cleared once the method finishes. - Example: The variable p (the reference) lives in the stack. In short — ➡️ Heap = “Where objects live” ➡️ Stack = “Where methods run” Understanding this helps avoid memory issues, improve performance, and write cleaner, more predictable Java code. 🚀 #Java #MemoryManagement #JavaDeveloper #CodingTips #LearningJourney #BackendDevelopment

💻 public static void main(String[] args) 🌟 Every Java application needs a starting line, and that's precisely what the public static void main(String[] args) method is! Think of it as the main switch 💡 that the Java Virtual Machine (JVM) flips to kick off your program's execution. Without it, your code is just a collection of instructions with no starting point! Here is a spotlight on each component's vital role: • public 🔓: This is an access modifier. It makes the method accessible from anywhere, including outside the class. The JVM needs to call this method to start your program, so it must be publicly accessible. • static 🏛️: This keyword means the method belongs to the class itself, rather than any specific object of that class. This is crucial because it allows the JVM to call the main method directly without having to first create an instance (object) of the class. • void 🛑: This specifies the return type is empty. The main method does not return any value. Once the program's execution within this method is complete, the program simply terminates. • main 🎯: This is the standard, recognized name for the entry point method in Java. The JVM specifically looks for a method named main to begin execution. Don't change this name! • (String[] args) 🗣️: This declares a parameter that is an array of String objects. This array is how your program receives command-line arguments that users can pass to the Java program when it's executed. #Java #Programming #JDK #JRE #JVM #CoreJava Codegnan Anand Kumar Buddarapu

💡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