Java Encapsulation and Constructors: A Deeper Dive

📘 Day 72 | Learning Update 📌 Topic - Collection Framework in Java Today's I learned: ✅️ Stack Class in Java ✔️ Declaration of Stack Class ✔️ Methods of Stack Class ✔️ Implementation of Stack Class ✅️ Queue Interface In Java ✔️ Declaration of Queue Interface ✔️ Common Implementations of Queue Interface ✔️ Methods of Queue Interface 1️⃣ ArrayDeque – Resizable, double-ended queue. 🔹️Syntax, Methods & Example ( Non-Generic & Generic Collection of ArrayDeque ) 2️⃣ LinkedList – Doubly linked list implementation. 🔹️Syntax, Methods & Example ( Non-Generic & Generic Collection of LinkedList ) 3️⃣ PriorityQueue – Queue ordering elements by priority. 🔹️Syntax, Methods & Example ( Non-Generic & Generic Collection of PriorityQueue ) ✅️ Difference Between ArrayDeque, LinkedList & PriorityQueue ✅️ Map Interface in Java ✔️ Declaration of Map Interface ✔️ Common Implementations of Map Interface ✔️ Methods of Map Interface ✔️ Implementation of Map Interface 1️⃣ HashMap – Unordered key-value pairs using hashing. 🔹️Syntax, Methods & Example ( Non-Generic & Generic Collection of HashMap ) 2️⃣ LinkedHashMap – Insertion-ordered key-value pairs. 🔹️Syntax, Methods & Example ( Non-Generic & Generic Collection of LinkedHashMap ) 3️⃣ TreeMap – Sorted key-value pairs. 🔹️Syntax, Methods & Example ( Non-Generic & Generic Collection of TreeMap ) ✅️ Difference Between HashMap, LinkedHashMap & TreeMap 🚀 Thanks to my mentor PRATIKSHA INDROL Ma'am for helping me understand the Collection Framework in Java with simple and practical explanations.💻✨️ #Day72 #Domain #CoreJava #JavaProgramming #LearningJourney #FortuneCloud #CollectionFramework #180DayChallenge #JavaFullStackDeveloper

💬 Day 6 of My Journey to Learning Java ☕ Today’s focus was on making my programs more interactive and logical — learning how to take user input, perform calculations, and use operators effectively. Here’s what I explored 👇 🔹 Basic I/O in Java: Learned how to use the Scanner class to take input from users. Example: import java.util.Scanner; Scanner sc = new Scanner(System.in); int num = sc.nextInt(); It’s amazing how a few lines can make a program feel alive — accepting input and responding dynamically. 🔹 Arithmetic & Unary Operators: Practiced how operators control the logic of calculations: Arithmetic Operators: +, -, *, /, % — used for performing basic mathematical operations. Unary Operators: ++ and -- — used to increase or decrease a value by 1. Example: int a = 5; System.out.println(++a); // Pre-increment → 6 System.out.println(a++); // Post-increment → 6, then becomes 7 🔹 Hands-On Practice: Solved small but powerful problems today 💡 ✔️ Swapping two numbers without a third variable ✔️ Calculating Simple Interest ✔️ Practiced several MCQs to strengthen fundamentals 💡 Reflection: Today’s practice helped me connect syntax with problem-solving. Writing code that actually takes input, performs logic, and returns output — that’s when programming starts to feel real. #Java #JavaLearning #ProgrammingJourney #100DaysOfCode #CodeEveryday #LearnInPublic #DeveloperInMaking #BackendDevelopment #JavaDeveloper

💡 Today’s Java Learning: Method Overloading & Compile-Time Polymorphism Today, I explored a brand new concept — Method Overloading in Java. Here’s a 1-minute recap 🧠👇 🔹 Definition: Method Overloading means defining multiple methods with the same name in a class, but with different parameter lists (number or type). 🔹 How Java Resolves It: At compile time, the Java compiler checks: 1️⃣ Method name 2️⃣ Number of parameters 3️⃣ Type of parameters …and calls the correct version — avoiding any confusion. 🔹 Key Insight: No method is truly “overloaded.” Each method performs its own unique task — we, as programmers, just assume one name does many things. 🔹 Why Called Compile-Time Polymorphism? Because the method to be executed is decided at compile time. 🔹 Polymorphism in Simple Words: “One in many forms.” Example: Water 💧 Ice ❄️ → Solid Water 💦 → Liquid Steam 🌫️ → Gas That’s polymorphism — and method overloading is its compile-time version! 🚀 #Java #Learning #Polymorphism #MethodOverloading #JavaDeveloper #CodingJourney

💡 Call by Value vs. Call by Reference: How Data is Passed in Programming 🤝 Understanding how functions/methods receive arguments is critical for predicting a program's behavior, especially when dealing with data manipulation. The two main ways to pass arguments are: 1. Call by Value (Copying the Data) What it does: A copy of the argument's actual value is passed to the method. Result: Changes made to the parameter inside the method do not affect the original variable outside the method. In Java: All primitive types (int, char, boolean, etc.) are always passed by Call by Value. 2. Call by Reference (Passing the Memory Address) What it does: The actual memory address (or a reference to the data) is passed to the method. Result: Changes made to the object inside the method will affect the original object outside the method. The key takeaway for Java: When you pass an object to a method, you're passing a copy of the reference (Call by Value), but since that copy points to the original object in memory, the method can modify the object's content (e.g., changing a value in an array or a field in an object). You just can't make the original reference variable point to an entirely new object outside the method. Mastering this distinction is key to debugging subtle data-related bugs! Thank you sir Anand Kumar Buddarapu,Saketh Kallepu,Uppugundla Sairam,Codegnan #Java #Programming #CodingFundamentals #SoftwareDevelopment #Codegnan

🚀 Java Learning – I once wondered: 👉 “Why can’t we modify a String like we do with a StringBuilder?” Here’s why Strings are immutable in Java 👇 1️⃣ Security – Strings store sensitive data like DB URLs, usernames, and passwords. If they were mutable, their values could be changed after creation. 2️⃣ String Pool Optimization – The JVM reuses immutable Strings to save memory and improve performance. 3️⃣ Thread Safety – Immutable Strings can be shared safely across multiple threads. 4️⃣ HashMap Reliability – The hashCode of a String stays constant, making it a reliable key in Maps. ✨ Takeaway: Immutability is one of the key reasons Java is secure, efficient, and consistent. #Java #JavaDeveloper #Coding #TechLearning #StringImmutability #SoftwareDevelopment #Programming #CleanCode #JavaTips

Today, I explored some interesting LeetCode problems to strengthen my Java and DSA fundamentals. Here’s a quick breakdown of what I solved 👇 🔹 Problem 1: Toeplitz Matrix 🧩 Question: Check whether all diagonals from top-left to bottom-right contain the same elements. 🧠 Approach: Traverse the matrix and compare each element with its bottom-right diagonal neighbor. If any mismatch occurs, return false; otherwise, true. This ensures every diagonal maintains uniformity. 📊 Complexity: Time: O(m × n) Space: O(1) 💡 Key Learning: Strengthened understanding of 2D array traversal and pattern validation. 🔹 Problem 2: Largest Number At Least Twice of Others 🧩 Question: Find the index of the largest element if it’s at least twice as large as every other element; otherwise, return -1. 🧠 Approach: Scan the array once to find the largest and second-largest elements. Check if the largest element is ≥ 2 × (second-largest). If true, return its index; else, return -1. 📊 Complexity: Time: O(n) Space: O(1) 💡 Key Learning: Practiced efficient single-pass array traversal and comparison logic. 🔹 Problem 3: Shortest Completing Word 🧩 Question: Given a license plate string and a list of words, find the shortest word that contains all the letters (and their frequencies) from the license plate. 🧠 Approach: Clean the license plate (keep only letters, make lowercase). Count frequency of each letter. For each word, check if it fulfills the required frequency. Track and return the shortest valid word. 📊 Complexity: Time: O(k × n), where k = number of words and n = average word length Space: O(1) 💡 Key Learning: Improved string manipulation, frequency mapping, and logical optimization. 🔥 Overall Takeaway: Practicing diverse problems like these boosts my problem-solving mindset, enhances Java coding efficiency, and builds confidence in tackling real-world algorithmic challenges 💪 Profile link ->https://lnkd.in/gFH_4R9a #Java #LeetCode #ProblemSolving #DSA #CodingPractice #LearningJourney #Developer #TechSkills #CodingInJava

☕ Continuing My Journey in Java — Building Strong Foundations Before OOP After comparing Java and JavaScript in my earlier post, I’ve now officially begun exploring Java in depth. Before diving into Object-Oriented Programming, I’m focusing on understanding how a Java program is structured — the true foundation of everything that follows. Today, I learned that every Java program is built from the following core elements: 🔹 Whitespace – Enhances code readability by separating elements, though ignored during execution. 🔹 Identifiers – Names that uniquely define classes, methods, and variables. 🔹 Comments – Non-executable notes that make code easier to understand and maintain. 🔹 Literals – Constant values such as numbers or strings that remain unchanged during execution. 🔹 Operators – Symbols that perform specific actions on variables or data. 🔹 Separators – Characters such as semicolons, parentheses, and braces that organize code structure. 🔹 Keywords – Reserved words that define Java’s syntax and behavior. I also explored: 🔹 Variables – Named memory locations used to store data. In Java, they’re declared with a data type followed by a name, e.g., int age = 25; 🔹 Escape Sequences – Special character combinations used to format output, like \n for a new line or \t for a tab. Understanding these fundamentals is helping me appreciate how Java enforces structure, readability, and precision — qualities that make it a powerful Object-Oriented language. 🚀 #Java #LearningJourney #OOP #ProgrammingFundamentals #SoftwareDevelopment #Coding #DataScience

Day 26 : Today’s Java Learning: Interfaces Unlocked! Interfaces in Java aren’t just syntax—they’re a powerful design principle. I dove deep into how interfaces help achieve standardization, polymorphism, and loose coupling in code. Here's what I learned: 🔹 An interface is a collection of pure abstract methods—only method signatures, no bodies. 🔹 It acts like a contract: any class that implements it must honor its structure. 🔹 Interface references can point to implementing class objects, enabling flexible polymorphism. 💡 12 Key Rules of Interfaces I explored today: 1️⃣ Interfaces standardize method naming across implementations. 2️⃣ Promote polymorphism and loose coupling. 3️⃣ All methods are implicitly public abstract. 4️⃣ Specialized methods aren’t accessible via interface reference. 5️⃣ Partial implementation = abstract class. 6️⃣ No diamond problem—interfaces don’t inherit method bodies. 7️⃣ Interfaces cannot implement other interfaces. 8️⃣ But they can extend other interfaces (hello, multiple inheritance!). 9️⃣ A class can extend another class and implement interfaces (in that order). 🔟 Variables in interfaces are public static final by default. 1️⃣1️⃣ Empty interfaces = Marker Interfaces (used for tagging). 1️⃣2️⃣ You cannot instantiate an interface directly. 📌 This session helped me appreciate how interfaces shape scalable, maintainable code. Next up: diving into real-world use cases and design patterns using interfaces! If you’re exploring Java or building interview-ready logic, let’s connect and grow together. I love sharing my journey and learning from yours! #JavaLearning #InterfacesInJava #ObjectOrientedProgramming #Polymorphism #MarkerInterface #JavaInterviewPrep #CodeWithClarity #TapAcademy #LinkedInLearning #WomenWhoCode #TechJourney TAP Academy

💬 Day 4 of My Journey to Learning Java ☕ Today’s focus was on the core building blocks of Java — concepts that decide how data is stored, accessed, and managed inside a program. Here’s what I explored 👇 🔹 Introduction Recap: Revised how Java programs are written, compiled, and executed — understanding how the JVM (Java Virtual Machine) makes Java platform-independent. 🔹 Keywords in Java: Learned about the reserved words that define the structure of a Java program. Examples — class, public, static, if, else, return Each keyword has a specific role that keeps code organized and meaningful. 🔹 Data Types in Java: Understood the two major categories: Primitive types → store actual values (int, double, char, boolean) Non-primitive types → store references (String, Arrays, Classes`) Choosing the right type helps with memory optimization and precision. 🔹 Scope & Types of Variables: Discovered how variables behave based on where they’re declared: Local variables – exist only inside methods Instance variables – belong to individual objects Static variables – shared across all objects Understanding variable scope helps prevent unexpected data conflicts in large programs. 💡 Reflection: The more I explore Java, the more I realize — it’s not just about writing code; it’s about writing code that the machine and humans both can understand clearly. Slow and steady — but always forward. 🚀 #Java #JavaLearning #ProgrammingJourney #100DaysOfCode #BackendDevelopment #LearnInPublic #JavaDeveloper #CodeEveryday #DeveloperInMaking #DSA