SUBODH KUMAR’s Post

Day 65 of Sharing What I’ve Learned 🚀 Creating Threads in Java — Turning Concepts into Execution After building a clear understanding of programs, processes, and threads, the next step was to move from theory to practice — how threads are actually created and used in Java. Understanding what a thread is is important. But knowing how to create and control it is where things start getting real. 🔹 Two Ways to Create Threads in Java Java provides two primary ways to create threads: 1️⃣ Extending the Thread class Here, we create a class that extends Thread and override the run() method. class MyThread extends Thread { public void run() { System.out.println("Thread is running..."); } } public class Main { public static void main(String[] args) { MyThread t1 = new MyThread(); t1.start(); // starts a new thread } } 👉 start() is important — it creates a new thread and calls run() internally. 2️⃣ Implementing the Runnable interface This is the more flexible and commonly used approach. class MyRunnable implements Runnable { public void run() { System.out.println("Thread using Runnable..."); } } public class Main { public static void main(String[] args) { Thread t1 = new Thread(new MyRunnable()); t1.start(); } } 👉 This approach is preferred because Java doesn’t support multiple inheritance, but it allows implementing multiple interfaces. 🔹 Key Difference Thread → Direct but less flexible Runnable → More scalable and widely used in real-world applications 🔹 Important Observation Creating a thread is not just about writing run() 👉 It’s about understanding how execution flow changes run() → normal method call (no new thread) start() → creates a new thread (parallel execution) 🔹 Simple Perspective Thread creation = defining a task start() = actually running it concurrently 🔹 Why This Matters This is where applications start becoming powerful: 👉 Multiple tasks can run independently 👉 Better performance and responsiveness 👉 Foundation for advanced concepts like thread synchronization and concurrency 🔹 My Realization Earlier, execution felt linear — one step after another. Now it’s clear that: 👉 Execution doesn’t have to wait 👉 Tasks can run side by side 👉 Efficiency comes from how we structure execution This is just the next layer — Up next: controlling threads and managing their lifecycle. #Java #Multithreading #Programming #JavaDeveloper #100DaysOfCode #DeveloperJourney #Day65 Grateful for guidance from TAP Academy Sharath R kshitij kenganavar

☕ Core JAVA Notes — Complete Study Guide 📖 About the Document A thorough, beginner-to-intermediate Core Java study guide spanning 130 pages, packed with clear explanations, syntax breakdowns, real code examples, and comparison tables. Scanned and formatted for students and aspiring Java developers. 🚀 🏗️ What's Inside? 🔷 Chapter 1 — Java Introduction ➤ What is Java? — A high-level, object-oriented, platform-independent language by Sun Microsystems (now Oracle), born in 1995 ➤ The legendary "Write Once, Run Anywhere" (WORA) principle powered by the JVM ➤ Key features: Platform Independence, OOP, Robustness, Multithreading, Rich Standard Library ➤ Where Java is used: Web Development, Mobile Apps (Android), Enterprise Systems ➤ First program: Hello, World! 👋 🔶 Chapter 2 — OOP Concepts (Object-Oriented Programming) ➤ Classes & Objects — Blueprints and instances of real-world entities ➤ POJO (Plain Old Java Object) — private fields, constructors, getters/setters, toString/hashCode ➤ Constructors — Default, Parameterized, this() and super() keywords ➤ Inheritance — extends keyword, parent-child relationships, super calls ➤ Polymorphism — Method Overloading & Overriding ➤ Abstraction — Abstract classes & Interfaces ➤ Encapsulation — Access modifiers: public, private, protected 🟡 Chapter 3 — Core Language Features ➤ Data Types, Variables, Operators, Control Statements (if, switch, loops) ➤ Arrays — single/multi-dimensional, iteration patterns ➤ Exception Handling — try, catch, finally, throws, custom exceptions 🟢 Chapter 4 — String Handling ➤ String class — immutable, pool concept ➤ Key methods: length(), charAt(), substring(), equals(), compareTo(), replace() ➤ StringBuilder — mutable, faster, single-threaded environments ➤ StringBuffer — mutable, thread-safe for concurrent modifications 🔵 Chapter 5 — Collections Framework ➤ ArrayList vs Array — dynamic sizing, java.util.ArrayList ➤ List, Set, Map interfaces — HashMap, HashSet, LinkedList ➤ Iterating with for, for-each, and Iterator ➤ Java Collections = store & manipulate groups of objects efficiently 📦 #CoreJava #Java #JavaProgramming #OOPConcepts #LearnJava #JavaForBeginners #ObjectOrientedProgramming #JVM #WORA #JavaCollections #StringHandling #StringBuilder #Inheritance #Polymorphism #Encapsulation #Abstraction #LambdaExpressions #AnonymousClass #Multithreading #JavaInterviewPrep #PlacementPreparation #ComputerScience #CodingNotes #ProgrammingLanguage #SoftwareDevelopment #JavaDeveloper #BackendDevelopment #TechNotes #StudyMaterial #CodeWithJava

🚀 Backend Systems | Post - 3 | How to create Threads in JAVA In the last posts, we understood Multithreading, and the difference between Concurrency and Parallelism , now lets learns how do we actually create threads in Java. 1. Extending the Thread Class You can create a thread by having a subclass which extends the Thread class and overriding the run() method. class MyThread extends Thread { @Override public void run() { System.out.println("Hello World"); } } MyThread t1 = new MyThread(); t1.start(); 2. Implementing Runnable Interface (this is usually recommended) This is the most commonly used approach in real-world systems having a class implements the runnable interface and overriding the run method. what is Runnable interface ? It is functional interface which has only one abstract function run. class MyRunnable implements Runnable { @Override public void run() { System.out.println("Hello World"); } } Thread t1 = new Thread(new MyRunnable()); t1.start(); 💡 Why is this better? --> as in java multilevel inheritance isn't possible with classes but possible with interface , since runnable is a interface because of that it allows for multilevel inheritance , this approach is usually better in backend systems. 3. Using Lambda (Modern Java🔥) In modern java we use lambda as a shortcut way to implement a functional interface , since Runnable is also a functional interface , we use this way when this line of code will only be used only by this thread. Thread t1 = new Thread(() -> { System.out.println("Hello World"); }); t1.start(); ⚠️ Common Mistake (VERY IMPORTANT) Most beginners think this will create a thread: Calling run() directly -->This will NOT create a new thread --> It just runs like a normal function call. --> the correct way is to always use start() to create a new thread. 🚀 Key Takeaways --> Runnable is better than Thread for better design. --> Lambda is a clean way to implement Runnable. --> start() creates a thread, run() does not. #Multithreading #Java #OperatingSystem #BackenedSystems

Hello Connections, Post 17 — Java Fundamentals A-Z This one confuses every Java developer at least once. 😱 Can you spot the bug? 👇 public static void addTen(int number) { number = number + 10; } public static void main(String[] args) { int x = 5; addTen(x); System.out.println(x); // 💀 5 or 15? } Most developers say 15. The answer is 5. 😱 Java ALWAYS passes by value — never by reference! Here’s what actually happens 👇 // ✅ Understanding the fix public static int addTen(int number) { number = number + 10; return number; // ✅ Return the new value! } public static void main(String[] args) { int x = 5; x = addTen(x); // ✅ Reassign the result! System.out.println(x); // ✅ 15! } But wait — what about objects? public static void addName(List<String> names) { names.add("Mubasheer"); // ✅ This WORKS! } public static void main(String[] args) { List<String> list = new ArrayList<>(); addName(list); System.out.println(list); // [Mubasheer] ✅ } 🤯 Java passes the REFERENCE by value! You can modify the object — but not reassign it! Post 17 Summary: 🔴 Unlearned → Java passes objects by reference 🟢 Relearned → Java ALWAYS passes by value — even for objects! 🤯 Biggest surprise → This exact confusion caused a method to silently lose transaction data! Have you ever been caught by this? Drop a 📨 below! #Java #JavaFundamentals #BackendDevelopment #LearningInPublic #SDE2 Follow along for more! 👇

🚀 Mastering Java Exception Handling & Propagation! 🚀 Today was an intensive deep dive into how Java manages those "unusual events" that occur during runtime—Exceptions. Here’s a breakdown of what I learned about keeping programs running smoothly instead of letting them crash abruptly! 💡 What is an Exception? An Exception is an unusual event that occurs during a program's runtime, often due to faulty user input, which leads to abrupt termination. Our goal as developers is to handle these gracefully to ensure normal termination. 🔍 3 Ways to Get Exception Information: When an exception object is generated, we have three main ways to see what went wrong: 1) Printing the Reference (e): Provides the Type of exception and the Reason (Description). This works because the toString method is overridden in the Exception class. 2) e.getMessage(): Provides only the Reason/Description why the exception occurred. 3) e.printStackTrace(): The "complete description." It shows the Type, the Reason, and the exact Location (method and line number) where it occurred. 🌊 Exception Propagation If an exception isn't handled where it occurs, it propagates (travels) up the call stack to the caller method. If no one handles it, the Default Exception Handler takes over, printing the error and abruptly terminating the program. 🛠️ The 3 Strategies for Handling: The sources identify three primary ways to manage these situations: ✅ Try-Catch: Handling it directly at the source. This is considered the best practice. 🔄 Rethrowing: Catching the exception, performing some action, and then using the throw keyword to pass it back to the caller. 🦆 Ducking: "Escaping" or dodging the exception. You don't use a try-catch block; instead, you use the throws keyword in the method signature to warn the caller they must handle it. 💻 Coding Example: The Power of finally One of the most important keywords is finally. This block compulsory executes whether an exception is thrown or not—perfect for closing connections!. public class ExceptionDemo { // Ducking the exception using 'throws' public void calculate() throws ArithmeticException { try { int a = 100, b = 0; int c = a / b; // Risky code! System.out.println("Result: " + c); } catch (ArithmeticException e) { System.out.println("Reason: " + e.getMessage()); throw e; // Rethrowing the exception object reference } finally { // This ALWAYS runs, ensuring normal cleanup System.out.println("Connection Terminated Safely."); } } } 🗝️ Key Takeaway Polymorphism is at the heart of this! Since Exception is the parent class of all exceptions, a parent reference can catch any child exception object (loose coupling). #Java #Coding #BackendDevelopment #ExceptionHandling #ProgrammingTips #LearningJourney #TapAcademy #HarshitT

✅ Day 11 of Studying Java --- 🧠 1. Pass by Value ≠ Pass by Reference (But in Java… it’s tricky!) ✅ In Java, everything is Pass by Value — even object references. 🔹 When you assign `Car b = a;`, you’re copying the *reference value* (memory address), not the object itself. 🔹 Both `a` and `b` now point to the same object → changes via either reference reflect everywhere. 🔸 Real-world analogy? One car, two keys. Change the air freshener with one key → both drivers smell it! ⚠️ Interview Tip: “Java doesn’t have true pass-by-reference — it passes the *value of the reference*. Always clarify with diagrams!” --- 🧱 2. Object Creation & Memory Management in Java 📌 Objects live in the Heap. References live in the Stack. 📌 Instance variables? → Heap. Local variables? → Stack. ♻️ No manual cleanup! Java’s Garbage Collector auto-removes unreferenced objects (the real MVP 🧹). 💡 Fun Fact: Why “Heap”? → It’s where your “heap of garbage” (unreferenced objects) piles up before GC cleans it! --- ⚙️ 3. Java Methods Demystified Every method has 4 parts: 1️⃣ Method Name 2️⃣ Parameters (Input) 3️⃣ Body (Logic) 4️⃣ Return Type (Output) 🎯 4 Types of Methods: - ❌ No input, ❌ No output → `void methodName()` - ❌ No input, ✅ Output → `int methodName() { return value; }` - ✅ Input, ❌ No output → `void methodName(int x)` - ✅ Input, ✅ Output → `int methodName(int x) { return x+1; }` 📌 Pro Tip: `System.out.println()` ≠ returning output. Use `return` for actual data handoff between methods. --- 🏗️ 4. Stack Segment = LIFO in Action 🔁 Last In, First Out (LIFO) — just like your school lunchbox 🍱: → Rice (first in) → Sambar → Snacks (last in) → Snacks eaten first → Rice last! 💻 In Code: The method on top of the stack executes. When done, it pops off → control returns to caller. --- TAP Academy #Java #CoreJava #PassByValue #PassByReference #JavaMemoryManagement #HeapAndStack #JavaMethods #CodingBootcamp #SoftwareDeveloper #TechInterviews #LearnToCode #Programming #JavaOOP #GarbageCollection #JavaTips #CodeNewbie #DeveloperCommunity

⏳ Day 24 – 1 Minute Java Clarity – Exception Handling Basics** Try, Catch, Finally… Java's safety net! 🛡️ 📌 What is an Exception? An unexpected event that disrupts the normal flow of a program. 👉 Java handles this gracefully using try-catch blocks. 📌 Example: class ExceptionDemo {   public static void main(String[] args) {     try {       int result = 10 / 0; // ArithmeticException     } catch (ArithmeticException e) {       System.out.println("Cannot divide by zero! " + e.getMessage());     } finally {       System.out.println("This always runs ✅");     }   } } 📌 Block Breakdown: ✔ try → Code that might throw an exception ✔ catch → Handles the exception ✔ finally → Always executes (clean up code) 💡 Real-time Example: Think of an ATM 🏧 try → You attempt a withdrawal catch → "Insufficient funds!" message shown finally → Card is always returned ✅ 📌 Exception Hierarchy: Throwable ├── Error (JVM level – don't handle) └── Exception   ├── Checked (compile-time)   └── Unchecked (runtime – RuntimeException) ⚠️ Interview Trap: Does finally always execute? 👉 YES — except when `System.exit()` is called or JVM crashes! 📌 Common Exceptions: ✔ ArithmeticException → divide by zero ✔ NullPointerException → null object access ✔ ArrayIndexOutOfBoundsException → invalid index ✔ ClassCastException → invalid type casting ✔ NumberFormatException → invalid string to number 💡 Quick Summary: ✔ try-catch prevents program crashes ✔ finally runs regardless of exception ✔ Checked exceptions must be handled at compile time ✔ Unchecked exceptions occur at runtime 🔹 Next Topic → throw vs throws in Java Did you know `finally` block even runs after a `return` statement? Drop 🔥 if this surprised you! #Java #ExceptionHandling #JavaProgramming #TryCatch #CoreJava #JavaDeveloper #BackendDeveloper #Coding #Programming #1MinuteJavaClarity #100DaysOfCode

Same result. Half the code. Most Java developers don’t use this 😱 Java Fundamentals Series | Part 21 Can you spot the improvement? 👇 List<String> names = Arrays.asList( "Alice", "Bob", "Charlie" ); // ❌ Verbose Lambda names.forEach(name -> System.out.println(name)); // ✅ Method Reference names.forEach(System.out::println); Cleaner. More readable. More professional. 💪 4 Types of Method References 👇 // 1. Static method Function<Integer, Integer> abs = Math::abs; // 2. Instance method of object Function<String, String> upper = String::toUpperCase; // 3. Instance method of instance String prefix = "DBS: "; Function<String, String> addPrefix = prefix::concat; // 4. Constructor reference Function<String, StringBuilder> builder = StringBuilder::new; Real-world example 👇 // ❌ Lambda transactions.stream() .map(t -> t.getAmount()) .forEach(a -> System.out.println(a)); // ✅ Method Reference transactions.stream() .map(Transaction::getAmount) .forEach(System.out::println); Summary: 🔴 Writing lambdas everywhere 🟢 Use method references when method already exists 🤯 Cleaner code = fewer lines + better readability ⸻ 👉 Posting more real-world fixes like this. Have you used method references? Drop a :: below 👇 #Java #JavaFundamentals #BackendDevelopment #LearningInPublic #SDE2

#60DaysOfJava 📚 Day 16 Constructor in Java 🔹 Constructor in Java 👉 Constructor is a special method 👉 Using the constructor we initialize objects at object creation time. 👉 Constructor is called at instance creation time 👉 While constructor is invoked, memory for the object will be allocated. 👉 Constructor doesn’t return anything and we don’t need to mention return type. 👉 abstract, static, final, and synchronized cannot be used with constructor 👉 We can use access modifiers (private, protected, public, default) to control object creation. 🔹 How to Create Constructor Syntax: AccessModifier ClassName() { } 👉 Example: public Employee(String name, double salary) { } 👉 Constructor will be called at object creation time 🔹 Types of Constructor 👉 No Parameterized Constructor 👉 Parameterized Constructor 👉 Copy Constructor 🔹 Example class Employee { String name; double salary; double bonous; 🔹Non parameterized constructor public Employee(){ System.out.println("Constructor called"); } 🔹Parameterized constructor public Employee(String empName,double empSalary){ name = empName; salary = empSalary; } 🔹 Parameterized constructor with different parameter size public Employee(String empName,double empSalary,double empBonous){ name = empName; salary = empSalary; bonous = empBonous; } 🔹 Copy constructor public Employee(Employee employee){ name = employee.name; salary = employee.salary; bonous = employee.bonous; } } 🔹 Notes 👉 Non-parameterized constructor is not mandatory compiler will add it by default 👉 Inside default constructor, values are not initialized explicitly 👉 JVM assigns default values based on data types 👉 Parameterized constructor ➡️ We can overload like normal methods (different type/size) 👉 Copy constructor ➡️ Used to copy values from one object to another ➡️ Not available by default in Java we need to define it 🤵 Follow Hariprasath V for daily more helpful resources. ♻ Repost Others also learn and grow together 👍 Hit if this was helpful. ✅ Save it future use. ================================================ #60DaysOfJavaWithHariprasathv6 #Java #JavaBasics #Programming #Coding #Developers #LearningJava #HighLevelDesign #SystemDesign #DSAChallenge #60DaysOfDSA #ProblemSolving #CodingJourney #Consistency #LearnByDoing #DataStructures #Algorithms #InterviewPrep #KeepCoding #Productivity #Focus #DreamBig #Java #SystemDesign #DataStructures #Algorithms #JavaDeveloper #DSA #CodingInterview #TechInterview #SystemDesignInterview #BackendDevelopment #SoftwareEngineering #JavaInterview #LeetCode #InterviewPrep #DataStructureAndAlgorithms #DesignPatterns #LowLevelDesign #Multithreading #SOLIDPrinciples #RESTAPI #BackendEngineer #CodeInterview #interviewtips #interviewexperience #Java #Programming #CoreJava #Learning #Developers #OOP

🚀 Day 5 of Java 8 Series 👉 Question: Find the frequency of each word in a given sentence using Java 8 Streams. import java.util.*; import java.util.function.Function; import java.util.stream.Collectors; public class WordFrequency {   public static void main(String[] args) {     String sentence = "java is great and java is powerful";     Map<String, Long> frequencyMap = Arrays.stream(sentence.split("\\s+"))         .collect(Collectors.groupingBy(             Function.identity(),             Collectors.counting()         ));     System.out.println(frequencyMap);   } } Output: {java=2, powerful=1, and=1, is=2, great=1} 🧠 Key Concepts Explained 👉 1. Arrays.stream() Converts an array into a Stream, which allows us to perform functional operations like filtering, grouping, and counting. In this example, after splitting the sentence into words, we use it to start the stream pipeline. 👉 2. split("\\s+") (Regex) \\s → matches any whitespace (space, tab, newline) + → matches one or more occurrences 💡 This ensures that even if there are multiple spaces between words, the sentence is split correctly into individual words. 👉 3. Collectors.groupingBy() This is used to group elements based on a key. Here, we group words by their value (Function.identity()) So all same words come under one group Example: java → [java, java] 👉 4. Collectors.counting() Used along with groupingBy() to count the number of elements in each group. Instead of storing a list of words, it directly gives the frequency #Java #Java8 #Streams #Coding #Developers #Learning