Constructor Chaining in Java using super()

🚀 Learning Core Java – Difference Between super and super() Today I learned an important concept in Java — the difference between super and super(). Although they look similar, they serve different purposes in inheritance. ⸻ 🔹 super Keyword super is a reference variable used to refer to the parent class members. It is used to: ✔ Access parent class variables ✔ Call parent class methods ✔ Resolve ambiguity when child and parent have same names 👉 Example concept: super.variable super.method() ⸻ 🔹 super() Constructor Call super() is used to call the parent class constructor from the child class. It is mainly used for: ✔ Initializing parent class properties ✔ Ensuring proper constructor chaining 👉 Important Rule: super() must be the first statement inside the child class constructor 💡 Key Insight 👉 super → Used for accessing parent class data and behavior 👉 super() → Used for initializing parent class during object creation Understanding this difference is essential for writing clean and structured inheritance-based code in Java. Excited to keep strengthening my OOP fundamentals! 🚀 #CoreJava #SuperKeyword #ConstructorChaining #ObjectOrientedProgramming #JavaDeveloper #ProgrammingFundamentals #LearningJourney #SoftwareEngineering

🚀 Day 27 and 28 of Learning Java @ Tap Academy 📘 Constructor Chaining & POJO in Java Today, I explored Constructor Chaining and also learned about POJO (Plain Old Java Object) concepts. 🔹 What is Constructor Chaining? Constructor chaining is a process where one constructor calls another constructor in the same class using this(). ✔️ Helps in code reusability ✔️ Must be the first statement inside the constructor 🔹 POJO (Plain Old Java Object): A POJO class is a simple Java class that contains: ✔️ Private fields ✔️ Zero-argument constructor (default constructor) ✔️ Parameterized constructor ✔️ Getter and Setter methods 🔹 Example of POJO Class: class Student { private int id; private String name; // Zero-parameter constructor Student() {} // Parameterized constructor Student(int id, String name) { this.id = id; this.name = name; } // Getter public int getId() { return id; } public String getName() { return name; } // Setter public void setId(int id) { this.id = id; } public void setName(String name) { this.name = name; } } 🔹 Wrapper Classes in Java: ✔️ Primitive data types (int, float, etc.) are not objects ✔️ Wrapper classes (Integer, Float, etc.) convert primitives into objects ✔️ Helps Java achieve better object-oriented programming concepts 🔹 Performance Note: ✔️ Java is slightly slower compared to C and C++ ✔️ Because Java uses JVM and abstraction features ✔️ C & C++ are faster due to low-level memory access 💡 Key Takeaway: Understanding POJO, constructor chaining, and wrapper classes helps build strong foundations in Java and object-oriented programming. #TapAcademy #Java #LearningJava #CodingJourney #JavaBasics #OOPS #POJO #ConstructorChaining

🚀 Learning Progress: Java OOP – Encapsulation & POJO Continuing my journey in mastering Object-Oriented Programming in Java, I worked on a program to demonstrate Encapsulation along with the use of a POJO (Plain Old Java Object) class. In this program: I created a POJO class with private variables to represent the data Used getter and setter methods to control access and modification of that data Ensured proper data hiding, which is the core idea of Encapsulation This hands-on implementation helped me understand how POJO classes are used in real-world applications to create clean, reusable, and maintainable code structures while keeping data secure. It was a great exercise in writing structured and professional Java code, and I’m excited to explore more OOP concepts and apply them in practical scenarios. #Java #OOP #Encapsulation #POJO #LearningJourney #SoftwareDevelopment#Tap Academy

Day 41 of Learning Java: Method Overriding If method overloading was about flexibility,method overriding is about customization. What is Method Overriding? It’s when a subclass provides its own implementation of a method that is already defined in the parent class. Same method name. Same parameters. But different behavior. 🔹 Simple example- class Parent { void watchTV() { System.out.println("Watching News/Serial"); } } class Child extends Parent { @Override void watchTV() { System.out.println("Watching Music/Sports"); } } Same method → different output depending on the object. • Parent defines a general behavior • Child modifies it based on its own need • This helps in writing more flexible and reusable code 🔹 Key points to remember • Method signature must be the same • Happens during runtime (runtime polymorphism) • Inheritance is required 👉 You cannot override: static methods private methods final methods 🔹 One important concept Parent ref = new Child(); ref.watchTV(); Even though the reference is of Parent, the method of Child gets executed. 👉 This is called dynamic method dispatch 🔹 About @Override It’s not mandatory, but it helps: ✔ Avoid mistakes ✔ Makes code more readable ✔ Ensures you’re actually overriding #Java #OOP #MethodOverriding #LearningInPublic #Programming#sql #branding

🚀 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 🚀

🚀 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

📘 Day 2 of Java Learning Series 🔹 Understanding OOP Concepts in Java Java is based on Object-Oriented Programming (OOP), which helps in writing clean, reusable, and scalable code. 🔑 4 Main OOP Concepts: 1️⃣ Encapsulation 👉 Wrapping data (variables) and code (methods) into a single unit 👉 Achieved using classes 👉 Helps in data hiding 💡 Example: class Student { private String name; public void setName(String name) { this.name = name; } public String getName() { return name; } } 2️⃣ Inheritance 👉 One class can inherit properties of another class 👉 Promotes code reuse 💡 Example: class Animal { void sound() { System.out.println("Animal makes sound"); } } class Dog extends Animal { void bark() { System.out.println("Dog barks"); } } 3️⃣ Polymorphism 👉 One action, many forms 👉 Method overloading & overriding 4️⃣ Abstraction 👉 Hiding implementation details and showing only functionality 👉 Achieved using abstract classes & interfaces 🚀 Mastering OOP is the foundation of becoming a strong Java developer! 👉 Follow for more Java concepts #Java #OOP #Programming #Developers #Learning #100DaysOfCode

JAVA FULL STACK DEVELOPMENT Day 25 – Day 27 | Tap Academy 🔹 Day 25: Method Overloading & Polymorphism ✔️ Concept of Method Overloading ✔️ Same method name with: Different number of parameters Different data types ✔️ Compile-time Polymorphism ✔️ Type Promotion (Implicit Conversion) ✔️ Real-time examples using Java methods 👉 Key Learning: Flexibility in methods and improving code readability 🔹 Day 26: OOPS Concepts ✔️ Introduction to Object-Oriented Programming System ✔️ Core Pillars: 🔸 Class & Object 🔸 Encapsulation 🔸 Inheritance 🔸 Polymorphism 🔸 Abstraction ✔️ Real-world analogy for better understanding 👉 Key Learning: Writing structured, reusable, and scalable code 🔹 Day 27: Constructors & Memory Management ✔️ Understanding Constructors ✔️ Types: Default Constructor Parameterized Constructor ✔️ Use of this keyword ✔️ Stack vs Heap memory concept ✔️ Object creation and reference handling 👉 Key Learning: How Java manages memory and initializes objects ⚡ Difference Between this Keyword and this() Method Feature this Keyword this() Method Meaning Refers to current object Calls another constructor Usage Access variables, methods of same class Constructor chaining Place Anywhere inside class methods/constructors Must be first line in constructor Purpose Remove ambiguity (same variable names) Reuse constructor code Example this.name = name; this(101, "Alex"); 💡 Example class Demo { int id; String name; Demo() { this(101, "Alex"); // this() method } Demo(int id, String name) { this.id = id; // this keyword this.name = name; } } 🚀 Conclusion Strengthened understanding of OOPS concepts Learned method overloading & polymorphism Mastered constructors and memory handling Gained clarity on this keyword vs this() method #Java #FullStackDevelopment #TapAcademy #OOPS #JavaLearning #Programming #Developers

🚀 Learning Core Java – Understanding Method Overriding Today I explored an important concept in Java — Method Overriding. Method overriding occurs when a child class provides its own implementation of a method that is already defined in the parent class. It is mainly used to achieve runtime polymorphism, which is also known as: 👉 Late Binding 👉 Dynamic Binding 👉 True Polymorphism 🔹 Rules for Method Overriding To correctly override a method in Java, we must follow these rules: ✔ Method Name & Parameters The method name and parameters must be exactly the same as in the parent class. ✔ Access Modifiers The access level of the overridden method should be: 👉 Same or more accessible (increased visibility) Example: protected → public ✅ public → protected ❌ ✔ Return Type Before JDK 5 → Return type must be exactly the same After JDK 5 → Can be same or covariant return type ✔ Parameters Parameters must remain unchanged (same type, number, and order) 🔎 What is Covariant Return Type? It means the overridden method can return a subclass type instead of the parent type, providing more flexibility. 💡 Key Insight Method overriding enables: ✔ Runtime polymorphism (dynamic behavior) ✔ Flexible and extensible design ✔ Cleaner and maintainable code Understanding overriding is essential for building scalable and robust object-oriented applications. Excited to keep strengthening my Java fundamentals! 🚀 #CoreJava #MethodOverriding #Polymorphism #RuntimePolymorphism #JavaDeveloper #ProgrammingFundamentals #LearningJourney #SoftwareEngineering

I’m learning Java — and this week was all about OOP (Object-Oriented Programming) 🚀 Honestly, this is where Java starts to feel powerful. Here’s what clicked for me 👇 🔹 Encapsulation → Control your data, not just hide it Using private fields + public methods isn’t just for security It lets you: ✔ Validate inputs ✔ Prevent invalid states ✔ Change logic without breaking other code Example: A BankAccount should never allow a negative balance — encapsulation enforces that. 🔹 Inheritance → Real-world relationships in code extends lets one class reuse another But more importantly: 👉 It creates a hierarchy (like Employee → Manager) 👉 Helps avoid duplication 👉 Makes systems easier to scale Also learned: Java doesn’t support multiple inheritance (for classes) 🔹 Polymorphism → Same method, different behavior Two types: ✔ Compile-time (Overloading) → same method name, different parameters ✔ Runtime (Overriding) → method decided at runtime This is what enables: 👉 Flexible systems 👉 Clean APIs 👉 “Write generic, behave specific” 🔹 Abstraction → Hide complexity, expose essentials This is where things get interesting 👀 👉 Abstract Class • Can have both abstract + concrete methods • Used when classes are related 👉 Interface • Defines a contract • Supports multiple inheritance • Used for capabilities 💡 Big realization: OOP isn’t about syntax. It’s about how you design systems. I’ve explained all of this with clear code examples in my slides (made it super simple to revise) 🤔 Curious question for you: When do you prefer using an abstract class over an interface in real projects? Would love to hear real-world perspectives 👇 #Java #OOP #JavaDeveloper #LearningInPublic #SoftwareDevelopment #CodingJourney