Java final, finally, finalize() Clarified

After finishing Loops, I went through the basic building blocks of a Java program to connect everything I’ve written so far. This wasn’t about writing new code. It was about understanding what the code is actually made of. What became clearer: - how keywords, identifiers, literals, operators, and comments fit together - why main() is the starting point and not just a rule to memorize - how objects are created and methods are invoked step by step - the role of imports and why they exist - how indentation and structure affect readability, not execution - that every program is just a combination of small building blocks working together Seeing a complete program broken down into these parts helped me understand why Java feels strict and structured. Big realization for me: - earlier, I was writing code line by line - now I can see how each line plays a specific role in the whole program This felt like a good pause point before moving ahead. #Java #LearningInPublic #Beginner #DSA

𝗧𝗵𝗶𝗻𝗴𝘀 𝗜 𝘄𝗶𝘀𝗵 𝗜 𝗸𝗻𝗲𝘄 𝘄𝗵𝗲𝗻 𝗜 𝘀𝘁𝗮𝗿𝘁𝗲𝗱 𝗝𝗮𝘃𝗮 When I started learning Java, I thought: “If I know syntax, I’m good.” Turns out… not even close 😅 𝗔 𝗳𝗲𝘄 𝘁𝗵𝗶𝗻𝗴𝘀 𝗜 𝗿𝗲𝗮𝗹𝗹𝘆 𝘄𝗶𝘀𝗵 𝗜 𝘂𝗻𝗱𝗲𝗿𝘀𝘁𝗼𝗼𝗱 𝗲𝗮𝗿𝗹𝗶𝗲𝗿: Java is way more than the core language. Spring, Maven/Gradle, JVM, logs, configs—this is where real-world Java lives. Readable code beats smart-looking code. I used to feel proud writing “clever” code. In production, boring and clear code wins. OOP matters. Encapsulation, SOLID principles, and design patterns decide whether your code scales or suffers. Exception handling isn’t optional. Catching Exception everywhere feels easy until debugging becomes a nightmare. Performance problems usually start with bad design. Not Java. Not the framework. Mostly… us 😬 Frameworks change. Fundamentals don’t. Collections, concurrency, and JVM basics will always matter. Java gave me a strong foundation, but real growth started when I stopped thinking like someone who just writes code and started thinking like a software engineer. If you’re early in your Java journey, stick with it. It gets better. And yes, it’s worth it. #Java #Developers #SoftwareEngineering #SpringBoot #CareerGrowth #CleanCode

𝗧𝗵𝗲 𝗝𝗮𝘃𝗮 𝗖𝗼𝗱𝗲 𝗬𝗼𝘂’𝗹𝗹 𝗜𝗻𝗵𝗲𝗿𝗶𝘁 𝗜𝘀 𝗠𝗼𝗿𝗲 𝗜𝗺𝗽𝗼𝗿𝘁𝗮𝗻𝘁 𝗧𝗵𝗮𝗻 𝘁𝗵𝗲 𝗝𝗮𝘃𝗮 𝗖𝗼𝗱𝗲 𝗬𝗼𝘂 𝗪𝗿𝗶𝘁𝗲 Most Java discussions focus on features, performance, or frameworks. But in real-world systems, the hardest part of Java isn’t writing code it’s living with it. Somewhere, someone will open your Java class at 2 a.m. because production is misbehaving. They won’t care how clever the stream pipeline is or how many patterns you used. They’ll care whether they can understand what’s happening in under five minutes. This is where Java quietly teaches discipline. Explicit types force intent. Clear method names act like documentation. Boring, predictable structure becomes a survival feature, not a limitation. The best Java code isn’t impressive it’s readable under pressure. Modern Java gives us plenty of power: records, sealed classes, virtual threads. But the real skill is knowing when not to use them. Great Java engineers design code that future engineers can debug, extend, and trust without fear. In fast-moving teams, languages come and go. But systems that last tend to have one thing in common: someone cared about the next person reading the code.That mindset is why Java still runs the most unglamorous, mission-critical parts of the internet and probably will for a long time. #Java #CleanCode #SoftwareDesign #BackendEngineering #MaintainableCode #DeveloperMindset #ProgrammingLife #EnterpriseSoftware

Day 44/100 | Building Consistency 🗽 Showing up every day. Learning, growing, and improving. Today I went back to the basics that actually matter: understanding how Java code runs behind the scenes. It’s not just writing code — it’s knowing what happens after you press Run. Java Execution Flow (simple & powerful): 1️⃣ HelloWorld.java → Written by us (human-readable source code) 2️⃣ Java Compiler (javac) → Converts source code into bytecode 3️⃣ HelloWorld.class → Platform-independent bytecode 4️⃣ JVM (Java Virtual Machine) → Translates bytecode into machine code 5️⃣ Output runs on the system 🚀 This is why Java is called: “Write Once, Run Anywhere.” The JVM is the real hero here — it handles memory, security, portability, and execution. Day 44 reminded me: 👉 Strong developers don’t skip fundamentals. 👉 Understanding execution makes debugging, optimization, and backend work much easier. Still showing up. Still building clarity. Still learning Java the right way. 💪☕ #Day44 #Java #JVM #JavaBasics #BackendJourney #Consistency #LearningInPublic #CodeLife

📅 Day 6– Exception Handling & Clean Error Design in Java Today I focused on one of the most important (and often ignored) parts of backend development — exception handling. In real-world applications, handling errors properly is just as important as writing business logic. 🔹 Key learnings from today: Difference between checked and unchecked exceptions Why custom exceptions make code more readable and maintainable Avoiding empty catch blocks 🚫 Using global exception handling in Spring Boot with @ControllerAdvice Returning meaningful error responses instead of generic messages 🔹 Why this matters: Good exception handling: ✔ Improves debugging ✔ Makes APIs more reliable ✔ Enhances user experience ✔ Keeps code clean and professional “Clean code is not just about happy paths — it’s about handling failures gracefully.” 📌 Still learning, still improving, one concept at a time. #Java #JavaDeveloper #SpringBoot #BackendDevelopment #ExceptionHandling #CleanCode #LearningJourney #SoftwareEngineering #LinkedInDaily

This is a great reminder that Java’s evolution has always been problem-driven, not trend-driven. Each major release focused on what engineers actually struggled with in production: • Safety and readability • Expressiveness and maintainability • Stability and long-term support • Reducing boilerplate without sacrificing clarity That’s why Java continues to scale well in enterprise systems — it evolves cautiously, but with purpose. As engineers, upgrading Java isn’t about chasing versions — it’s about adopting the right features that simplify real-world problems. #Java #SoftwareEngineering #BackendDevelopment #SystemDesign

Currently expanding my skill set by exploring Java and Spring Boot, and the learning journey has been both insightful and rewarding. Recently, I explored the concept of Dependency Injection, which plays a key role in building scalable and maintainable applications. Instead of tightly coupling classes by creating dependencies manually, Spring manages and injects required components automatically. This approach helps in: - improving code maintainability - promoting loose coupling - making applications easier to test and extend. Understanding these core principles is helping me strengthen my backend fundamentals and write cleaner, more structured code. #SoftwareEngineering #BackendDevelopment #ContinuousLearning

🚀 Day 2/100 – Understanding How Java Actually Runs Day 1 was about logic. Day 2 was about execution and internals. Instead of just writing programs, I focused on understanding what actually happens when Java code runs. Writing code is one thing. Understanding the runtime model is another. 📌 Deep Dive Today: 🔹 Java Execution Pipeline • .java → Compilation → .class (Bytecode) • Bytecode → JVM → Native Machine Code • JDK vs JRE vs JVM • What actually makes Java platform-independent 🔹 Boilerplate & Structure • Public class rules • main(String[] args) • File naming & compilation constraints 🔹 Variables & Memory • Stack-level understanding of primitives • Identifiers vs literals • Assignment & reassignment behavior 🔹 Data Types • Primitive vs Non-Primitive • Size & range awareness (byte → double) • Why Java is statically typed 🔹 Type Conversion & Promotion • Widening (implicit) • Narrowing (explicit) • Lossy conversion scenarios • Why byte * byte promotes to int 🔹 Input Handling • Scanner class • next(), nextLine(), nextInt(), nextFloat() • Buffer behavior 💻 Implemented & Tested: ✅ Sum & Product programs ✅ Area of a circle ✅ User-input-based programs ✅ Memory reassignment example ✅ Explicit & implicit type casting cases (Sharing handwritten notes 📖) 💡 Key Insight: Once you understand: Source Code → Bytecode → JVM → Execution You stop treating Java as syntax. You start treating it as a runtime system. That shift changes how you debug, design, and optimize. 🔁 System Update: Concept → Implement → Understand Runtime → Reflect No zero days. Learning under the guidance of Apna College & Shradha Khapra, focusing on mastering fundamentals before moving into complex DSA patterns. This is not just coding practice. It’s building execution-level clarity. Day 2 complete. Consistency compounds. #Day2 #100DaysOfCode #Java #JVM #DSAJourney #PlacementPreparation #LearningInPublic #ApnaCollege

🛠️Engineering Perspective – Monday One thing I’ve noticed after spending more time with Java codebases is how rarely problems come from complex logic. Most issues start with small decisions that compound over time. A quick shortcut here. An unclear method name there. A piece of logic placed where it doesn’t really belong. Individually, they seem harmless. Together, they make systems hard to reason about. Good engineering isn’t about avoiding mistakes entirely. It’s about making choices that limit how expensive those mistakes become. Clean structure, clear boundaries, and intentional decisions make Java code more resilient as it grows.