"Learning Exception Handling in Java: Day 19"

💻 Day 11 of My Java Learning Journey 💯 ~ Understanding Short-Circuit Operators in Java (&& and ||) Today, I explored an important concept in Java: Short-Circuit Operators — && (AND) and || (OR). These operators help in making conditional statements more efficient by controlling how expressions are evaluated. 🔹 What Are Short-Circuit Operators? Short-circuiting means that Java stops evaluating further conditions once the result is determined. && (AND Operator): → If the first condition is false, the second condition is not evaluated. → Used when both conditions must be true. || (OR Operator): → If the first condition is true, the second condition is not evaluated. → Used when only one condition needs to be true. 🧩 Code Example -------------------------------------code start-------------------------------------- public class ShortCircuitDemo { public static void main(String[] args) { // && operator examples int x = 15, y = 12; if (--x >= 14 && --y <= 12) { --x; } else { --y; } System.out.println("x = " + x + " y = " + y); int p = 15, q = 12; if (--p >= 15 && --q <= 10) { --p; } else { --q; } System.out.println("p = " + p + " q = " + q); // || operator examples int a = 10, b = 5; if (++a >= 10 || ++b <= 5) { ++a; } else { ++b; } System.out.println("a = " + a + " b = " + b); int n = 8, m = 3; if (++n >= 10 || ++m <= 2) { ++n; } else { ++m; } System.out.println("n = " + n + " m = " + m); } } -------------------------------------code output-------------------------------------- x = 13 y = 11 p = 14 q = 11 a = 12 b = 5 n = 9 m = 4 -------------------------------------code end-------------------------------------- 💡 Key Takeaways && → If the first condition is false, the second is skipped. || → If the first condition is true, the second is skipped. Helps in optimizing code execution and avoiding unnecessary evaluations. Learning these small but impactful details helps me write smarter and more efficient Java code every day. 🚀 #Day11 #JavaLearning #ShortCircuitOperators #LogicalOperators #100DaysOfCode #JavaDevelopment #ProgrammingConcepts #DevOps #CodingJourney #YuviLearnsJava

💡 Today’s Learning: Method Overloading in Java Today, I explored Method Overloading in more depth! 🚀 Yesterday, I learned that the Java compiler differentiates overloaded methods using: 1️⃣ Number of parameters 2️⃣ Data types of parameters 3️⃣ Sequence of parameters 4️⃣ Check impicit typecasting But today, I discovered one more key factor — 👉 Implicit Typecasting — the compiler also considers it while resolving overloaded methods. However, it can sometimes cause ambiguity in certain cases! ⚠️ I also noticed that several built-in methods in Java are overloaded: substring(int beginIndex) substring(int beginIndex, int endIndex) println() and print() in System.out printf() and format() methods 🧠 Quick Mind Map Recap 🌟 Method Overloading 🌟 │ ┌────────────────────────┼────────────────────────┐ │ │ │ 📘 Definition ⚙️ Compiler Checks 🧩 Built-in Examples │ ├─ Name │ ├─ Same method name ├─ No. of params ├─ println() ├─ Different params ├─ Data types ├─ print() │ ├─ Sequence of params ├─ substring() │ └─ Implicit typecasting └─ printf() │ 💭 Can cause ambiguity if compiler finds multiple matches 💻 Example: class Demo { void show(int a) { System.out.println("Int: " + a); } void show(double a) { System.out.println("Double: " + a); } public static void main(String[] args) { Demo d = new Demo(); d.show(10); // calls show(int) d.show(10.5); // calls show(double) d.show('A'); // implicit typecasting → int → show(int) } } 🔍 Bonus Concept: Can the main() method be overloaded? ✅ Yes! We can overload the main() method in Java. However, the JVM always starts execution from the standard method signature: public static void main(String[] args) If we create another overloaded main() method, JVM won’t call it automatically — we need to call it manually from the original main. Example: class Test { public static void main(String[] args) { System.out.println("Main method with String[] args"); main(10); // Calling overloaded main } public static void main(int a) { System.out.println("Overloaded main with int parameter: " + a); } } 🧩 So, JVM recognizes the main() method by its method signature — public static void main(String[] args) — not just by its name. ✨ Key Takeaway: Method Overloading improves code readability, reusability, and flexibility — a powerful concept in Java’s Object-Oriented Programming! 💪 #Java #OOPs #MethodOverloading #LearningJourney #Programming #CodeEveryday #JavaDeveloper

⭐💻 Star Pattern Programs in Java 🚀 Learning Java becomes even more fun when you practice pattern programs! These Star Pattern Programs are a great way to improve your logic building, loop control, and problem-solving skills. ✅ Covers: • Basic to Advanced Star Patterns • Pyramid, Triangle & Diamond Patterns • Number & Character Patterns • Logical Thinking with Nested Loops 🎯 Perfect For: • Beginners learning Java fundamentals 🎓 • Students preparing for coding interviews 💼 • Developers improving logic-building & problem-solving skills ⚡ Start practicing these patterns today and build a solid foundation in Java programming! 👉 2000+ free courses free access https://lnkd.in/eSRBi64n 𝐅𝐫𝐞𝐞 𝐆𝐨𝐨𝐠𝐥𝐞 & 𝐈𝐁𝐌 𝐂𝐨𝐮𝐫𝐬𝐞𝐬 𝐢𝐧 𝟐𝟎𝟐6, 𝐃𝐨𝐧’𝐭 𝐌𝐢𝐬𝐬 𝐎𝐮𝐭 𝐨𝐫 𝐘𝐨𝐮’𝐥𝐥 𝐑𝐞𝐠𝐫𝐞𝐭 𝐈𝐭 𝐋𝐚𝐭𝐞𝐫! Introduction to Generative AI: https://lnkd.in/enQETEtu Google AI Specialization https://lnkd.in/ezYU6P3b Google Prompting Essentials Specialization: https://lnkd.in/eCAb5m3j Crash Course for Python https://lnkd.in/eNPZE74F Google Cloud Fundamentals https://lnkd.in/eMbczkqy IBM Python for Data Science https://lnkd.in/eCYYhCte IBM Full Stack Software Developer https://lnkd.in/eegYi7ya IBM Introduction to Web Development with HTML, CSS, JavaScript https://lnkd.in/eFs_bbRa IBM Back-End Development https://lnkd.in/ebiZfsM2 Full Stack Developer https://lnkd.in/eYy5bZKA Data Structures and Algorithms (DSA) https://lnkd.in/e7EMvayd Machine Learning https://lnkd.in/eNKpDUGN Deep Learning https://lnkd.in/ebDwXb24 Python for Data Science https://lnkd.in/e-csZZsf Web Developers https://lnkd.in/ezHuwkdR Java Programming https://lnkd.in/eQpQCmb8 Cloud Computing https://lnkd.in/ezQg7fN7

🔜 🚀 Day 8 of Learning java 🔁 Looping Statements 💡 Definition: Looping statements are used to execute a block of code repeatedly as long as a given condition is true. They help avoid writing the same code multiple times and make programs more efficient, readable, and organized ⚡ ⚙️ Main Parts of a Loop 🟢 Initialization 🧩 Sets up the starting point of the loop (usually a counter variable). 📍 It runs only once, before the loop begins. 🔴 Condition Checking 🔍 The loop checks whether the condition is true or false. ✅ If true, the loop body executes. ⛔ If false, the loop stops. 🟡 Statements (Body of the Loop) 💬 The main block of code that executes repeatedly as long as the condition remains true. 📦 It contains the logic or operations you want to perform multiple times. 🔵 Increment / Decrement 📈 Updates the control variable after each iteration. 🚫 Prevents infinite looping by moving toward the termination condition. 🧭 Types of Looping Statements 🔹 1️⃣ For Loop 🕒 Used when the number of repetitions is known in advance. 🧠 All parts of the loop — initialization, condition, and increment/decrement — are written together. 🔁 Ideal for count-controlled iterations. ex. for (initialization; condition; increment/decrement) {   // statements } 🔹 2️⃣ While Loop 🔍 Used when the number of repetitions is unknown. 📋 The condition is checked before executing the loop body. ⚙️ Executes only if the condition is true. ex.while (condition) {   // statements } 🔹 3️⃣ Do-While Loop 🔂 Similar to the while loop, but the condition is checked after the loop body. ✅ Ensures the loop body executes at least once, even if the condition is false. 📍 Commonly used for menu-driven or input-validation programs. ex.do {   // statements } while (condition); 🔹 4️⃣ For-Each Loop (Enhanced For Loop) 📦 Used for iterating over arrays or collections. 🔁 Automatically goes through each element one by one without needing an index variable. 🧠 Ideal for simplifying array or list traversal. 🚀 In Summary Looping statements make your program: 🔄 More efficient 🧠 Easier to maintain ⚡ Cleaner and less repetitive ex. for (dataType variable : arrayName) {   // statements }

🚀 Day 57 & 58 of My Java Full Stack Learning Journey Topic: ABSTARCTION IN JAVA 💡 Today, I dived deep into one of the most powerful OOPs concepts — Abstraction. It’s like magic 🪄 — showing only what’s necessary and hiding all the complexity behind the scenes. Just think about using an ATM 💳 — We simply insert the card, press a few buttons, and get the cash. But do we know how the machine internally communicates with the bank server? Nope! 👉 That’s exactly what Abstraction does in Java. 💬 What I Learned: ✨ Abstraction hides implementation details and shows only essential features. ✨ It increases security, reduces complexity, and improves maintainability. ✨ It can be achieved in two ways: 1️⃣ Abstract Classes — allow partial implementation. 2️⃣ Interfaces — define only method declarations (until Java 7). With Java 8+, interfaces became more powerful: ✅ default methods ✅ static methods ✅ private methods (from Java 9) And yes — I also explored Functional Interfaces with Lambda Expressions, which make code cleaner and more expressive! ⚡ 🧩 Quick Example: interface Bank { void deposit(double amount); void withdraw(double amount); } abstract class Account { double balance; abstract void openAccount(); void showBalance() { System.out.println("Current Balance: " + balance); } } class SBI extends Account implements Bank { void openAccount() { System.out.println("SBI Account Opened ✅"); } public void deposit(double amount) { balance += amount; } public void withdraw(double amount) { balance -= amount; } } public class TestAbstraction { public static void main(String[] args) { Account acc = new SBI(); acc.openAccount(); ((SBI) acc).deposit(5000); ((SBI) acc).withdraw(2000); acc.showBalance(); } } Output: SBI Account Opened ✅ Deposited: 5000.0 Withdrawn: 2000.0 Current Balance: 3000.0 🧠 My Takeaway: 💭 Abstraction helps developers focus on what to do, not how to do it. It’s like separating the “menu” from the “recipe” — we just choose what we need, and the behind-the-scenes logic takes care of the rest! I’m enjoying how each OOP concept builds a stronger foundation for becoming a confident Full Stack Developer 💪 #Java #Abstraction #OOPsConcepts #FullStackDevelopment #180DaysOfCode #LearningJourney #JavaProgramming #WomenInTech #TechLearner #CodeWithLaya #DevelopersCommunity #Motivation

💻 Day 3 — Java Learning Journey 🚀 Topic: Happy Number using Recursion in Java Today I practiced recursion by writing a simple program to check if a number is a Happy Number. 👉 What is a Happy Number? A number is called happy if the sum of the squares of its digits eventually becomes 1. Example: 13 → (1² + 3²) = 10 → (1² + 0²) = 1 ✅ Here’s my Java code 👇 public class Top_ji {   static int sum = 0;   public static void top(int num) {     sum = 0;     if (num <= 9) {       if (num == 1) {         System.out.println("Happy number");       } else {         System.out.println("Not a happy number");       }       return;     }     while (num > 0) {       int r = num % 10;       sum = sum + (r * r);       num = num / 10;     }     top(sum);    }   public static void main(String[] args) {     top(13);   } }

🌟 Day 14 of My Java Learning Journey 🔥 💯 Hey everyone! 👋 ~ Today’s topic was all about decision-making in Java — how a program chooses which path to follow based on given conditions. 💡 . I explored how to find the greatest number among multiple values using nested if-else statements, one of the core parts of selection statements in Java. 💻 Here’s the code I worked on today: 👇 -------------------------------------code start-------------------------------------- public class FindGreaterNumberDemo2 { public static void main(String[] args) { int p = 11; int q = 22; int r = 33; int s = 44; if (p > r && p > s && p > q) { System.out.println("p is greater number "); } else if (q > s && q > p && q > r) { System.out.println("q is greater number"); } else if (r > p && r > s && r > q) { System.out.println("r is greater number"); } else { System.out.println("s is greater number"); } } } -------------------------------------code output------------------------------------ s is greater number ---------------------------------------code end-------------------------------------- . 🔍 Explanation: We have four integer variables: p, q, r, and s. Using an if-else-if ladder, we compare each number with the others using the logical AND (&&) operator. The first condition that turns out true will print which number is the greatest. If none of them match, the else block executes, showing that s is the greatest. . 💡 Key Takeaway: Selection statements like if, else if, and else help control the program’s logic — deciding what happens next depending on the condition. . 🚀 What’s next? In the upcoming posts, I’ll share many more real-world examples related to selection statements, so we can deeply understand how decision-making works in Java programs. Stay tuned — it’s gonna get crazy cool and more practical! 💻🔥 . #Java #100DaysOfCode #Day14 #JavaLearningJourney #FlowControl #IfElse #SelectionStatements #DevOps #Programming #CodingJourney #LearnJava #TechLearner #CodeNewbie .

I recently started learning Java. And learning it after Python feels like learning to drive manual after automatic 😅 Here's my roadmap and what I'm discovering at each stage: 1️⃣ Basic (Week 1-2) - Syntax & Variables, Data Types, Control Flow, Loops, Arrays. - I'm realising Java's strictness teaches discipline Python let me skip. - 𝘍𝘪𝘳𝘴𝘵 𝘴𝘵𝘳𝘶𝘨𝘨𝘭𝘦: Remembering semicolons and type declarations everywhere. 2️⃣ OOPs (Week 3-4) - Classes & Objects, Inheritance, Polymorphism, Abstraction, Encapsulation. - Everything MUST be in a class - no shortcuts. - Forces you to think in objects from day one. - Understanding why Java is called "𝘱𝘶𝘳𝘦𝘭𝘺 𝘰𝘣𝘫𝘦𝘤𝘵-𝘰𝘳𝘪𝘦𝘯𝘵𝘦𝘥" compared to Python's hybrid approach. 3️⃣ Collections (Week 5) - List, Set, Map, Generics, Iterators. - ArrayList vs LinkedList isn't just preference - it's understanding when fast access beats fast insertion. 4️⃣ Exception Handling (Week 6) - Try-Catch, Throw & Throws, Custom Exceptions. - Learning when to catch exceptions vs when to throw them. - Exception handling separates amateur code from production-ready code. 5️⃣ File I/O (Week 7) - FileReader/Writer, BufferedReader/Writer, Serialization. - Reading and writing files efficiently. Buffered I/O is significantly faster than basic I/O - matters at scale. - Serialization lets you save object states - crucial for real applications. 6️⃣ Multithreading (Week 8-9) - Thread & Runnable, Synchronization, Executors. - Mind-bending but powerful. Making programs do multiple things simultaneously without breaking. - 𝘏𝘢𝘳𝘥𝘦𝘴𝘵 𝘱𝘢𝘳𝘵 𝘴𝘰 𝘧𝘢𝘳: Understanding thread safety and avoiding race conditions. 7️⃣ Java 8+ (Week 10) - Lambda, Stream API, Functional Interfaces, Date & Time API. - Modern Java feels cleaner. Lambdas reduce boilerplate, Streams make data processing elegant. - This is where Java catches up to modern programming paradigms. 8️⃣ JDBC (Week 11) - Connection, Statements, Transactions. - Connecting Java to databases. Every backend application needs this. - Learning to write clean database code that doesn't leak connections or crash under load. 9️⃣ Frameworks (Week 12-14) - Spring Boot, Hibernate, Maven/Gradle. - The real world runs on frameworks. Spring Boot powers enterprise applications globally. - This is where Java's verbose nature pays off - frameworks handle the boilerplate. 🔟 Web Dev (Week 15-16) - Servlets & JSP, REST API, Spring MVC. - Building actual web applications. RESTful APIs are how modern apps communicate. - 𝘎𝘰𝘢𝘭: Build a complete backend system that can handle real traffic. 😥 Why am I learning Java when Python dominates AI? Enterprise systems run on Java. Python gets you started, Java gets you scale. Where are you in your Java journey? What's tripping you up? 👇 Follow Arijit Ghosh for daily shares and my learning journeys #Java #roadmap #programming

Java Developers! Your Ultimate Cheat Sheet is Here Whether you’re revising for interviews or writing production-grade code, remembering all Java keywords can be tricky. Here’s a quick reference guide that covers everything 1️⃣ Data Types: int, double, char, boolean, var 2️⃣ Control Flow: if, for, while, switch, yield 3️⃣ OOP Concepts: class, interface, extends, implements, super, this 4️⃣ Access Modifiers: public, private, protected 5️⃣ Exception Handling: try, catch, finally, throw, throws 6️⃣ Threads: synchronized, volatile 7️⃣ Modules (Java 9+): module, exports, requires, open 8️⃣ Sealed Classes (Java 17+): sealed, non-sealed, permits 9️⃣ Others: return, void, static, transient, assert, enum A must-have for every Java learner and developer who wants to code efficiently! Which section do you find most challenging to memorize? Free Courses you will regret not taking in 2025 👇 1. Python for Data Science, AI & Development https://lnkd.in/dU86J2eh 2. Crash Course on Python https://lnkd.in/dwBEaw4j 3. Python for Everybody https://lnkd.in/dERUNTkr 4. Data Analysis with Python https://lnkd.in/dCkR_UFW 5. Python 3 Programming Specialization https://lnkd.in/dbrtiZq9 6. Programming for Everybody https://lnkd.in/dPHeFia5 7. IBM Generative AI Engineering https://lnkd.in/dfwgQMkc 8. IBM AI Developer https://lnkd.in/drxG_Shn 9. Machine Learning Specialization https://lnkd.in/dX8DPYZd 10. AI For Everyone https://lnkd.in/dyuata4J 11. Artificial Intelligence (AI) https://lnkd.in/dX5XRi2N 12. Google Data Analytics https://lnkd.in/dvP__MU2 13. Google Cybersecurity https://lnkd.in/db6_ymtp 14. Google Project Management https://lnkd.in/dupKAyBF 15. Prompt Engineering Specialization https://lnkd.in/dBDur4fZ 16. IBM Data Science https://lnkd.in/dGPXtRm3 17. SQL https://lnkd.in/dPaRaeaB 18. Microsoft Cybersecurity Analyst https://lnkd.in/dFiSUbDm 19. Programming with Python and Java Specialization https://lnkd.in/d2JKYqnw 20. Statistics with Python Specialization https://lnkd.in/d8274rHu 21. AI Python for Beginners https://lnkd.in/dQycfi68 Follow Java Assignment Helper for more #Java #Programming #Developers #SoftwareEngineering #Coding #TechLearning #OOP #CodeWithJava #JavaDeveloper