JavaPoet Explained: Automatic AST Translation

🔹 Version 1: Traditional Switch Case Started with the basics of switch-case in Java using the traditional approach. ✔ Uses ":" (colon) syntax ✔ Requires "break" to prevent fall-through ✔ Simple and widely used in older Java versions 🔹 Version 2: Multiple Case Labels Explored handling multiple inputs in a single case block. ✔ Multiple case labels share the same logic ✔ Reduces code duplication ✔ Makes code more readable This version showed me how to simplify conditions when different inputs produce the same result. 🔹 Version 3: Arrow Syntax (->) Learned the modern switch syntax introduced in newer Java versions. ✔ Uses "->" instead of ":" ✔ No need for "break" ✔ More concise and readable 🔹 Version 4: Switch as Expression (No Breaks) Tried using switch as an expression instead of a statement. ✔ No "break" needed ✔ Directly returns a value ✔ More structured and efficient This approach made my code shorter and more expressive. 🔹 Version 5: Single Result Variable Focused on improving code structure by using a single result variable. ✔ All cases return a value ✔ Output handled outside the switch ✔ Better separation of logic and display This makes the code more maintainable and reusable. 🔹 Version 6: Using yield Explored advanced switch expressions using "yield". ✔ Used inside block cases ✔ Allows multiple statements before returning value ✔ More flexibility in logic This helped me understand how to handle complex scenarios inside switch expressions. #java #Codegnan #CodingJourney #SwitchCase My gratitude towards my mentor #AnandKumarBuddarapu #SakethKallepu #UppugundlaSairam

🚀 Day 5 of my Java journey — Abstraction, Enums, Lambda! Today was a deep dive into some of the most powerful features of Java! 🔥 🏗️ Abstract Class — deeper understanding ✅ Abstract class cannot be instantiated directly ✅ BUT you can create an anonymous class from it on the spot! ✅ This is how Java gives flexibility without creating a full new class 🔗 Interface — deeper concepts ✅ Interface can extend another interface ✅ A class can implement multiple interfaces ✅ Deep abstraction — hide implementation, show only what matters 🎯 Types of Interfaces in Java ✅ Normal interface — only abstract methods ✅ Functional interface — exactly ONE abstract method (used with lambda!) ✅ Marker interface — no methods at all, just marks a class (e.g. Serializable) 🔢 Enum in Java ✅ Enum = a fixed set of constants ✅ Example: Days of week, Directions (NORTH, SOUTH, EAST, WEST) ✅ Much safer than using plain int or String constants 💡 Functional Interface + Lambda Expression ✅ @FunctionalInterface annotation — only 1 abstract method allowed ✅ Lambda replaces the need to write a full class! ✅ Before lambda: create a class, implement method, create object ✅ With lambda: just write the logic in one line — clean and powerful! Example: A obj = (int a) -> {   System.out.println("Hello from lambda!"); }; obj.show(5); Java is getting more and more interesting every day! 🚀 Day 1 ✅ | Day 2 ✅ | Day 3 ✅ | Day 4 ✅ | Day 5 ✅ ... #Java #JavaDeveloper #Lambda #FunctionalInterface #Enum #Abstraction #100DaysOfCode #BackendDevelopment #TechCareer #LearningToCode

Think var in Java is just about saving keystrokes? Think again. When Java introduced var, it wasn’t just syntactic sugar — it was a shift toward cleaner, more readable code.  So what is var? var allows the compiler to automatically infer the type of a local variable based on the assigned value. Instead of writing: String message = "Hello, Java!"; You can write: var message = "Hello, Java!"; The type is still strongly typed — it’s just inferred by the compiler.  Why developers love var:  Cleaner Code – Reduces redundancy and boilerplate  Better Readability – Focus on what the variable represents, not its type  Modern Java Practice – Aligns with newer coding standards  But here’s the catch: Cannot be used without initialization Only for local variables (not fields, method params, etc.) Overuse can reduce readability if the type isn’t obvious Not “dynamic typing” — Java is still statically typed  Pro Insight: Use var when the type is obvious from the right-hand side — avoid it when it makes the code ambiguous.  Final Thought: Great developers don’t just write code — they write code that communicates clearly. var is a tool — use it wisely, and your code becomes not just shorter, but smarter. Special thanks to Syed Zabi Ulla and PW Institute of Innovation for continuous guidance and learning support. #Java #Programming

🚫 Java is NOT a pure object-oriented language… and that’s exactly why it wins. When I first started exploring Java in depth, I believed everything was truly object-oriented—it felt like every piece of code revolved around classes. But the deeper I went, the more I realized the reality is far more nuanced… and way more interesting. Here’s the truth 👇 👉 A pure object-oriented language means everything is an object. No exceptions. Languages like Smalltalk follow this strictly. 👉 But Java? It bends the rules. ⚡ Primitive data types exist int, char, boolean, double — these are NOT objects. They don’t belong to any class and don’t inherit from anything. ⚡ Static methods & variables break OOP principles They belong to the class, not objects—so they bypass core concepts like polymorphism. ⚡ Wrapper classes exist… but as a workaround Yes, Integer, Double, etc. exist—but the fact we need them proves primitives aren't objects. So why does Java do this? Because Java chose performance + practicality over purity. Primitive types: ✔ Faster ✔ Memory efficient ✔ Less overhead than objects If Java forced everything to be an object, it would sacrifice speed—especially in large-scale systems. 💡 The takeaway: Java is an object-oriented language, but not purely object-oriented. And that’s not a flaw—it’s a design decision. 👉 In real-world engineering, balance beats ideology. — 💬 What’s your take—does this change how you look at Java? #Java #Programming #OOP #SoftwareEngineering #Coding

Q. Can an Interface Extend a Class in Java? This is a common confusion among developers and even I revisited this concept deeply today. - The answer is NO, an interface cannot extend a class. - It can only extend another interface. But there is something interesting: - Even though an interface doesn’t extend Object, all public methods of the Object class are implicitly available inside every interface. Methods like: • toString() • hashCode() • equals() These are treated as abstractly redeclared in every interface. ⚡ Why does Java do this? - To support upcasting and polymorphism, ensuring that any object referenced via an interface can still access these fundamental methods. ❗ Important Rule: While you can declare these methods in an interface, you cannot provide default implementations for them. interface Alpha { default String toString() { // ❌ Compile time error return "Hello"; } } Reason? Because these methods already have implementations in the Object class. Since every class implicitly extends Object, allowing default implementations of these methods in interfaces would create ambiguity during method resolution. Therefore, Java does not allow interfaces to provide default implementations for Object methods. 📌 Interfaces don’t extend Object, but its public methods are implicitly available. However, default implementations for them are not allowed. #Java #OOP #InterviewPreparation #Programming #Developers #Learning #SoftwareEngineering

📘 Ghost Keywords in Java – `goto` and `const` While learning Java fundamentals, I discovered an interesting concept in the language design: ghost keywords. Java reserves two keywords — `goto` and `const` — but surprisingly, they are not actually used in the language. 🔹 What does this mean? A reserved keyword is a word that cannot be used as an identifier (like a variable name, class name, or method name). Even though `goto` and `const` exist in Java’s reserved keyword list, they have no functionality implemented in the language. For example: ```java int goto = 10; // Compile-time error int const = 20; // Compile-time error ``` Even though they do nothing, the Java compiler still prevents developers from using them. 🔹 Why were they reserved? When Java was being designed, its creators intentionally avoided certain features that could lead to poor coding practices. • *goto`– In languages like C and C++, `goto` allows jumping to different parts of a program. However, it often leads to spaghetti code, making programs difficult to read, maintain, and debug. Java avoided this to promote structured programming. • const`– Instead of `const`, Java introduced the `final` keyword to define constants in a cleaner and more object-oriented way. Example: ```java final int MAX_VALUE = 100; ``` 🔹 **Why keep them reserved?** Keeping these keywords reserved helps prevent naming conflicts and allows flexibility for future language design decisions. 💡 Key takeaway: Sometimes what a programming language chooses not to include* is just as important as what it includes. #Java #Programming #SoftwareDevelopment #ComputerScience #Coding #LearnInPublic

🚨 Java Myth Buster: “Finally block always executes” — Really? 🤔 Most developers confidently say: 👉 “Yes, finally always runs!” ❌ Let’s break that myth with a real example 👇 --- 💻 Code Example: public class Test { public static void main(String[] args) { try { System.out.println("Inside try"); System.exit(1); } finally { System.out.println("Inside finally"); } } } --- 📌 Output: Inside try 😳 Wait… where is the "finally" block? --- 💡 Explanation (Simple & Clear): When "System.exit(1)" is executed: - 🚫 JVM shuts down immediately - 🚫 No further code executes - 🚫 "finally" block is completely skipped --- 🔢 Understanding Exit Codes: - "System.exit(0)" → Normal termination ✅ - "System.exit(1)" → Abnormal termination ❌ 👉 But important point: Both will skip the "finally" block! --- ⚠️ So when does finally NOT execute? ✔️ When JVM is forcefully terminated ✔️ Using "System.exit()" ✔️ JVM crash / system failure ✔️ Infinite loop (control never reaches finally) --- 🧠 Interview Takeaway: 👉 “Finally block executes in almost all cases, except when JVM terminates abruptly like with System.exit().” --- 🔥 This is one of the most asked tricky Java interview questions! 💬 Did you know this before? #Java #JavaDeveloper #CodingInterview #Programming #TechTips #Developers #InterviewQuestions #JavaBasics

Day 43-Understanding Runtime Polymorphism in Java If compile-time polymorphism is about decisions made early, runtime polymorphism is where things get interesting — decisions are made while the program is running. What is Runtime Polymorphism? Runtime polymorphism is the ability of a program to decide which method to execute at runtime based on the object. It is achieved using method overriding. 🔹 Simple Idea: Same method name, same parameters… but different behavior depending on the object. 🔹 Example: class Card { void swipe() { System.out.println("Please wait..."); } } class CreditCard extends Card { void swipe() { System.out.println("Payment via Credit Card"); } } class DebitCard extends Card { void swipe() { System.out.println("Payment via Debit Card"); } } public class Main { public static void main(String[] args) { Card c; c = new CreditCard(); c.swipe(); // Credit Card method c = new DebitCard(); c.swipe(); // Debit Card method } } 🔹 What’s happening here? - The reference type is Card - But the object changes (CreditCard / DebitCard) - JVM decides which method to call at runtime 🔹 Key Points: ✔ Happens at runtime (execution time) ✔ Achieved using method overriding ✔ Also called Dynamic Binding / Late Binding ✔ JVM decides method execution based on actual object This is what makes Java powerful and flexible in real-world applications. #Java #OOP #Polymorphism #CodingJourney #ProgrammingBasics

📌 Method References in Java — Cleaner Than Lambdas Method references provide a concise way to refer to existing methods using lambda-like syntax. They improve readability when a lambda simply calls an existing method. 1️⃣ What Is a Method Reference? Instead of writing a lambda: x -> System.out.println(x) We can write: System.out::println --- 2️⃣ Syntax ClassName::methodName Used when: • Lambda just calls an existing method • No additional logic is required --- 3️⃣ Types of Method References 🔹 Static Method Reference ClassName::staticMethod Example: Integer::parseInt --- 🔹 Instance Method Reference (of object) object::instanceMethod Example: System.out::println --- 🔹 Instance Method Reference (of class) ClassName::instanceMethod Example: String::length --- 🔹 Constructor Reference ClassName::new Example: ArrayList::new --- 4️⃣ Example Comparison Using Lambda: list.forEach(x -> System.out.println(x)); Using Method Reference: list.forEach(System.out::println); --- 5️⃣ Benefits ✔ More readable code   ✔ Less boilerplate   ✔ Cleaner functional style   ✔ Works seamlessly with Streams  --- 🧠 Key Takeaway Method references are a shorthand for lambda expressions that call existing methods. Use them when they improve clarity, not just to shorten code. #Java #Java8 #MethodReference #FunctionalProgramming #BackendDevelopment

📌 Lambda Expressions in Java — Writing Cleaner Code Lambda expressions allow writing concise and readable code by replacing anonymous classes. They are built on functional interfaces. 1️⃣ What Is a Lambda Expression? A lambda is an anonymous function: • No name • No return type declaration • Shorter syntax Syntax: (parameters) -> expression --- 2️⃣ Traditional vs Lambda Before Java 8: Runnable r = new Runnable() {   public void run() {     System.out.println("Hello");   } }; With Lambda: Runnable r = () -> System.out.println("Hello"); --- 3️⃣ Syntax Variations • No parameter: () -> System.out.println("Hi") • One parameter: x -> x * 2 • Multiple parameters: (a, b) -> a + b • Multi-line: (a, b) -> {   int sum = a + b;   return sum; } --- 4️⃣ Why Lambda Is Powerful ✔ Reduces boilerplate code   ✔ Improves readability   ✔ Enables functional programming   ✔ Works seamlessly with Streams  --- 5️⃣ Where Lambdas Are Used • Collections (sorting, filtering) • Streams API • Multithreading (Runnable, Callable) • Event handling Example: list.forEach(x -> System.out.println(x)); --- 6️⃣ Important Rule Lambda works only with: ✔ Functional Interfaces (single abstract method) --- 🧠 Key Takeaway Lambda expressions simplify code by focusing on *what to do*, not *how to implement it*. They are the foundation of modern Java programming. #Java #Java8 #Lambda #FunctionalProgramming #BackendDevelopment