Java Constructor Chaining with this() and super()

🚀 Learning Core Java – Understanding Inheritance Today I explored another important pillar of Object-Oriented Programming — Inheritance. Inheritance is the concept where one class acquires the properties (variables) and behaviors (methods) of another class. It is achieved using the extends keyword in Java. This helps in code reusability, reduces duplication, and builds a relationship between classes. ⸻ 🔹 Types of Inheritance in Java Java supports several types of inheritance: ✔ Single Inheritance One class inherits from one parent class. ✔ Multilevel Inheritance A chain of inheritance (Grandparent → Parent → Child). ✔ Hierarchical Inheritance Multiple classes inherit from a single parent class. ✔ Hybrid Inheritance A combination of multiple types. ⸻ 🔎 Important Concept 👉 In Java, every class has a parent class by default, which is the Object class. Even if we don’t explicitly extend any class, Java automatically extends: java.lang.Object This means: • Every class in Java inherits methods like toString(), equals(), hashCode(), etc. • The Object class is the root of the class hierarchy. ⸻ 🚫 Not Supported in Java (via classes) ❌ Multiple Inheritance One class inheriting from multiple parent classes is not supported in Java (to avoid ambiguity). 👉 However, it can be achieved using interfaces. ❌ Cyclic Inheritance A class inheriting from itself (directly or indirectly) is not allowed. ⸻ 💡 Key Insight Inheritance promotes: ✔ Code reuse ✔ Better organization ✔ Logical relationships between classes And remember: 👉 All classes in Java ultimately inherit from the Object class. ⸻ Understanding inheritance is essential for building scalable and maintainable Java applications. Excited to keep strengthening my OOP fundamentals! 🚀 #CoreJava #Inheritance #ObjectOrientedProgramming #JavaDeveloper #ProgrammingFundamentals #LearningJourney #SoftwareEngineering #TechLearning

DAY 29: CORE JAVA 🔗 Constructor Chaining in Java using "super()" (Inheritance) While learning Java OOP concepts, one interesting topic I explored is Constructor Chaining in Inheritance. 📌 What is Constructor Chaining? Constructor chaining is the process of calling one constructor from another constructor. In inheritance, a child class constructor calls the parent class constructor using "super()". This ensures that the parent class variables are initialized before the child class variables. ⚙️ Key Points to Remember • "super()" is used to call the parent class constructor. • It must be the first statement inside the child constructor. • If we don’t explicitly write "super()", Java automatically calls the parent class default constructor. • This mechanism ensures proper initialization of objects in inheritance hierarchy. 💡 Example Scenario Parent Class: class Test1 { int x = 100; int y = 200; } Child Class: class Test2 extends Test1 { int a = 300; int b = 400; } When an object of "Test2" is created, Java first calls the parent constructor, initializes "x" and "y", and then initializes "a" and "b". 📊 Execution Flow 1️⃣ Object of child class is created 2️⃣ Child constructor calls "super()" 3️⃣ Parent constructor executes first 4️⃣ Control returns to child constructor This concept is very important for understanding object initialization, inheritance hierarchy, and memory allocation in Java. 🚀 Learning these small internal mechanisms of Java helps build a strong foundation in Object-Oriented Programming. TAP Academy #Java #OOP #ConstructorChaining #Inheritance #JavaProgramming #SoftwareDevelopment #CodingJourney

Extends vs Implements in Java — Stop Confusing Them Many beginners mix these two concepts up. A clear understanding is essential for a solid OOP foundation. 🔹 extends (Inheritance) - Used when one class inherits another class. - Reuse code from the parent class. - Not mandatory to override methods. - Can extend only one class (no multiple inheritance). Example: class Animal { void sound() { System.out.println("Animal makes sound"); } } class Dog extends Animal { void bark() { System.out.println("Dog barks"); } } 🔹 implements (Interface) - Used when a class implements an interface. - Must implement all methods. - Supports multiple interfaces. - Used for abstraction. Example: interface Animal { void sound(); } class Dog implements Animal { public void sound() { System.out.println("Dog barks"); } } ⚔️ Key Differences - extends → class inherits class - implements → class follows the contract of an interface - extends → optional method override - implements → mandatory implementation - extends → single inheritance - implements → multiple interfaces allowed 💡 Reality Check: If you’re still memorizing this instead of understanding why interfaces exist, you’re learning Java incorrectly. Interfaces are design contracts, while inheritance is about code reuse. 🔥 Level up tip: Don’t just read — build a small project using both. Otherwise, this will remain theory. #Java #OOP #Programming #Developers #Coding #JavaDeveloper

🚀 Day 27 | Core Java Learning Journey 📌 Topic: Vector & Stack in Java Today, I learned about Vector and Stack, two important Legacy Classes in Java that are part of the early Java library and later became compatible with the Java Collections Framework. 🔹 Vector in Java ✔ Vector is a legacy class that implements the List interface ✔ Data structure: Growable (Resizable) Array ✔ Maintains insertion order ✔ Allows duplicate elements ✔ Allows multiple null values (not "NILL" ❌ → correct term is null ✔) ✔ Can store heterogeneous objects (different data types using Object) ✔ Synchronized by default (thread-safe, but slower than ArrayList) 📌 Important Methods of Vector • add() – add element • get() – access element • remove() – delete element • size() – number of elements • capacity() – current capacity of vector 💡 Note: Due to synchronization overhead, ArrayList is preferred in modern Java. 🔹 Stack in Java ✔ Stack is a subclass (child class) of Vector ✔ It is also a Legacy Class ✔ Data structure: LIFO (Last In, First Out) 📌 Core Methods of Stack • push() – add element to top • pop() – remove top element • peek() – view top element without removing 📌 Additional Useful Methods • isEmpty() – check if stack is empty • search() – find element position 💡 Note: In modern Java, Deque (ArrayDeque) is preferred over Stack for better performance. 📌 Key Difference: Vector vs Stack ✔ Vector → General-purpose dynamic array ✔ Stack → Specialized for LIFO operations 💡 Understanding these legacy classes helps in learning how Java data structures evolved and why modern alternatives are preferred today. Special thanks to Vaibhav Barde Sir for the guidance! #CoreJava #JavaLearning #JavaDeveloper #Vector #Stack #JavaCollections #Programming #LearningJourney

🚀 Understanding Key Java Differences: throw vs throws & final, finally, finalize Java has several keywords that sound similar but serve completely different purposes. Understanding these differences is essential for writing clean and efficient code. Let’s break them down 👇 🔹 throw vs throws 👉 throw Used to explicitly throw an exception Used inside a method or block Throws a single exception at a time throw new ArithmeticException("Error occurred"); 👉 throws Used in method signature Declares exceptions that a method might throw Can declare multiple exceptions void readFile() throws IOException, SQLException { // code } 💡 Key Difference: throw is used to actually throw an exception, while throws is used to declare exceptions. 🔹 final vs finally vs finalize 👉 final Keyword used with variables, methods, and classes Variable → value cannot be changed Method → cannot be overridden Class → cannot be inherited final int x = 10; 👉 finally Block used with try-catch Always executes (whether exception occurs or not) Used for cleanup activities try { int a = 10 / 0; } finally { System.out.println("Cleanup done"); } 👉 finalize Method called by Garbage Collector before object destruction Used for cleanup (rarely used in modern Java) protected void finalize() throws Throwable { System.out.println("Object is destroyed"); } 💡 Key Difference: final → restriction keyword finally → execution block finalize → method for cleanup before garbage collection ✨ Takeaway: Small keywords can make a big difference in Java. Mastering these improves your code quality and helps you handle exceptions and memory more effectively. Keep learning, keep coding, and keep growing 💻🚀 #Java #ExceptionHandling #ProgrammingConcepts #Developers #CodingJourney #KeepLearning #OOP TAP Academy

🚀 Exploring Built-in Methods of ArrayList in Java As part of my continuous learning in Java, I explored the powerful built-in methods of ArrayList that make data handling efficient and flexible. Understanding these methods is essential for writing clean and optimized code. Here’s a quick overview of some commonly used ArrayList methods 👇 🔹 1. add() Adds an element to the list list.add("Java"); 🔹 2. add(index, value) Inserts an element at a specific position list.add(1, "Python"); 🔹 3. addAll() Adds all elements from another collection list.addAll(otherList); 🔹 4. retainAll() Keeps only common elements between two collections list.retainAll(otherList); 🔹 5. removeAll() Removes all elements present in another collection list.removeAll(otherList); 🔹 6. set() Replaces an element at a specific index list.set(0, "C++"); 🔹 7. get() Retrieves an element by index list.get(0); 🔹 8. size() Returns the number of elements list.size(); 🔹 9. trimToSize() Trims capacity to match current size list.trimToSize(); 🔹 10. isEmpty() Checks if the list is empty list.isEmpty(); 🔹 11. contains() Checks if an element exists list.contains("Java"); 🔹 12. indexOf() Returns the first occurrence index list.indexOf("Java"); 🔹 13. lastIndexOf() Returns the last occurrence index list.lastIndexOf("Java"); 🔹 14. clear() Removes all elements from the list list.clear(); 🔹 15. subList(start, end) Returns a portion of the list list.subList(1, 3); 💡 Key Takeaway: Mastering these built-in methods helps in efficiently managing collections and solving real-world problems with ease. Consistency in practicing such concepts builds a strong foundation in Java development 💻✨ #Java #ArrayList #CollectionsFramework #Programming #Developers #LearningJourney #CodingSkills #KeepGrowing TAP Academy

While learning Java, I realized something important: 👉 Writing code is easy 👉 Handling failures correctly is what makes you a good developer So here’s my structured understanding of Exception Handling in Java 👇Java Exception Handling — the part most tutorials rush through. If you're writing Java and your only strategy is wrapping everything in a try-catch(Exception e) and hoping for the best, this is for you. A few things worth understanding properly: 1. Checked vs Unchecked isn't just trivia Checked exceptions (IOException, SQLException) are compile-time enforced — the language is telling you these failure modes are expected and you must plan for them. Unchecked exceptions (RuntimeException and its subclasses) signal programming bugs — they shouldn't be caught and hidden, they should be fixed. 2. finally is a contract, not a suggestion That block runs regardless of what happens. Use it for resource cleanup. Better yet, use try-with-resources in modern Java — it handles it automatically. 3. Rethrowing vs Ducking "Ducking" means declaring throws on a method and letting the caller deal with it. Rethrowing means catching it, maybe wrapping it with more context, and throwing again. Know when each makes sense. 4. Custom exceptions add clarity A PaymentDeclinedException tells the next developer (and your logs) far more than a generic RuntimeException with a message string. The image attached gives a clean visual overview — bookmarking it might save you a Google search or two. TAP Academy kshitij kenganavar What's your go-to rule for exception handling in production systems? #Java #SoftwareDevelopment #CleanCode #JavaDeveloper #BackendEngineering #TechEducation #100DaysOfCode

💡 Java Concept: Exception Handling in Method Overriding 🚀 While learning Java, I discovered an important rule that many beginners miss 👇 👉 How exceptions behave when a child class overrides a parent method 🔹 Simple Definition When a subclass overrides a method, it cannot throw broader or new checked exceptions than the superclass. 🧠 Golden Rule 👉 Child class can: ✔ Throw same exception ✔ Throw smaller (child) exception ✔ Throw unchecked exception ✔ Throw no exception 👉 Child class cannot: ❌ Throw new checked exception (not in parent) 🔴 Example (Wrong ❌) class Parent { void show() { } } class Child extends Parent { void show() throws IOException { // ❌ Compile Error System.out.println("Child"); } } 👉 Reason: Parent didn’t declare any exception 🟢 Example (Correct ✅) class Parent { void show() throws Exception { System.out.println("Parent"); } } class Child extends Parent { void show() throws ArithmeticException { System.out.println("Child"); } } 👉 Allowed because: ✔ ArithmeticException is unchecked ✔ OR smaller than parent exception 💡 Why this rule exists? To maintain runtime safety and avoid unexpected errors Parent p = new Child(); p.show(); 👉 Compiler only knows Parent → so child cannot introduce new checked exceptions 🔥 Easy Trick to Remember 👉 "Child can reduce risk, but not increase it" 📌 Small concept, but very important for interviews & real-world coding! #Java #OOP #ExceptionHandling #Programming #Developers #Coding #SoftwareEngineering #LearningJourney

🚀 Understanding Strings in Java – A Fundamental Concept for Every Developer While learning Java, one of the most important topics to understand is Strings and how Java manages them in memory. 🔹 A String is a sequence of characters enclosed in double quotes, like "JAVA". 🔹 In Java, Strings are treated as objects and stored in the heap memory. 📌 Key Concepts I Learned: ✅ Immutable vs Mutable Strings Immutable: Cannot be changed after creation (e.g., names, date of birth). Mutable: Values that may change, like passwords or email IDs. ✅ String Pool & Memory Allocation Constant Pool → Created without new keyword (String s = "JAVA";) Non-Constant Pool → Created using new keyword (new String("JAVA")) Duplicate literals share the same memory reference in the pool. ✅ String Comparison Methods in Java == → Compares memory reference equals() → Compares actual string value compareTo() → Compares character by character equalsIgnoreCase() → Compares values ignoring case 💡 Example Insight: Two "JAVA" literals may refer to the same memory location, but new String("JAVA") always creates a new object. Understanding these fundamentals helps write efficient and optimized Java programs. 📚 Currently exploring more core Java concepts and strengthening my programming foundation in TAP Academy . #Java #Programming #JavaDeveloper #Coding #SoftwareDevelopment #LearningJava #CoreJava #Developers

💡 Mastering Exception Handling in Java: Try & Catch Explained While writing robust applications, handling unexpected errors gracefully is just as important as writing the main logic. That’s where try-catch blocks come into play in Java. 🔹 Why use try-catch? It helps prevent your program from crashing and allows you to handle runtime errors effectively, ensuring a smooth user experience. 🔸 1. Basic Try-Catch Block A simple try-catch block is used to handle a single exception. public class Example { public static void main(String[] args) { try { int result = 10 / 0; // ArithmeticException } catch (ArithmeticException e) { System.out.println("Cannot divide by zero!"); } } } 👉 Here, the try block contains code that may throw an exception, and the catch block handles it. 🔸 2. One Try Block with Multiple Catch Blocks Java allows multiple catch blocks to handle different types of exceptions separately. public class MultipleCatchExample { public static void main(String[] args) { try { int[] arr = new int[5]; arr[10] = 50; // ArrayIndexOutOfBoundsException int result = 10 / 0; // ArithmeticException } catch (ArithmeticException e) { System.out.println("Arithmetic Exception occurred"); } catch (ArrayIndexOutOfBoundsException e) { System.out.println("Array Index is out of bounds"); } catch (Exception e) { System.out.println("Some other exception occurred"); } } } 👉 Multiple catch blocks allow you to handle each exception type differently, making your code more precise and readable. ✨ Key Takeaways: ✔ Always handle specific exceptions before general ones ✔ Improves program stability and debugging ✔ Essential for writing production-level Java code 🚀 Keep learning, keep building, and make your code resilient! #Java #ExceptionHandling #Programming #Coding #Developers #Learning #JavaDeveloper TAP Academy