Mastering Java Wrapper Classes & Utility Methods

Scored 3100/3100 in the Java Online Test by CodeChef But beyond the score, here’s the framework I’m taking away from this experience: 1. What I learned from the test This wasn’t just about knowing Java — it was about applying concepts under time pressure. I realized the importance of: • Strong fundamentals (data structures, logic, syntax clarity) • Writing optimized and clean code on the first attempt • Staying calm and focused throughout 2. Lessons for others preparing for similar tests If you’re aiming for these assessments: • Don’t just “practice questions” — understand patterns • Focus on accuracy first, then speed • Simulate real test environments to build confidence • Read questions carefully — small details matter more than you think 3. How this impacts me going forward This experience reinforces that consistency beats intensity. It gives me more confidence to: • Approach real-world problems with structured thinking • Perform under pressure • Keep improving beyond just test performance At the end of the day, a perfect score is just a milestone — the real goal is becoming a better problem solver every day #Java #CodingJourney #ProblemSolving #TechGrowth #Developers #Learning

Day 5/100 – Java Practice Challenge 🚀 Continuing my #100DaysOfCode journey by diving deeper into Java OOP concepts. 🔹 Topic Covered: Abstraction using Abstract Class Abstraction helps in hiding internal implementation and exposing only the required functionality. 💻 Practice Code: 🔸 Abstract Class abstract class Employee { abstract void work(); void companyPolicy() { System.out.println("Follow company rules"); } } 🔸 Implementation Class class Developer extends Employee { void work() { System.out.println("Developer writes code"); } } 🔸 Usage public class Main { public static void main(String[] args) { Employee emp = new Developer(); emp.work(); emp.companyPolicy(); } } 📌 Key Learnings: ✔️ Cannot create object of abstract class ✔️ Can have both abstract & concrete methods ✔️ Supports partial abstraction ✔️ Used when classes share common behavior 🎯 Focus: "What to do" instead of "how to do" 🔥 Interview Insight: Abstract classes are useful when we want to provide a base structure with some common implementation. #Java #100DaysOfCode #OOP #JavaDeveloper #CodingJourney #LearningInPublic

Day 14/60 🚀 Extends Thread vs Implements Runnable — Clear Comparison In Java multithreading, there are two main ways to create a thread: 👉 Extending the "Thread" class 👉 Implementing the "Runnable" interface This comparison highlights the key differences 👇 --- 💡 When you extend the Thread class 🔹 You cannot extend another class (Java doesn’t support multiple inheritance) 🔹 Task logic and thread execution are tightly coupled 🔹 Code reusability is limited 🔹 Slight overhead due to additional Thread methods 🔹 Maintenance becomes harder as code grows 👉 Best suited for simple or quick implementations --- 💡 When you implement Runnable interface 🔹 You can still extend another class 🔹 Task and thread are loosely coupled 🔹 Better code reusability (same task can run in multiple threads) 🔹 No unnecessary overhead 🔹 Easier to maintain and scale 👉 Preferred in real-world applications --- 🔥 Core Idea Both approaches ultimately execute the same method: ➡️ "run()" But the difference lies in design flexibility and scalability --- ⚖️ Simple Conclusion ✔ Use Thread → when simplicity matters ✔ Use Runnable → when flexibility, scalability, and clean design matter --- 📌 One-line takeaway: Runnable focuses on task, Thread focuses on execution --- #Java #Multithreading #CoreJava #Thread #Runnable #JavaDeveloper #Programming #SoftwareEngineering #BackendDevelopment #Concurrency #TechConcepts #CodingJourney #DeveloperLife #InterviewPreparation #FreshersJobs #LearnJava #100DaysOfCode #WomenInTech #CareerGrowth #LinkedInLearning #CodeNewbie

🚀 Why Runnable is Preferred Over Thread in Java? Many beginners start with extending the Thread class, but in real-world development, Runnable (or lambda) is the preferred approach. Let’s understand why 👇 🔹 Problem with Thread Class Java supports single inheritance. 👉 If you write: class A extends Thread ❌ You cannot extend any other class 🔹 Real-Time Scenario class A extends B 👉 Now you want threading also… ❌ You CANNOT do: class A extends B, Thread // Not possible 🔹 Solution: Use Runnable(Functional Interface)✅ class A extends B implements Runnable { public void run() { System.out.println("Running"); } } 👉 Now you can: ✔ Extend another class ✔ Use threading ✔ Follow clean design 🔹 Why Runnable is Better? ✔ Supports flexibility ✔ Follows good design (separates task & thread) ✔ Works with modern APIs (ExecutorService, ThreadPool) ✔ Supports lambda expressions 🎯 Key Takeaway 👉 “Since Java supports single inheritance, we use Runnable instead of extending Thread to achieve better flexibility and design.” #Java #Multithreading #JavaDeveloper #Coding #SoftwareEngineering #Learning

🧩 Day 7 & Day 8: From Escape Sequences to Dynamic Java Programs 🚀💻 Every small concept in Java builds toward writing clean, professional, and scalable code—and the past two days were a perfect example of that. 🔹 Day 7: Mastering Escape Sequences I explored how Java handles special characters and how to control them using the backslash \. Key learnings: ✔️ \" → Print double quotes inside strings ✔️ \\ → Display backslash (useful for file paths) ✔️ \n → Create new lines for structured output ✔️ \t → Align content in a tabular format ✔️ \b → Fine-tune output using backspace This helped me understand how to make output cleaner and more readable—an underrated but essential skill. 🔹 Dynamic Coding & Efficient Output I took a step closer to real-world programming by making my Java programs dynamic and efficient. 💡 Highlights: ✔️ Used Command Line Arguments (String[] args) to pass data at runtime ✔️ Built an Employee Details Program without hardcoding values ✔️ Practiced writing output using only ONE System.out.println() statement ✔️ Combined escape sequences to format output professionally 🎯 What I Built: A Java program that: Accepts employee details dynamically Displays structured output using \n and \t Handles special characters like file paths using \\ 📌 Key Takeaway: Writing code is not just about logic—it’s also about how clearly your program communicates its output. Clean formatting + dynamic input = professional code. #JavaFullStack #CodingChallenge #CleanCode #CommandLine #Java2026 #LearningInPublic #Day7 #Day8 #BackendDeveloper #SoftwareEngineering #10000Coders

A lesson Java taught me over time: 👉 Consistency beats cleverness. Early in my career, I tried to write “smart” code — one-liners, complex streams, fancy abstractions. It worked… but only I understood it. In large teams and enterprise systems, that doesn’t scale. Now I focus on: ✔ Writing predictable code ✔ Following consistent patterns ✔ Keeping things easy to read and debug Because in real-world systems: Someone else will maintain your code Bugs will happen under pressure Clarity matters more than brilliance 💡 Insight: The best code is not the smartest — it’s the most understandable. #Java #CleanCode #SoftwareEngineering #BackendDevelopment #TechLeadership

I used to think learning Java was just syntax and code… until it proved me wrong. 💡 But over time, I realized something — it’s not about how much you cover, it’s about how much you truly understand. There were moments where I could explain a concept… but couldn’t apply it confidently. That’s when it hit me — I wasn’t learning deeply, I was just moving fast. ⚡ So now, I’m changing my approach. Slowing down. Asking more questions. Breaking things until I actually understand how they work. 🧠 This journey is no longer about “finishing Java” — it’s about building strong fundamentals that actually stay. I’ll be sharing what I learn along the way — the small insights, mistakes, and lessons that make a difference. 📌 What’s one concept you thought you understood… until you had to actually use it? 🤔 #Java #LearningInPublic #DeveloperJourney #Consistency #Growth

Unlocking the Power of Java: From Interfaces to Lambda Expressions! 🚀 Today’s class was a deep dive into some of the most critical concepts in Java, specifically focusing on advanced Interface features and the road to Exception Handling. Here are my key takeaways from the session: 1. JDK 8 & 9 Interface Features We revisited interfaces and explored how they’ve evolved. I learned about concrete methods in interfaces: Default Methods: For achieving backward compatibility. Static & Private Methods: For better encapsulation and code reusability within the interface. 2. Functional Interfaces A Functional Interface is defined by having only one Single Abstract Method (SAM). Examples include Runnable, Comparable, and Comparator. This is the foundation for writing concise code. 3. The "4 Levels" of Implementing Functional Interfaces The instructor used a brilliant analogy about "security levels" (locking a bicycle outside vs. keeping it inside the house vs. Z+ security) to explain the different ways to implement a functional interface: Level 1: Regular Class (Basic implementation). Level 2: Inner Class (Better security). Level 3: Anonymous Inner Class (No class name, high security). Level 4: Lambda Expression (Maximum security and cleanest code!). 4. Mastering Lambda Expressions We explored the syntax () -> {} and learned that Lambdas can only be used with Functional Interfaces. If an interface has multiple abstract methods, Java gets confused! We also looked at parameter type inference and when parentheses are optional. 5. Exception Handling vs. Syntax Errors We started touching on Exception Handling, distinguishing between: Errors: Syntax issues due to faulty coding (Compile time). Exceptions: Runtime issues due to faulty inputs (Execution time). Understanding these concepts brings me one step closer to mastering Advanced Java and JDBC. Continuous learning is the key! 💻✨ #Java #Programming #LambdaExpressions #FunctionalInterface #ExceptionHandling #Coding #TechLearning #SoftwareDevelopment #Java8 #OOPS TAP Academy

Generics in Java always felt simple… until wildcards came in. Recently spent some time understanding how ?, ? extends, and ? super actually work. It looks small, but it completely changes how you design flexible and type-safe code. So I made a short PPT to break it down in a way that’s easier to understand. No heavy theory, just trying to make the concept clear. This is one of those topics that feels confusing at first, but once it clicks, it actually makes a lot of sense. Still exploring Java deeper, one concept at a time… let’s see where it goes. #Java #Generics

🚀 Day 75 — LeetCode Practice 🚀 Today’s problem: To Lower Case 💡 What I learned today: • Understood how to convert characters using built-in string methods • Learned the importance of string immutability in Java • Practiced writing clean and minimal code • Realized that sometimes the simplest problems reinforce core concepts 🧠 Key Idea: Use Java’s inbuilt function: toLowerCase() → converts all uppercase letters to lowercase easily 🔥 Takeaway: Not every problem needs complex logic — knowing the right method saves time ⏱️ Consistency > Complexity 💯 #Day75 #LeetCode #Java #DSA #CodingJourney #Consistency #Learning