Java Inheritance Types: Single, Multilevel, Hierarchical, and More

📘 Java Learning – Multithreading (Part 1: Multitasking & Thread Creation) 🚀🎯 Starting my learning journey into Java Multithreading, one of the most powerful features of Java used for executing multiple tasks simultaneously. 🔰 Multitasking Executing several tasks simultaneously is called Multitasking. There are two types of multitasking: 👉 Process Based Multitasking 👉 Thread Based Multitasking 1️⃣ Process Based Multitasking Executing several tasks simultaneously where each task is a separate independent process. Example: Running multiple applications at the same time: • Browser • Music Player • Code Editor ✔ Best suited at Operating System level 2️⃣ Thread Based Multitasking (Multithreading) Executing several tasks simultaneously where each task is an independent part of the same program. Each independent path of execution is called a Thread. ✔ Best suited for Programmatic level 🎯 Objective of Multitasking • Improve system performance • Reduce response time 📌 Applications of Multithreading Multithreading is widely used in: • Video games • Multimedia graphics • Animations • High performance applications 🔰 Multithreading Support in Java Java provides rich API support for multithreading through: • Thread • Runnable • ThreadGroup • ThreadLocal ✔ Java provides built-in APIs for multithreading, and programmers use these APIs to create and manage threads. This makes multithreading easier in Java compared to C++. 🔰 Ways to Create a Thread A thread can be defined in two ways: 1️⃣ Extending Thread class 2️⃣ Implementing Runnable interface 📌 Example – Extending Thread Class class MyThread extends Thread { public void run() { for(int i=0;i<5;i++){ System.out.println("Child Thread"); } } } public class ThreadDemo { public static void main(String[] args) { MyThread t = new MyThread(); // instantiation of thread t.start(); // starting of a thread for(int i=0;i<5;i++){ System.out.println("Main Thread"); } } } 📌 start() does NOT directly execute run(). It does: start() ↓ JVM asks Thread Scheduler ↓ New Thread Created ↓ run() executes in new thread ⭐ Key Points • start() method creates a new thread • run() contains the task executed by thread • Multiple threads execute simultaneously More concepts like Thread Scheduler, start() vs run(), Thread Lifecycle in the next post. #Java #CoreJava #Multithreading #JavaDeveloper #Concurrency #LearningJourney

🚀 Day 39 – Core Java | Polymorphism, Upcasting & Downcasting Today’s session focused on understanding the third pillar of Object-Oriented Programming — Polymorphism and how it works internally in Java. 🔹 What is Polymorphism? The word Polymorphism comes from Greek: Poly → Many Morph → Forms Meaning: One entity behaving in multiple forms. In Java, this is achieved mainly using method overriding and inheritance. 🔹 Example Used A Plane parent class with a method: fly() Three child classes: CargoPlane PassengerPlane FighterPlane Each class overrides the fly() method and behaves differently. Example: Cargo Plane → flies at low height Passenger Plane → flies at medium height Fighter Plane → flies at high altitude This demonstrates one method → multiple behaviors. 🔹 Tight Coupling vs Loose Coupling Tight Coupling Child reference → Child object CargoPlane cp = new CargoPlane(); cp.fly(); Here both reference and object are child type. Loose Coupling (Used for Polymorphism) Parent reference → Child object Plane ref = new CargoPlane(); ref.fly(); Here: Parent reference Child object This allows polymorphic behavior. 🔹 Types of Methods in Inheritance 1️⃣ Inherited Method Method comes directly from parent. 2️⃣ Overridden Method Child modifies the parent method. 3️⃣ Specialized Method Method exists only in child class. Example: carryCargo() carryPassengers() carryWeapons() 🔹 Important Rule Using parent reference, we can access: ✔ Inherited methods ✔ Overridden methods ❌ Cannot access specialized methods. 🔹 Downcasting To access child-specific methods: Parent reference must behave like a child. Example: ((CargoPlane) (ref)).carryCargo(); This process is called Downcasting. 🔹 Upcasting Plane ref = new CargoPlane(); Child object assigned to parent reference. This is called Upcasting and it happens automatically in Java. 🔹 Advantages of Polymorphism 1️⃣ Code Reduction Common logic can be reused instead of repeating code. 2️⃣ Code Flexibility One method can handle multiple object types. Example: airport.permit(plane) The same method can accept: CargoPlane PassengerPlane FighterPlane 💡 Key Takeaway Polymorphism allows one interface to perform multiple behaviors, making Java programs: More flexible Easier to maintain Less repetitive It is one of the most powerful concepts used in real-world Java applications and interviews. #CoreJava #Polymorphism #JavaOOP #MethodOverriding #Upcasting #Downcasting #JavaLearning #DeveloperJourney #InterviewPreparation

🚀 Day 25 | Core Java Learning Journey 📌 Topic: ArrayList & LinkedList in Java Today I learned about ArrayList and LinkedList, two important classes in the Java Collections Framework that implement the Java List Interface. Both are used to store ordered collections of elements, but they use different internal data structures and have different performance characteristics. 🔹 ArrayList ✔ ArrayList is a dynamic (growable) array implementation of the List interface. ✔ It automatically resizes when elements are added or removed. ✔ It allows duplicate elements and maintains insertion order. ✔ Elements can be accessed quickly using an index. Internal Data Structure: • Uses a resizable array. 📌Key Features: ✔ Fast random access using index (get, set operations) ✔ Allows null values and duplicate elements ✔ Maintains insertion order ✔ Automatically increases capacity when needed Best Use Case: ✔ When frequent data access (reading) is required. Example Implementation: • ArrayList 🔹 LinkedList ✔ LinkedList is another implementation of the List interface. ✔ It stores elements using nodes connected through links. ✔ Each node contains data and references to other nodes. ✔ It also implements Deque, so it can be used as a queue or stack. Internal Data Structure: • Doubly Linked List Each node contains: • Data • Reference to the previous node • Reference to the next node 📌Key Features : ✔ Efficient insertion and deletion of elements ✔ Allows duplicate elements ✔ Maintains insertion order ✔ Can be used as List, Queue, or Deque 🔹Types of Linked Lists (Conceptually): • Singly Linked List – Node points to next node • Doubly Linked List – Node points to both previous and next node • Circular Linked List – Last node connects back to the first node In Java, LinkedList is implemented as a Doubly Linked List. Example Implementation: • LinkedList 📌 Key Differences ✔ ArrayList uses a dynamic array ✔ LinkedList uses a doubly linked list structure ✔ ArrayList provides faster element access ✔ LinkedList provides faster insertion and deletion 📌 Key Takeaways ✔ Both ArrayList and LinkedList implement the List interface ✔ ArrayList is best for fast access and reading data ✔ LinkedList is better for frequent insertions and deletions ✔ Choosing the right data structure improves performance and efficiency Understanding these implementations helps developers select the most suitable data structure when working with collections in Java 💻⚡ Special thanks to Vaibhav Barde Sir for explaining these concepts clearly. #CoreJava #JavaLearning #ArrayList #LinkedList #JavaCollections #JavaDeveloper #Programming #LearningJourney

🚀 Day 21 | Core Java Learning Journey 📌 Topic: Exception Handling Keywords in Java Today I learned the most important Java exception handling keywords: try, catch, finally, throw, throws — and the commonly confused finalize(). Understanding them is essential for writing clean, production-ready Java code 💡 🔹 try ✔ Wraps risky code ✔ Must be followed by catch or finally ✔ Cannot exist alone ✔ Multiple catch blocks allowed Syntax : try { // risky code } catch(Exception e) { // handling } 🔹 catch ✔ Handles exceptions from try ✔ Takes exception object as parameter ✔ Order matters (Child → Parent) ✔ Multiple catch blocks allowed 🔹 finally ✔ Always executes (whether exception occurs or not) ✔ Executes even if return statement is present ✔ Used for cleanup (files, DB, etc.) ✔ Won’t execute only if JVM crashes or System.exit() is called 🔹 throw ✔ Explicitly throws an exception ✔ Used inside method body ✔ Can throw checked & unchecked exceptions ✔ Followed by exception object throw new IllegalArgumentException("Invalid Age"); 🔹 throws ✔ Declares exception responsibility ✔ Used in method signature ✔ Mainly for checked exceptions ✔ Can declare multiple exceptions public void readFile() throws IOException { // code } 🔥 throw vs throws ✔ throw → Inside method body ✔ throws → In method declaration ✔ throw → Single exception ✔ throws → Multiple exceptions 🔹 finalize() (Important) ✔ NOT part of exception handling ✔ Belongs to Garbage Collection ✔ Defined in Object class ✔ Called before object destruction ✔ Deprecated (Java 9+) 🔥 finally vs finalize() ✔ finally → Exception handling block ✔ finalize() → GC method ✔ finally → (Almost) always runs ✔ finalize() → May or may not run 📌 Key Takeaways ✔ finally ensures cleanup ✔ throw creates exceptions ✔ throws delegates responsibility ✔ finalize() relates to memory management Small keywords — powerful concepts 💻🚀 Special thanks to Vaibhav Barde Sir . #CoreJava #JavaLearning #ExceptionHandling #JavaDeveloper #OOP #LearningJourney

☕ Java 8 Features — A Major Shift in Java Programming Java 8 was not just another version update. It changed how Java developers write code. Before Java 8, code was often: More verbose Less expressive Harder to process collections elegantly With Java 8, Java became far more functional, concise, and powerful. 🚀 🔥 Key Java 8 Features 1️⃣ Lambda Expressions Lambda expressions allow you to write anonymous functions in a concise way. Example use: Sorting Filtering Functional-style programming This reduced boilerplate significantly. 2️⃣ Stream API One of the most powerful additions in Java 8. It allows processing collections using operations like: ✔ filter() ✔ map() ✔ sorted() ✔ collect() ✔ forEach() Instead of writing manual loops, developers can now write more declarative code. 3️⃣ Functional Interfaces An interface with exactly one abstract method. Examples: Runnable Callable Comparator Predicate Function Consumer Supplier These are the backbone of lambda expressions. 4️⃣ Default Methods in Interfaces Before Java 8, interfaces could not have method implementations. With Java 8: ✔ Interfaces can have default methods ✔ Helps backward compatibility ✔ Existing implementations do not break 5️⃣ Static Methods in Interfaces Interfaces can now contain static utility methods as well. This improved API design and reduced unnecessary utility classes. 6️⃣ Optional Class Used to avoid NullPointerException and represent missing values more explicitly. Instead of returning null directly, code can return: ✔ Optional.of() ✔ Optional.empty() ✔ Optional.ofNullable() This encourages safer null handling. 7️⃣ New Date and Time API The old Date and Calendar APIs were confusing and mutable. Java 8 introduced: LocalDate LocalTime LocalDateTime ZonedDateTime Period Duration Much cleaner and thread-safe. 8️⃣ Method References A shorter and cleaner way of referring to methods using :: Examples: System.out::println String::length Useful with streams and lambdas. 9️⃣ forEach Method Collections got a forEach() method, making iteration easier and cleaner. 🔟 Nashorn JavaScript Engine Java 8 introduced Nashorn for executing JavaScript inside JVM. Less relevant today, but it was a notable feature at that time. 💡 Why Java 8 Matters Even Today Java 8 is still one of the most asked topics in interviews because it changed: Collection processing Interface design Functional programming style Date/time handling Null safety approach If you know Java but don’t know Java 8 deeply, your backend foundation is incomplete. 🎯 Key Insight Java 8 made Java: More expressive, more modern, and more interview-relevant. It was the version that moved Java from purely object-oriented style toward a blend of object-oriented + functional programming. #Java #Java8 #BackendEngineering #SoftwareEngineering #StreamAPI #LambdaExpressions #FunctionalProgramming #JavaDeveloper #Programming #TechLearning #InterviewPrep #Microservices

Basic Java Interview Q&A ✅ 1. What is Java? Java is a high-level, object-oriented, platform-independent programming language. Its “Write Once, Run Anywhere” principle is powered by the Java Virtual Machine (JVM). ✅ 2. Key Features of Java Simple & Secure Object-Oriented Platform Independent (via JVM) Robust & Multithreaded High Performance (with JIT Compiler) ✅ 3. Difference Between JDK, JRE, and JVM JDK (Java Development Kit) → Includes compiler, tools, and JRE. JRE (Java Runtime Environment) → Contains JVM + core libraries. JVM (Java Virtual Machine) → Executes bytecode, platform-dependent. ✅ 4. Four OOP Principles in Java Encapsulation → Data hiding through classes. Inheritance → Reuse properties and methods. Polymorphism → One interface, multiple implementations. Abstraction → Hide implementation details, expose essential features. ✅ 5. Difference Between == and .equals() == → Compares memory references. .equals() → Compares actual values or content. ✅ 6. What is String Immutability? Strings in Java are immutable, meaning once created, they cannot be changed. Any modification results in a new String object in the memory pool. ✅ 7. What is the difference between Array and ArrayList? Array → Fixed size, can store primitives & objects ArrayList → Dynamic size, only stores objects, part of Collections framework ✅ 8. Types of Access Modifiers public → Accessible from anywhere. protected → Accessible within the same package and subclasses. default → Accessible only within the package. private → Accessible only within the same class. ✅ 9. What is Exception Handling? A mechanism to handle runtime errors using keywords: try, catch, finally, throw, and throws. ✅ 10. Checked vs. Unchecked Exceptions Checked → Compile-time (e.g., IOException, SQLException). Unchecked → Runtime (e.g., NullPointerException, ArithmeticException). ✅ 11. What is Garbage Collection? Automatic memory management that removes unused objects from the heap to free memory space. ✅ 12. What is the difference between Overloading and Overriding? Overloading → Same method name, different parameters (Compile-time polymorphism) Overriding → Subclass redefines parent class method (Runtime polymorphism) Follow Programming [Assignment-Project-Coursework-Exam-Report] Helper For Students | Agencies | Companies for more #Java #JavaInterview #CoreJava #OOP #BackendDevelopment #JavaProgramming #CodingInterview #100DaysOfCode

🚀 Day 37 – Core Java | Object Class, toString() & Why Java Is Not Pure OOP Today’s session focused on one of the most fundamental classes in Java — the Object class and how it affects every program we write. 🔹 The Root of Java’s Class Hierarchy In Java, every class automatically inherits from the Object class. Even if we don’t write it explicitly: class Employee Java internally treats it as: class Employee extends Object This means all classes inherit the methods of the Object class. 🔹 Methods Present in the Object Class The Object class contains 12 important methods and 1 constructor. Some commonly used methods include: getClass() hashCode() equals() clone() toString() notify() notifyAll() wait() finalize() (deprecated) These methods are automatically available in every Java class. 🔹 Understanding toString() Method Whenever we print an object reference: System.out.println(obj); Java internally calls: obj.toString() If we do not override toString(), the default implementation prints: ClassName@HexadecimalHashCode Example: Employee@6d06d69c 🔹 Overriding toString() for Better Output Instead of printing the memory reference, we can override the method to display meaningful information. Example: @Override public String toString() { return eid + " " + ename + " " + salary; } Now printing the object: System.out.println(employee); Output becomes: 1 Alex 60000 This is why overriding toString() is common in POJO classes. 🔹 Understanding the clone() Method The clone() method allows us to duplicate an object. Example scenario: If two references point to the same object, modifying one reference affects both. Using clone(): A separate copy of the object is created Changes do not affect the original object This is useful when working with arrays or objects that should remain independent. 🔹 Why Java Is Not a Pure Object-Oriented Language A pure object-oriented language means everything must be an object. However, Java includes primitive data types such as: int float char boolean Example: int a = 10; Here a is not an object, it is stored directly in memory. Because of primitive data types, Java is not considered a pure object-oriented programming language. 🔹 Making Java Fully Object-Oriented Java provides Wrapper Classes to treat primitive data as objects. Example: Integer a = Integer.valueOf(10); Now a becomes an object instead of a primitive variable. 💡 Biggest Takeaway Understanding the Object class and its methods helps us understand: How Java prints objects How method overriding works in real programs How memory references behave Why Java balances performance and object orientation These internal concepts are frequently tested in technical interviews. #Day37 #CoreJava #JavaInternals #ObjectClass #ToString #JavaOOP #JavaProgramming #DeveloperJourney

DAY 27: CORE JAVA 🚀 Understanding Inheritance in Java and Its Types Inheritance is one of the fundamental pillars of Object-Oriented Programming (OOP). It allows one class to acquire the properties (variables) and behaviors (methods) of another class. 📌 Definition: Inheritance is the process where a child class (subclass) acquires the properties and behaviors of a parent class (superclass) using the "extends" keyword in Java. 💡 Advantages of Inheritance ♻️ Code Reusability – Existing code can be reused in new classes ⏱️ Reduced Development Time & Effort 📈 Improved Maintainability and Productivity 🔹 Types of Inheritance in Java 1️⃣ Single Inheritance A class inherits from only one parent class. Example structure: Parent → Child 2️⃣ Multilevel Inheritance Inheritance happens in multiple levels, where a class becomes both a child and a parent. Example structure: Grandparent → Parent → Child This allows properties and methods to pass through multiple generations of classes. 3️⃣ Hierarchical Inheritance Multiple child classes inherit from one parent class. Example structure: Parent → Child1 Parent → Child2 Parent → Child3 4️⃣ Hybrid Inheritance A combination of two or more types of inheritance, such as multilevel + hierarchical. ⚠️ Multiple Inheritance and Diamond Problem Multiple Inheritance means a class inherits from more than one parent class. Example idea: Parent1 Parent2 ↓ Child However, Java does NOT allow multiple inheritance using classes. ❓ Why? Because of the Diamond Problem. In this situation: - Two parent classes inherit from the same grandparent class. - The child class inherits from both parents. - If both parents contain the same method, the child class cannot decide which method to use. This creates ambiguity in method resolution, which is known as the Diamond Problem. Therefore, Java avoids this complexity by not allowing multiple inheritance with classes. Instead, Java uses interfaces to achieve similar behavior safely. ⚠️ Cyclic Inheritance Cyclic inheritance occurs when a class tries to inherit from itself directly or indirectly. Example idea: Class A → inherits from B Class B → inherits from A This creates an infinite inheritance loop, so Java does not allow cyclic inheritance. 💻 Simple Example class Parent { void readBooks() { System.out.println("Read Books"); } } class Child extends Parent { } public class Main { public static void main(String[] args) { Child c = new Child(); c.readBooks(); } } Here, the Child class inherits the method from the Parent class, demonstrating Single Inheritance. ✨ Understanding inheritance helps developers design clean, reusable, and scalable object-oriented systems. TAP Academy #Java #OOP #Inheritance #Programming #SoftwareDevelopment #JavaDeveloper #Coding

DAY 18: CORE JAVA TAP Academy 🚀 Understanding Method Overloading in Java Method Overloading is one of the core concepts of Compile-Time Polymorphism in Java. It allows a class to have multiple methods with the same name but different parameter lists. Let’s break down how method overloading is observed and identified 👇 🔹 1. Method Name The method name must be the same. Example: add() can have multiple definitions within the same class. 🔹 2. Number of Parameters If the number of parameters is different, the method is overloaded. int add(int a, int b) int add(int a, int b, int c) 🔹 3. Type of Parameters Even if the number of parameters is the same, changing the data type makes it overloaded. int add(int a, int b) double add(double a, double b) 🔹 4. Order of Parameters If parameter types are the same but in a different order, it is still valid overloading. void display(int a, String b) void display(String b, int a) 🔹 5. Type Conversion (Implicit Casting) Java follows method matching rules: Exact match Widening (int → long → float → double) Autoboxing Varargs Example: void show(int a) void show(double a) If we call show(5), Java chooses the most specific match (int). 🔹 6. Ambiguity in Method Overloading Ambiguity occurs when Java cannot determine which method to call. Example: void test(int a, float b) void test(float a, int b) Calling test(10, 10) creates confusion because both methods are possible after type conversion. ⚠️ The compiler throws an error in such cases. 📌 Important Terms Related to Method Overloading ✔️ Compile-Time Polymorphism ✔️ Static Binding ✔️ Early Binding ✔️ Method Signature (method name + parameter list) ✔️ Implicit Type Promotion ✔️ Varargs ✔️ Autoboxing 💡 Key Rule to Remember Changing only the return type does NOT achieve method overloading. int sum(int a, int b) double sum(int a, int b) ❌ (Invalid) ✨ Method overloading improves code readability, flexibility, and reusability. It allows developers to perform similar operations in different ways without changing method names. Mastering this concept is essential for cracking Java interviews and writing clean object-oriented code. #Java #OOPS #Programming #SoftwareDevelopment #Coding #LearningJourney

🚀 Mastering Java Stream API – Write Cleaner, Smarter Code If you're still writing verbose loops in Java, it's time to rethink your approach. The Stream API (introduced in Java 8) is not just a feature—it’s a paradigm shift toward functional-style programming in Java. It allows you to process collections of data in a declarative, concise, and efficient way. 🔍 What is Stream API? A Stream is a sequence of elements that supports various operations to perform computations. Unlike collections, streams: Don’t store data Are immutable (operations don’t modify the source) Support lazy evaluation Enable parallel processing effortlessly ⚙️ Core Concepts 1. Stream Creation List<String> names = Arrays.asList("John", "Jane", "Jack"); Stream<String> stream = names.stream(); 2. Intermediate Operations (Lazy) filter() map() sorted() These return another stream and are not executed until a terminal operation is invoked. names.stream() .filter(name -> name.startsWith("J")) .map(String::toUpperCase); 3. Terminal Operations (Trigger Execution) forEach() collect() count() List<String> result = names.stream() .filter(name -> name.length() > 3) .collect(Collectors.toList()); 💡 Why Use Stream API? ✅ Readable & Declarative Code Focus on what to do, not how to do it ✅ Less Boilerplate Goodbye nested loops ✅ Parallel Processing names.parallelStream().forEach(System.out::println); ✅ Functional Programming Power Lambdas + Streams = Clean pipelines 🔥 Real-World Example Traditional Approach List<String> filtered = new ArrayList<>(); for (String name : names) { if (name.length() > 3) { filtered.add(name.toUpperCase()); } } Stream API Approach List<String> filtered = names.stream() .filter(name -> name.length() > 3) .map(String::toUpperCase) .collect(Collectors.toList()); 👉 Less code. More clarity. Better maintainability. ⚠️ Common Pitfalls Overusing streams can hurt readability Avoid complex nested streams Be cautious with parallel streams (thread-safety matters) 🧠 Pro Tip Think of streams as a data pipeline: Source → Intermediate Operations → Terminal Operation 📌 Final Thoughts The Stream API is a must-have skill for modern Java developers. It helps you write clean, scalable, and expressive code, especially in microservices and data-heavy applications. If you're building backend systems with Java, mastering streams is not optional—it's essential. 💬 How often do you use Stream API in your projects? Any advanced patterns you rely on? #Java #StreamAPI #BackendDevelopment #Java8 #CleanCode #FunctionalProgramming #SoftwareEngineering