Understanding Java Arrays from Memory Perspective

Another concept that appears while studying class initialization in Java is the instance block. It behaves differently from static blocks and is tied to object creation rather than class loading. Things that became clear : • an instance block runs every time an object of the class is created • it executes before the constructor • it can be used to perform common initialization steps for objects • unlike static blocks, instance blocks run for each object created • they are part of the object initialization process A simple structure shows the execution flow : class Demo { { System.out.println("Instance block executed"); } Demo() { System.out.println("Constructor executed"); } public static void main(String[] args) { Demo d = new Demo(); } } When the object is created, the instance block executes first and then the constructor runs. Understanding this order helps in seeing how Java prepares an object step by step during creation. #java #oop #programming #learning #dsajourney

Day 5 of Learning Java : Today I started my journey into Java programming which is taught by Aditya Tandon Sir. Here are the key concepts I learned today: Type Conversation In Java:- In Java, "type conversion" is the process of changing a value from one data type to another. 1. Implicit Type Conversation • This happens automatically when we pass a value from a smaller primitive datatype to a larger primitive datatype. Because we are moving to a "bigger container," there is no risk of losing data. ∆ The Hierarchy: byte → short → char → int → long → float → double 2. Explicit Type Conversation • This must be done manually by placing the type in parentheses ( ) in front of the value. This is used when moving from a larger type to a smaller type. • It can loss the data. (e.g., losing decimals or overflowing). ∆ The Hierarchy: double → float → long → int → char → short → byte This is just the beginning. Excited to continue this journey Special thanks to Rohit Negi ne bhaiya & Aditya Tandon Sir. #Day5 #Java #Coding #Learning #Consistency

Day 49 of Sharing What I’ve Learned🚀 ArrayList in Java In the Java Collections Framework, ArrayList is one of the first classes that helps manage data easily and efficiently. 🔹 What is ArrayList? ArrayList is a dynamic array in Java that can grow and shrink automatically as elements are added or removed. Unlike normal arrays, you don’t need to worry about size — it manages that internally. 🔹 Key Features ✔ Maintains insertion order ✔ Allows duplicate elements ✔ Provides fast random access (index-based) ✔ Automatically resizes when needed 🔹 Why Not Use Arrays? Traditional arrays have limitations: ❌ Fixed size ❌ Manual resizing ❌ Less flexibility ArrayList solves all of these problems with built-in methods. 🔹 Common Methods ✔ add() → Insert elements ✔ get() → Access elements ✔ set() → Update elements ✔ remove() → Delete elements ✔ size() → Get total elements 🔹 Example import java.util.ArrayList; public class Demo { public static void main(String[] args) { ArrayList<String> list = new ArrayList<>(); list.add("Java"); list.add("Python"); list.add("Java"); // duplicate allowed System.out.println(list); // [Java, Python, Java] list.remove("Python"); System.out.println(list.get(0)); // Java } } 🔹 When to Use ArrayList? ✔ When you need frequent data access ✔ When order matters ✔ When duplicates are allowed ✔ When size is not fixed 🔹 Key Insight ArrayList is powerful, but not always the best choice. If your use case involves frequent insertions/deletions in the middle, other structures like LinkedList may perform better. 🔹 Realization Learning ArrayList made me realize something important — Java is not just about writing logic, it’s also about choosing the right structure to support that logic. #Java #CoreJava #ArrayList #CollectionsFramework #DataStructures #Programming #DeveloperJourney #100DaysOfCode #CodingJourney #Day49 Grateful for guidance from, Sharath R TAP Academy

🚀 I’ve just published my Java Day 3 article — and today’s learning was more about understanding how Java thinks than just writing code. When I started, I thought programming is only about printing output and running programs. But today I learned something different: 👉 Some words in Java are special (keywords) — you can’t just use them anywhere 👉 Some values should never change (constants using final) 👉 And sometimes data needs to change its type to make things work (type conversion) Honestly, at first these topics sounded boring and too “theory-like”. But once I tried them in code, I realized how important they are for writing clean and safe programs. Day by day, Java is feeling: ✔ Less scary ✔ More logical ✔ More interesting From “Hello World” to actually understanding how data works inside Java — this journey already feels worth it. #Java #LearningInPublic #BCA #BeginnerDeveloper #CodingJourney #LearnJava #StudentLife #Programming #Day3 #Java

🚀 Day 50/100 – #JavaJourney Continuing the journey with a mix of DSA practice and Core Java learning. Today’s focus was revisiting some important LeetCode problems and strengthening Java fundamentals. 🧠 DSA Practice (LeetCode) 1️⃣ LC 1 – Two Sum (Hash Map Complement Approach) 2️⃣ LC 26 – Remove Duplicates from Sorted Array (Two Pointer Approach) 3️⃣ LC 35 – Search Insert Position (Linear / Binary Search Approach) 4️⃣ LC 27 – Remove Element (Two Pointer Approach) 5️⃣ LC 283 – Move Zeroes (Two Pointer + Swap / Write Approach) 6️⃣ LC 66 – Plus One Also progressing with Prefix Sum concepts, practicing problems like Subarray Range Sum and Maximum Subarray to better understand array patterns. 📚 Core Java Concepts Studied 1️⃣ Enums & Annotations 2️⃣ Functional Interfaces & Lambda Expressions 3️⃣ Exception Handling & Custom Exceptions 4️⃣ User Input Handling (BufferedReader & Scanner) 5️⃣ Multithreading Concepts (Threads, Runnable, Race Condition, Thread States) 📈 Key Takeaways • Revisiting classic problems helps reinforce important DSA patterns • Learning concepts like lambdas and multithreading adds deeper understanding of Java • Consistency with both DSA practice and Java fundamentals is helping me build stronger foundations 💻 Check out my work: 🔗 GitHub: https://lnkd.in/gGquYtVZ 🔗 LeetCode: https://lnkd.in/gaNyep3M Day 50 completed ✅ Halfway through the journey and still learning every day 🚀 #Java #DSA #LeetCode #CoreJava #Multithreading #Lambda #100DaysOfCode #CodingJourney #Consistency #ProblemSolving

Day 12 of Java, Entering the World of OOP 🚀 Today felt like a major shift in my Java journey. Until now, I was learning how to write programs. But today I learned how software is actually structured. Welcome to Object Oriented Programming (OOP). Here’s the simple idea that clicked for me: 👉 Class = Blueprint 👉 Object = Real thing created from that blueprint Example: class Student { } Now when we write: Student s1 = new Student(); Java does two things: • The object is created in Heap memory • The reference variable is stored in Stack memory And the keyword that makes this happen? 🔥 new It tells Java to create a new object in memory. This is where programming starts feeling more like building systems instead of just writing lines of code. Big takeaway today: Classes define structure. Objects bring them to life. And this is just the beginning of OOP. Excited to go deeper into this world 🚀🔥 Special thanks to Aditya Tandon Sir & Rohit Negi Sir 🙌 #Java #CoreJava #OOP #Programming #LearningJourney #Developers #BuildInPublic

While learning more about constructors in Java, the idea of a default constructor also became clearer. A default constructor is automatically provided by Java when no constructor is written in a class. Things that became clear : • if a class does not define any constructor, Java automatically creates a default constructor • the default constructor has no parameters • it mainly helps create objects without requiring initialization values • instance variables get their default values if they are not explicitly initialized • once a constructor is written manually, Java no longer provides the default one automatically A simple example shows how it works : class Student { int rollNo; String name; } public class Test { public static void main(String[] args) { Student s = new Student(); System.out.println(s.rollNo); System.out.println(s.name); } } Here, even though no constructor is written, Java still allows object creation by providing a default constructor. Understanding this behaviour helps explain why objects can still be created even when constructors are not explicitly defined. #java #oop #programming #learning #dsajourney

🚀Constructor Chaining in Java: The Hidden Engine of Object Creation. Understanding how objects are truly constructed and how classes interact is essential for writing clean, efficient code. Here are my key takeaways from the Inheritance session at TAP Academy. Here is a breakdown of what makes this concept so essential for any Java developer: 🔹 Local vs. Inter-Class Chaining: Constructor chaining can be achieved in two ways: within the same class using the this() call (local chaining) or between different classes (parent and child) using the super() call. 🔹 The Invisible super() Call: Java has a powerful default behavior: if you don’t explicitly call a constructor, the compiler automatically inserts super() as the first line of your constructor. This ensures the parent class is always initialized before the child,. 🔹 The "First Line" Rule: Both this() and super() must be the very first statement in a constructor,. Because of this requirement, they are mutually exclusive—you cannot use both in the same constructor,. 🔹 The Ultimate Parent: Every chain eventually leads to the Object class, which is the ultimate superclass of every class in Java,. Interestingly, the Object class constructor is the end of the line and does not contain a super() call because it has no parent. #JavaDevelopment #ConstructorChaining #OOP #CodingSkills #JavaProgramming #TechLearning #SoftwareEngineering #Java #TapAcademy

Continuing my Java learning journey, I’ve recently explored some advanced core concepts that further strengthen object-oriented design and code flexibility. Here are the topics I covered: Object Class and its fundamental methods like toString(), equals(), and hashCode() Interfaces and how they enable abstraction and multiple inheritance in Java Functional Interfaces and their role in supporting lambda expressions and cleaner code Nested Classes and how they help in logically grouping classes and improving encapsulation These concepts helped me understand how Java provides powerful tools to write more modular, reusable, and maintainable code. Step by step, building a deeper understanding of Java and preparing to apply these concepts in real-world applications. #Java #OOP #Programming #LearningJourney #SoftwareDevelopment #CDAC

Over the past 10 days, I focused on strengthening my core Java programming concepts. 🚀 Here are some of the key topics I explored and practiced: • Functions & Objects – Understanding how functions work and how objects are created and used in Java. • Constructors – Learning how constructors initialize objects and help in object creation. • Four Pillars of OOP – Inheritance, Encapsulation, Polymorphism, and Abstraction, which form the foundation of Object-Oriented Programming. • Autoboxing & Unboxing – Converting primitive data types to wrapper classes and vice versa. • Nested Classes – Classes defined inside another class and their use cases. • Interfaces – Implementing abstraction and multiple inheritance in Java. • Abstract Classes & Methods – Designing partially implemented classes for better architecture. • Import Statements – Using Java packages and importing required classes. • Java Input – Taking user input using classes like Scanner. Every day I'm trying to learn something new and improve my problem-solving and programming skills. Looking forward to exploring more advanced Java concepts and building practical projects. 💻 #Java #Programming #LearningJourney #OOP #SoftwareDevelopment