Java Myth Busted: Main Not Starting Point

🚀 Understanding Default, Static, and Private Methods in Java Interfaces As part of my learning journey at Tap Academy, I recently explored some powerful features introduced in Java interfaces starting from JDK 8 and JDK 9. These features allow interfaces to contain concrete methods, making them more flexible and powerful. Here’s a quick summary of what I learned: 🔹 Default Methods (JDK 8) The default keyword allows us to define concrete methods inside an interface. Example: public default void methodName() { // implementation } Key points: Default methods participate in inheritance. They can be overridden in the implementing (child) class. In the child class, we should NOT use the default keyword while overriding. Introduced mainly for backward compatibility, allowing new methods to be added to interfaces without breaking existing implementations. 🔹 Static Methods (JDK 8) Interfaces can also have static methods. Example: public static void methodName() { // implementation } Key points: Accessed using InterfaceName.methodName() Can be used without creating objects or implementing the interface Useful for utility/helper methods related to the interface Static methods cannot be overridden 🔹 Private Methods (JDK 9) Private methods were introduced to avoid code duplication inside interfaces. Example: private void methodName() { // implementation } Key points: Accessible only within the interface. Used to support default methods. Static methods cannot access non-static private methods. To solve this, we can create a private static method: private static void methodName() { // implementation } 🔹 Summary Interfaces can contain concrete methods using default, static, and private. default and static methods were introduced in JDK 8. private and private static methods were introduced in JDK 9. Grateful to Tap Academy for helping me understand these important Java concepts and strengthening my core Java knowledge. Looking forward to applying these concepts in real-world projects! #Java #CoreJava #JavaLearning #Programming #SoftwareDevelopment #JavaDeveloper #TapAcademy #LearningJourney TAP Academy

🚀 Understanding the Internal Execution Flow in Java. Ever wondered what really happens under the hood when you run a Java program? It is much more than just the main method!. In my latest learning session at TAP Academy with Sharath R sir, I learned about the seven essential elements of a Java class: static variables, static blocks, static methods, instance variables, instance blocks, instance methods, and constructors. Here are the key takeaways: 🔹 Static vs. Instance: A fundamental rule is that static members belong to the class, while instance members belong to the object. 🔹 The Class Loader: When the JVM needs a class, it calls its "closest friend," the Class Loader, to locate and load the class into the code segment. 🔹 Order of Execution: Java execution follows a strict sequence. It starts with static variables and static blocks during class loading, long before the main method or any object creation occurs. 🔹 The "Illegal" Access Rule: You cannot access instance variables from a static block or method. Why? Because static members are initialized during class loading, at which point the object (and its instance variables) does not even exist yet. Understanding the internal memory flow—from the static segment to the heap and stack—is the first step toward mastering Java's object-oriented pillars. #Java #Programming #SoftwareDevelopment #oops #ObjectOrientedProgramming #TechLearning #Tap Academy

Day 11 – Understanding Constructor Chaining & Initialization Flow in Java ☕💻 Today’s Java learning session focused on deepening my understanding of how constructors work across classes and how Java initializes objects during creation. Key concepts explored: • Constructor chaining using this() – calling one constructor from another constructor within the same class • Constructor chaining using super() – invoking a parent class constructor from a child class • Multi-level inheritance constructor flow (Parent → Child → Subclass) • Understanding why constructors are not inherited but are still executed during object creation • Using the super keyword to access parent variables, methods, and constructors • Difference between this() vs super() and when each should be used One key takeaway today was understanding the complete constructor execution flow when objects are created in an inheritance hierarchy. Even though the child object is created, Java ensures that parent constructors execute first to properly initialize inherited state. Breaking down these examples step-by-step made it much clearer how Java manages object initialization and constructor chaining internally. Looking forward to continuing tomorrow and exploring Java’s order of execution (static blocks, instance blocks, and constructors) to strengthen my understanding of object lifecycle in Java. #Java #LearningJourney #JavaDeveloper #Programming #SoftwareDevelopment #100DaysOfCode

🚀 Day 33 at Tap Academy – Java Journey Continues! 📘 Java Inheritance – Part 3: Super Keyword, Method Types & Overriding Today’s session was a deep dive into one of the most important pillars of Java — Inheritance, focusing on how real-world applications handle method behavior and class relationships. 🔑 Key Concepts Covered: ✅ super Keyword Learned how to access parent class variables and methods, especially in cases of variable shadowing. ✅ this() vs super() Constructor Calls Understood why both cannot coexist in the same constructor and how constructor chaining works internally. ✅ Method Types in Inheritance 🔹 Inherited Methods – Used as-is from parent 🔹 Overridden Methods – Same signature, different behavior 🔹 Specialized Methods – Defined only in child class ✅ Method Overriding Rules Strict rules around method signature, return type, and access modifiers — a must-know for interviews. ✅ @Override Annotation A small but powerful feature that ensures correctness and prevents silent bugs during overriding. 🛩️ Hands-On Learning: Plane Hierarchy Example Implemented a real-world scenario using: CargoPlane PassengerPlane FighterPlane This helped clearly visualize: 👉 How inheritance works 👉 How overriding changes behavior 👉 How specialized methods add new functionality 🎯 Interview Insights from a Placed Student (4.2 LPA Role) Key takeaway: “Learning alone is not enough — applying, practicing, and facing interviews is what makes the difference.” Focused areas: ✔ OOP concepts (Overloading vs Overriding) ✔ SQL (Joins, Keys) ✔ System design basics ✔ Communication skills #Java #OOP #Inheritance #MethodOverriding #CodingJourney #FullStackDeveloper #LearningInPublic #TapAcademy #JavaDeveloper #SoftwareEngineering 🚀

🚀 Day 29–33 of My Java Full Stack Development Journey In these days, I explored one of the most important concepts in Java — the Anatomy of a Java Class and its Execution Flow. I learned how Java programs are structured into Static (Class-Level) and Instance (Object-Level) components. 🔹 Static (Class-Level) Static variables and blocks belong to the class, not objects Loaded once during class loading Static methods (like main) cannot directly access instance variables 🔹 Instance (Object-Level) Instance variables and methods belong to individual objects Created when an object is instantiated Follow proper POJO standards (private variables + getters/setters) 💡 One of the key takeaways was understanding the Lifecycle of Execution in Java: 1️⃣ Class Loading Phase JVM loads the class Static variables are initialized Static blocks are executed 2️⃣ Object Creation Phase Memory is allocated for instance variables Instance blocks are executed 3️⃣ Constructor Execution Phase Constructor runs last Finalizes object initialization This helped me clearly understand how Java executes step by step internally, which is very important for writing optimized and bug-free code. Grateful to Tap Academy for helping me build strong fundamentals step by step 🙌 #Day29 #Day30 #Day31 #Day32 #Day33 #Java #OOP #Programming #FullStackDevelopment #JavaDeveloper #LearningJourney #CodingJourney #TapAcademy

🚀 Understanding the Difference Between Array and ArrayList in Java As part of my learning journey with TAP Academy, I explored one of the most fundamental yet important topics in Java — the difference between Array and ArrayList. Here’s a quick comparison that helped me understand when to use what 👇 🔹 1. Size 📌 Array → Fixed size 📌 ArrayList → Dynamic (Resizable) 🔹 2. Data Type 📌 Array → Stores homogeneous data 📌 ArrayList → Can store heterogeneous data (as Objects) 🔹 3. Storage 📌 Array → Stores primitive data types & objects 📌 ArrayList → Stores only objects 🔹 4. Length vs Size 📌 Array → Uses length keyword 📌 ArrayList → Uses size() method 🔹 5. Import Requirement 📌 Array → No import required 📌 ArrayList → Requires import java.util.*; 🔹 6. Utility Classes 📌 Array → Uses Arrays utility class 📌 ArrayList → Uses Collections utility class 🔹 7. Methods Availability 📌 Array → Limited methods 📌 ArrayList → Rich set of built-in methods 🔹 8. Multidimensional Support 📌 Array → Supports multidimensional arrays 📌 ArrayList → No direct support for multidimensional structure 💡 Key Takeaway: Arrays are simple and efficient for fixed-size data, while ArrayList provides flexibility and powerful methods for dynamic data handling. Choosing the right one depends on the problem requirement. Grateful to TAP Academy for helping me build strong fundamentals step by step 🙌 #Java #ArrayVsArrayList #CollectionsFramework #Programming #LearningJourney #TAPAcademy #KeepGrowing TAP Academy

🚀 What I Learned This Week — Java OOP Deep Dive at TAP Academy! Huge shoutout to our mentor Sir kshitij kenganavar for making these concepts crystal clear. Here's what we covered: 🔷 Abstraction — Abstract classes cannot be instantiated directly — Pure Abstraction = only abstract methods — Impure Abstraction = abstract + concrete methods — Constructor in abstract class runs only via child class — abstract + final can NEVER coexist in Java 🔷 Interfaces — All methods are public abstract by default — Variables are always public static final — A class implements; an interface extends another interface — Java 8 introduced default & static methods — Java 9 introduced private methods for security & reusability 🔷 Functional Interface (Java 8) — Has exactly ONE abstract method (SAM — Single Abstract Method) — Annotated with @FunctionalInterface — Built-ins: Runnable, Predicate, Comparator, Consumer 🔷 Lambda Expressions (Java 8) — Clean replacement for Anonymous Inner Classes — Works only with Functional Interfaces — Syntax: (params) -> { body } 🔷 Polymorphism via Interface — Achieves loose coupling through interface reference — Supports multiple inheritance (not possible with classes alone) — Marker Interface = empty interface for special properties (e.g., Serializable) Every concept we learn today becomes the foundation for what we build tomorrow. 💡 Thank you Sir kshitij kenganavar and TAP Academy for making Java OOP so approachable! 🙏 #Java #OOP #LambdaExpressions #FunctionalInterface #Abstraction #Interface #TAPAcademy #LearningJava #SoftwareDevelopment #Java8 #Infosys

⚠️ Why Java Avoids Multiple Inheritance – Understanding the Diamond Problem Have you ever questioned why Java doesn’t allow multiple inheritance through classes? Let’s break it down simply 👇 🔷 Consider a scenario: A child class tries to inherit from two parent classes, and both parents share a common base (Object class). Now the problem begins… 🚨 👉 Both parent classes may have the same method 👉 The child class receives two identical implementations 👉 The compiler has no clear choice This creates what we call the Diamond Problem 💎 🤯 What’s the Issue? When two parent classes define the same method: Which one should the child use? Parent A’s version or Parent B’s? This confusion leads to ambiguity, and Java simply doesn’t allow that ❌ 🔍 Important Points: ✔ Every class in Java is indirectly connected to the Object class ✔ Multiple inheritance can cause method conflicts ✔ Duplicate methods = compilation errors ✔ Java strictly avoids uncertain behavior 💡 Java’s Smart Approach: Instead of allowing multiple inheritance with classes, Java provides: 👉 Interfaces to achieve multiple inheritance safely 👉 Method overriding to resolve conflicts clearly 🚀 Final Thought: Java’s design ensures that code remains predictable, clean, and maintainable — even if it means restricting certain features like multiple inheritance. #TapAcademy #Java #OOP #Programming #SoftwareDevelopment #Coding #JavaDeveloper #TechConcepts #LearningJourney

DAY 30: CORE JAVA 🚀 Understanding "this()" vs "super()" in Java – A Quick Guide! While working with constructors in Java, two important calls often come into play: "this()" and "super()". Though they may seem similar, they serve very different purposes. 🔹 "this()" Call - Used to achieve constructor chaining within the same class. - Helps reuse constructors in a clean and efficient way. - It is optional and depends on the programmer’s need. 🔹 "super()" Call - Used to achieve constructor chaining between parent and child classes. - It is automatically invoked by Java (default behavior). - Always placed on the first line of the child class constructor. ⚠️ Important Rule 👉 "this()" and "super()" cannot be used together in the same constructor, as both must be the first statement. 💡 Key Insight Subclass variables always have higher priority than superclass variables. To access parent class variables when both have the same name, we use "super". 📌 Mastering these concepts is essential for writing clean and efficient code using inheritance in Java. TAP Academy #Java #OOP #Programming #CodingTips #SoftwareDevelopment

🚀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