Java Inheritance Explained: Understanding Superclass and Subclass

Day 12 of Learning Java Understanding the 4 Pillars of OOP (Object-Oriented Programming Today I learned about the four main pillars of Object-Oriented Programming (OOP) in Java. These concepts help us write clean, secure, and reusable code. The four pillars are: 1️⃣ Encapsulation Encapsulation means binding data and methods together in one class. It also helps to protect data by using private variables and public methods. Example idea: A capsule contains medicine inside. Similarly, a class keeps data and methods together. 2️⃣ Inheritance Inheritance means one class can use properties and methods of another class. It helps in code reuse. Example: A Car class can inherit features from a Vehicle class. 3️⃣ Polymorphism Polymorphism means one thing, many forms. The same method can behave differently in different situations. Example: A method named add() can add two numbers or three numbers. 4️⃣ Abstraction Abstraction means showing only important details and hiding complex implementation. Example: When we drive a car, we only use the steering wheel and pedals. We do not need to know how the engine works internally. In Simple Words OOP Pillars help us: ✔ Organize code ✔ Reuse code ✔ Improve security ✔ Reduce complexity #Java #OOP #ObjectOrientedProgramming #LearningInPublic #CodingJourney #SoftwareDevelopment

Started learning Object Oriented Programming (OOP) in Java. Until now most programs were written as step-by-step logic. OOP changes the perspective — instead of thinking only in terms of functions, we start thinking in terms of objects and their behaviour. Things that became clear : - an object represents something from the real world - every object has state (data) and behaviour (actions) - a class acts like a blueprint used to create objects - programs become easier to organize when related data and behaviour are grouped together - java mainly builds programs around four core ideas • encapsulation • inheritance • polymorphism • abstraction One realization from the start is that OOP is less about syntax and more about how you structure and model a problem. Still early in this section, but understanding this shift in thinking already makes the upcoming concepts easier to approach. Continuing with classes and objects. #java #oop #programming #learning #dsajourney

🚀 Day 11/45 – Introduction to OOP in Java On Day 11 of my Java learning journey, I started learning Object-Oriented Programming (OOP), which is one of the most important concepts in Java. OOP helps in designing programs using real-world objects, making code more structured and reusable. 📚 What I Learned Today Today I explored: ✔ What classes and objects are ✔ How to create and use objects in Java ✔ Understanding real-world mapping of objects to code ✔ Introduction to the four pillars of OOP – Encapsulation, Inheritance, Polymorphism, and Abstraction 💻 Practice Work To apply my learning, I implemented: • A simple class to store person details • A basic car example using class and object 🎯 Key Takeaway OOP is a powerful programming approach that helps in writing clean, modular, and reusable code. Understanding classes and objects is the first step toward mastering advanced Java concepts. Excited to dive deeper into OOP concepts. #Java #Programming #LearningInPublic #CodingJourney #SoftwareDevelopment #OOP

🚀 Java Casting: Upcasting vs Downcasting Understanding type casting in Java is essential for mastering Object-Oriented Programming and Polymorphism. 🔹 Upcasting (Child → Parent) When a child class object is referenced using a parent class reference. Example: Parent ref = new Child(); ✔ Done implicitly by the compiler ✔ Used to achieve runtime polymorphism ⚠ Child-specific methods cannot be accessed directly. 🔹 Downcasting (Parent → Child) When a parent reference is cast back to a child type. Example: Child c = (Child) ref; ✔ Done explicitly by the developer ✔ Allows access to child-specific methods ⚠ Must be used carefully to avoid ClassCastException at runtime. 💡 Key Takeaway: Upcasting = Moving up the class hierarchy (safe & automatic) Downcasting = Moving down the hierarchy (manual & needs caution) Mastering these concepts helps in writing flexible, reusable, and polymorphic Java code. #Java #JavaProgramming #OOP #Polymorphism #Programming #SoftwareDevelopment

💡 Understanding the Diamond Problem in Multiple Inheritance In Object-Oriented Programming, multiple inheritance allows a class to inherit from more than one parent class. But this can introduce a serious problem called the Diamond Problem. Imagine this inheritance structure: Class A / \ Class B Class C \ / Class D Both Class B and Class C inherit from Class A and override the same method show(). Example: class B extends A { void show() { System.out.println("B"); } } class C extends A { void show() { System.out.println("C"); } } Now when Class D inherits from both: D obj = new D(); obj.show(); Which method should run? B.show() C.show() This creates ambiguity because the compiler cannot determine which method implementation to use. To avoid this confusion, Java does NOT support multiple inheritance with classes. Instead, Java allows multiple inheritance through interfaces, where the implementing class explicitly defines the behavior. Understanding these design decisions helps us appreciate why Java prioritizes clarity, simplicity, and maintainability. #Java #ObjectOrientedProgramming #OOP #JavaDeveloper #SoftwareEngineering #ProgrammingConcepts #Coding #ComputerScience #LearnToCode #TechEducation:

Abstraction in Java The last OOP concept — Abstraction - using abstract classes. Here’s what I learned: 🔹 Abstract Methods These methods contain only the method signature (no body) and must be implemented by the child class. 🔹 Abstract Class Rules ✔ If a class contains abstract methods, it must be declared as abstract ✔ If a class extends an abstract class, it must either: • Implement all abstract methods, or • Be declared as abstract 🔹 Key Characteristics ✔ Abstract classes cannot be instantiated (no object creation) ✔ They can contain both abstract and non-abstract methods ✔ They behave like normal classes except for object creation 🔹 Constructor Behavior Even though we cannot create objects of an abstract class, its constructor is still executed when a child class object is created (via super()). This helped me clearly understand how abstraction provides structure and enforces implementation, making code more organized and scalable. TAP Academy #Java #OOP #Abstraction #Programming #SoftwareDevelopment #LearningJourney

🚀 Learning Java OOP Through Projects To strengthen my understanding of Object-Oriented Programming in Java, I built several mini projects where I focused on applying the core OOP principles in practice. Through these projects, I explored and implemented the following key concepts: 🔹 Classes & Objects 🔹 Encapsulation 🔹 Inheritance 🔹 Polymorphism 🔹 Abstraction 🔹 Collections (ArrayList) Projects I built while learning these concepts: 🔹 Parking Lot System https://lnkd.in/gYX7x_qN 🔹 Quiz Game https://lnkd.in/gseXZdmt 🔹 Employee Salary Calculator https://lnkd.in/gb_yrQiQ 🔹 Memory Matching Game ( Swing) https://lnkd.in/gqxftHhb Building these projects helped me move beyond theory and understand how OOP concepts are applied in real programs. #Java #OOP #JavaProjects #Programming #LearningByDoing

Day 40 - Abstraction in Java Today I explored Abstraction, one of the core concepts of Object-Oriented Programming in Java. 🔹 What is Abstraction? Abstraction is the process of hiding implementation details and showing only the essential features to the user. In simple terms: 👉 The user knows what a program does, but not how it does it internally. 📌 Key Points Abstraction is achieved using abstract classes and abstract methods. An abstract class cannot be instantiated (no objects can be created). It can contain both abstract methods and concrete methods. If a class contains at least one abstract method, the class must be declared abstract. 📌 Abstract Method A method that only has a declaration (signature) but no body. Child classes must provide the implementation. Example concept from my learning: ✈️ Plane Example Abstract class: Plane Methods: takeOff(), fly(), land() Child classes: CargoPlane PassengerPlane FighterPlane Each child class implements these methods differently, demonstrating abstraction and code reuse. 📌 Why Abstraction is Important ✔ Reduces code complexity ✔ Improves code maintainability ✔ Promotes modular design ✔ Enhances security by hiding details 💡 Real-world example: When sending an email, we simply type the message and click Send. The complex processes happening in the background are hidden from us. #Java #OOP #Abstraction #ProgrammingJourney #JavaLearning #SoftwareDevelopment #Coding

🚀 Understanding Core OOP Concepts in Java While revising Java, I summarized the main Object-Oriented Programming (OOP) concepts that form the foundation of modern software development. 🔹 Encapsulation Encapsulation means wrapping data (variables) and methods (functions) together inside a class. To protect data, variables are usually declared private, and access is provided using getter and setter methods. This improves security and data control. 🔹 Abstraction Abstraction focuses on hiding unnecessary implementation details and showing only the essential features to the user. In Java, abstraction can be achieved using Abstract Classes and Interfaces. 🔹 Inheritance Inheritance is the mechanism where one class acquires the properties and methods of another class. It helps in code reuse and creating hierarchical relationships between classes. Example types include: • Single Inheritance • Multilevel Inheritance • Hierarchical Inheritance 🔹 Polymorphism Polymorphism means “many forms”, where the same method behaves differently in different situations. Types of polymorphism: • Compile-Time Polymorphism – achieved using Method Overloading • Run-Time Polymorphism – achieved using Method Overriding 🔹 Static Keyword The static keyword is used for members that belong to the class instead of individual objects. Static variables and methods are shared among all instances of the class. These concepts together make Java programs modular, reusable, and easier to maintain. Always interesting to see how OOP principles model real-world problems in software design. #Java #OOP #Programming #SoftwareEngineering #Coding #ComputerScience

Today I learned Polymorphism in Java, one of the core concepts of Object-Oriented Programming (OOP). What is Polymorphism? The word Polymorphism comes from two Greek words: Poly = many Morphs = forms So, Polymorphism means “many forms” — the same parent reference can show different behaviors depending on which child object it refers to. Example: A parent class Plane can behave differently when connected to different child classes: CargoPlane PassengerPlane FighterPlane Plane ref; ref = new CargoPlane(); ref.fly(); ref = new PassengerPlane(); ref.fly(); ref = new FighterPlane(); ref.fly(); Here, the same ref calls fly() but produces different outputs. This is called Runtime Polymorphism (Method Overriding). Tight Coupling When a child class reference directly depends on its own object: CargoPlane cp = new CargoPlane(); cp.fly(); cp.carryCargo(); ✅ Child-specific methods accessible ❌ Less flexible ❌ Harder to extend Loose Coupling When a parent reference points to child objects: Plane ref = new CargoPlane(); ref.fly(); ✅ Flexible ✅ Reusable ✅ Supports polymorphism Advantages of Polymorphism ✅ Code Reusability ✅ Flexibility ✅ Reduction in Complexity Learning these OOP concepts is helping me understand how Java builds scalable and maintainable applications 🚀💻 #Java #Polymorphism #OOP #LooseCoupling #TightCoupling #Programming #SoftwareDevelopment #JavaLearning #CodingJourney