Java Method Overloading Explained

Day 39 Understanding Polymorphism in Java Today’s learning was about Polymorphism, one of the three fundamental pillars of Object-Oriented Programming (OOP) along with Encapsulation and Inheritance. The word Polymorphism comes from two Greek words: “Poly” meaning many and “Morph” meaning forms. In programming, it refers to the ability of a single operation or method to take multiple forms depending on the object that invokes it. Key Concepts I Learned 🔹Loose Coupling in Polymorphism Polymorphism in Java works effectively when we maintain loose coupling. This means using a parent class reference to point to a child class object. Example concept: Plane p = new CargoPlane(); Here, the reference type is Plane (parent class) while the object created is CargoPlane (child class). This approach increases flexibility, maintainability, and scalability in software design. 🔹Dynamic Method Dispatch (Runtime Polymorphism) Using polymorphism, the same method call can produce different behaviors depending on the object type. For example: PassengerPlane may implement fly() differently CargoPlane may implement fly() differently FighterPlane may implement fly() differently Even though the method name remains the same, the actual implementation executed depends on the object at runtime. This concept helps developers write more generic and reusable code. 🔹Upcasting Upcasting occurs when a child class object is assigned to a parent class reference. Example: Plane p = new FighterPlane(); Benefits of Upcasting: ✔ Reduces code redundancy ✔ Enables polymorphism ✔ Improves flexibility in program design 🔹Downcasting Downcasting is used when we want to convert the parent reference back to the child type to access child-specific methods. Example: FighterPlane f = (FighterPlane) p; This allows access to specialized behaviors defined only in the child class. 🔹 Role of Inheritance in Polymorphism A crucial takeaway from today’s session is that inheritance is a prerequisite for polymorphism. Without inheritance: There would be no parent-child relationship And polymorphism would not be possible Inheritance creates the structure that enables method overriding and dynamic behavior. Key Takeaway Polymorphism is powerful because it allows developers to write flexible and scalable programs where one interface can support multiple behaviors. Instead of writing separate code for each object type, we can use a single reference and method call to handle multiple implementations efficiently. This concept is widely used in real-world software systems to build maintainable and extensible applications. Every day at Tap Academy is helping me strengthen my understanding of core programming principles and real-world coding practices, and I’m excited to continue this learning journey. #Java #OOP #Polymorphism #Programming #SoftwareDevelopment #Coding #DeveloperJourney #LearningInPublic #InternshipJourney #TapAcademy #JavaDeveloper #100DaysOfCode 🚀 TAP Academy Sharath R Harshit T Somanna M G

🚀Day 48–50: Java Full Stack Learning with Frontlines EduTech (FLM)& Fayaz S. In these sessions, I explored Java 8 Stream API features, Method References, Optional, and Date-Time. 🔹 partitioningBy() partitioningBy() splits elements into two groups based on a given predicate (true/false condition). It returns a Map<Boolean, List<T>>, making it useful for separating data like even/odd or passed/failed records. Map<Boolean, List<Integer>> result = numbers.stream() .collect(Collectors.partitioningBy(n -> n % 2 == 0)); 🔹 reduce() reduce() combines stream elements into a single result such as sum, product, or concatenation. int sum = numbers.stream() .reduce(0, (a, b) -> a + b); 🔹 joining() joining() is used to concatenate stream elements into a single String. It allows adding delimiters, prefixes, and suffixes while combining values. String names = list.stream() .collect(Collectors.joining(", ")); 🔹 groupingBy() groupingBy() groups elements based on a classification function. It returns a Map<Key, List<Value>>, commonly used in real-world scenarios like grouping employees by department. Map<String, List<Employee>> grouped = employees.stream() .collect(Collectors.groupingBy(Employee::getDepartment)); 🔹Method References (::) Method references provide a cleaner and shorter syntax for lambda expressions when only calling an existing method. They improve readability and reduce boilerplate code but can only be used when the lambda body contains a single method call. ✔ Static Method → ClassName::methodName ✔ Instance Method → object::methodName ✔ Instance Method → ClassName::methodName (e.g., String::toUpperCase) ✔ Constructor Reference → ClassName::new list.stream() .map(String::toUpperCase) .forEach(System.out::println); 🔹 Optional (Java 8) Optional helps avoid NullPointerException by handling possible null values safely. Optional<String> name = Optional.ofNullable(value); 🔹 LocalDateTime LocalDate and LocalDateTime are part of the java.time package introduced in Java 8. LocalDate represents only date (year, month, day) while LocalDateTime represents both date and time without timezone information. Both classes are immutable and inherently thread-safe. LocalDate date = LocalDate.now(); LocalDateTime dateTime = LocalDateTime.now(); LocalDate nextWeek = date.plusWeeks(1); LocalDateTime updatedTime = dateTime.minusHours(2); 💡 Overall, I strengthened my understanding of functional programming concepts, Stream processing, method referencing, null-safety using Optional, and Date-Time handling in Java. 🚀📈 #Java #JavaFeatures #JavaFullStack #FrontlinesEduTech #FullStackDeveloper #JavaDeveloper

🚀 Day 17 @ TAP Academy | Introduction to Strings in Java Today at TAP Academy, we explored a core concept of Java programming — the String! ☕💻 💡 What is a String in Java? A String is a sequence of characters enclosed within double quotes ("). In Java, a string is actually an object of the String class, not just a data type. 🧠 Simple Definition: A string is a collection of characters used to represent text in Java. ✅ Example: String name = "TAP Academy"; System.out.println(name); 📘 Output: TAP Academy 🧩 Different Ways to Create a String There are two main ways to create strings in Java 👇 1️⃣ Using String Literal String s1 = "Hello"; String s2 = "Hello"; 🟢 Java reuses the same memory in the String Constant Pool, making it efficient. 2️⃣ Using new Keyword String s3 = new String("Hello"); 🔵 Creates a new object in heap memory, even if the same value exists. ⚙️ Common String Methods Strings in Java come with many useful built-in methods that make text handling simple: MethodDescriptionExamplelength()Returns string length"TAP".length() → 3charAt()Returns character at index"Java".charAt(2) → vtoUpperCase()Converts to uppercase"tap".toUpperCase() → TAPtoLowerCase()Converts to lowercase"TAP".toLowerCase() → tapconcat()Joins two strings"TAP".concat(" Academy") → TAP Academyequals()Compares strings"Java".equals("JAVA") → false 🧠 String Characteristics ✔️ Strings are immutable – once created, they cannot be changed. ✔️ They are stored in the String Constant Pool for memory efficiency. ✔️ The String class is part of the java.lang package (imported automatically). ✔️ For mutable strings, we use StringBuilder or StringBuffer. 🔍 Example Program public class StringExample { public static void main(String[] args) { String course = "TAP Academy"; System.out.println("Length: " + course.length()); System.out.println("Uppercase: " + course.toUpperCase()); System.out.println("Character at index 4: " + course.charAt(4)); } } ✅ Output: Length: 11 Uppercase: TAP ACADEMY Character at index 4: c 💬 Why Strings Are Important ✔️ Used in almost all applications (names, messages, input/output). ✔️ Essential for working with user input, file handling, and APIs. ✔️ Foundation for text processing and data communication in Java. #TAPAcademy #JavaProgramming #StringsInJava #CoreJava #LearningJourney #InternshipExperience #CodingJourney #ProgrammingBasics #LearnToCode #BuildInPublic #JavaDeveloper #TechLearning #SoftwareDevelopment #CodingCommunity #ObjectOrientedProgramming

☕ Core Java Learning Journey – Day 4 🚀 Inheritance in Object-Oriented Programming (OOP) Inheritance is one of the most important concepts in Object-Oriented Programming. It allows a child class (derived class) to acquire the properties and behaviors (variables and methods) of a parent class (base class). This helps developers reuse existing code and build structured, scalable applications. In simple words, inheritance creates an “IS-A” relationship between classes. For example: A Dog IS-A Animal, a Car IS-A Vehicle. 🔹 Understanding Inheritance In inheritance, there are two main classes: ✔ Parent Class (Base Class) – The class whose properties and methods are inherited. ✔ Child Class (Derived Class) – The class that inherits the features of the parent class and can also add its own functionality. This mechanism allows the child class to reuse existing code instead of rewriting it, which improves development efficiency. Example (Conceptual): Parent Class → Animal Child Class → Dog The Dog class can inherit properties like eat() or sleep() from the Animal class and can also define its own methods like bark(). 🔹 Advantages of Inheritance ✅ Code Reusability Developers can reuse existing code from parent classes instead of writing the same code again. ✅ Faster Development Since many functionalities are already defined in the parent class, development becomes quicker. ✅ Better Code Organization Classes can be organized in a hierarchical structure, making the program easier to understand. ✅ Easier Maintenance If a change is required, it can often be done in the parent class, and it will automatically apply to child classes. ✅ Supports Polymorphism Inheritance allows method overriding, which is an important concept in runtime polymorphism. 🔹 Types of Inheritance 1️⃣ Single Inheritance One child class inherits from one parent class. Example: Class A → Class B 2️⃣ Hierarchical Inheritance Multiple child classes inherit from the same parent class. Example: Class A → Class B Class A → Class C 3️⃣ Multilevel Inheritance A class inherits from another class, and then another class inherits from it, forming a chain. Example: Class A → Class B → Class C 4️⃣ Multiple Inheritance (Concept) A child class inherits from more than one parent class. Example: Class A + Class B → Class C ⚠ In Java, multiple inheritance is not supported with classes because it can cause the Diamond Problem. 5️⃣ Hybrid Inheritance (Concept) A combination of different types of inheritance. It can be achieved in Java using interfaces. #Java #JavaLearning #Day4 #OOP #Inheritance #JavaProgramming #CodingJourney #LearnJava #DeveloperJourney

📘 Java Learning – Multithreading (Part 3: Runnable Interface, Thread Names & Priorities) 🚀🎯 Continuing my learning journey into Java Multithreading. In this post, I explored how to define threads using the Runnable interface, along with concepts like thread names and priorities. 🔰 Defining a Thread using Runnable Interface A thread can also be defined by implementing the Runnable interface, which is present in the java.lang package and contains only one method: • run() 📌 Two Approaches to Define a Thread 1️⃣ Extending Thread class 2️⃣ Implementing Runnable interface 📌 Example – Runnable Implementation class MyRunnable implements Runnable { public void run() { System.out.println("Child Thread"); } public static void main(String[] args) { MyRunnable r = new MyRunnable(); Thread t = new Thread(r); t.start(); System.out.println("Main Thread"); } } ✔ Output may appear in mixed order because execution depends on the Thread Scheduler. 🔰 Best Approach to Define a Thread Between the two approaches, implementing Runnable is recommended. Reason: • If a class extends Thread, it cannot extend any other class • If a class implements Runnable, it can still extend another class ✔ This provides better flexibility in design. 🔰 Common Thread Constructors Some commonly used constructors of the Thread class: Thread() Thread(Runnable r) Thread(String name) Thread(Runnable r, String name) Thread(ThreadGroup g, String name) Thread(ThreadGroup g, Runnable r) Thread(ThreadGroup g, Runnable r, String name) Thread(ThreadGroup g, Runnable r, String name, long stackSize) 🔰 Getting and Setting Thread Name Every thread in Java has a name (default or programmer-defined). Methods used: • getName() • setName(String name) Example: System.out.println(Thread.currentThread().getName()); // main Thread.currentThread().setName("first thread"); System.out.println(Thread.currentThread().getName()); To get the current executing thread reference: Thread.currentThread() 🔰 Thread Priority Every thread has a priority ranging from 1 (lowest) to 10 (highest). Standard constants: • Thread.MIN_PRIORITY • Thread.NORM_PRIORITY • Thread.MAX_PRIORITY If two threads have the same priority, the execution order depends on the Thread Scheduler. 🔰 Default Priority • Default priority of main thread → 5 • Child threads inherit priority from the parent thread Methods used: • getPriority() • setPriority(int p) Example: t.setPriority(5); t.setPriority(10); t.setPriority(100); // IllegalArgumentException ⭐ Key Takeaways • Threads can be created using the Runnable interface • Implementing Runnable offers better design flexibility • Every thread has a name and priority • Priority range: 1 to 10 Learning multithreading step by step while strengthening Java fundamentals ☕💻 #Java #CoreJava #Multithreading #JavaDeveloper #Concurrency #LearningJourney

🚀 Day 18 – Core Java Training TAP Academy | Mastering Arrays (1D, 2D & 3D) 💻📊 Today’s session was a deep dive into Arrays in Java, one of the most fundamental and frequently used concepts in programming. We didn’t just learn theory — we understood how arrays actually work in memory, how to store data dynamically, and how to traverse arrays efficiently using loops. This session strengthened my understanding of real interview-level array programming 🔥 ✅ Key Concepts Covered 📦 1️⃣ Understanding Arrays in Java We learned that: ✔️ Arrays are objects in Java ✔️ Arrays store homogeneous data ✔️ Memory is allocated in the Heap ✔️ Reference variables store memory addresses 💡 Important Insight: Printing an array reference prints the memory address, not the values. 📊 2️⃣ One-Dimensional Arrays (1D Array) We learned how to: ✔️ Create arrays using new ✔️ Take input using Scanner ✔️ Store values using indexing ✔️ Traverse arrays using loops ✔️ Print array elements efficiently 💡 Key Learning: Array indexing always starts from 0 to length-1 📐 3️⃣ Two-Dimensional Arrays (2D Array) We explored: ✔️ Rows and Columns structure ✔️ Nested loops for traversal ✔️ Storing and accessing values ✔️ Real-world examples like classrooms and students 💡 Important Concept: 2D Arrays require loop inside loop Outer loop → Rows Inner loop → Columns 🧊 4️⃣ Three-Dimensional Arrays (3D Array) One of the most interesting parts of today’s session: ✔️ Blocks → Rows → Columns structure ✔️ Triple nested loops ✔️ Storing and retrieving data ✔️ Real-world example: 🏫 Schools → Classrooms → Students 💡 Big Learning: 3D arrays use three indexing variables (i, j, k) 📏 5️⃣ Array Length Property We learned how to write dynamic programs using: array.length Instead of hardcoding values. ✔️ Works automatically if array size changes ✔️ Makes programs professional ✔️ Reduces errors 💡 Example: Instead of: for(int i=0;i<5;i++) Use: for(int i=0;i<a.length;i++) 🧠 Major Takeaway 💡 90% of array programs use the same logic: ✔️ Create array ✔️ Store values using loops ✔️ Traverse array using loops Only the logic inside the loop changes. 📚 Learning Habit Improvement Today’s biggest lesson was not only coding: ✔️ Practice by typing code ✔️ Ask questions ✔️ Maintain short notes ✔️ Revise regularly Consistency is the key to getting placed 🚀 🔥 Step by Step Growth in Core Java Continues… Grateful to Tap Academy for structured and deep technical training. More learning ahead 🚀 Trainer:Sharath R #Java #CoreJava #Arrays #Programming #TapAcademy #JavaDeveloper #CodingJourney #SoftwareDeveloper #Learning #Freshers #InterviewPreparation 💻🔥

🚀 Learning Update: Deep Dive into Java Inheritance Today’s session gave me a much clearer understanding of one of the core pillars of Object-Oriented Programming in Java — Inheritance. I learned that inheritance is the process by which one class acquires the properties and behaviors of another class. It plays a major role in code reusability, reduced development effort, and better program structure. Key concepts I learned: 🔹 Static in Java Before moving fully into inheritance, I revised the concept of static in Java: Static variables help in memory efficiency because only one copy is created for the entire class. Static blocks are used to initialize static variables and execute code before the main() method. Static methods can be called without creating objects, making them useful for class-level functionality. I also learned that static can be used with an inner class, but not with an outer class. 🔹 Inheritance in Java Inheritance allows a child class to access the fields and methods of a parent class using the extends keyword. This makes programs more structured and avoids rewriting the same logic again and again. Types of inheritance I understood: ✅ Single Inheritance – One parent and one child ✅ Multilevel Inheritance – Grandparent → Parent → Child ✅ Hierarchical Inheritance – One parent with multiple children ✅ Hybrid Inheritance – Combination of inheritance types ❌ Multiple Inheritance – Not allowed in Java because of the Diamond Problem / Ambiguity ❌ Cyclic Inheritance – Not allowed because it creates inconsistency in type hierarchy Every class in Java indirectly extends the Object class Private members do not participate in inheritance Constructors are not inherited Constructor execution between parent and child happens using constructor chaining with super() Difference between multilevel and multiple inheritance is very important 🔹 UML & Class Diagrams Another interesting takeaway was understanding how inheritance is represented using UML diagrams and how these diagrams help in the design phase of software development. This also connected with the idea of Software Development Life Cycle (SDLC), where requirement analysis and planning happen before coding begins. My takeaway: This session helped me realize that Java is not just about syntax — it is about understanding how real-world relationships are modeled in software. Strong basics in OOP concepts like inheritance are essential before moving on to polymorphism, abstraction, interfaces, exception handling, multithreading, collections, and advanced Java. Grateful for another step forward in my Java learning journey. Looking forward to learning more about constructor chaining, super keyword, and access modifiers in the next sessions. #Java #CoreJava #OOP #Inheritance #JavaProgramming #LearningJourney #SoftwareDevelopment #UML #SDLC #Programming #StudentDeveloper #CodingJourney TAP Academy

🚀 AI Powered Java Full Stack Journey with Frontlines EduTech (FLM) – Day 7 📌 Relational & Unary Operators — Understanding Decision Making in Java Day 7 was about learning how Java programs make decisions and control values step by step. This session introduced relational operators for comparisons and unary operators for value updates. 🔹 Relational Operators (Comparison Power) Relational operators are used to compare two values. The result of every comparison is always true or false. These operators are commonly used in conditions such as if statements and loops. Operators: == , > , < , >= , <= , != Example: int a = 10; int b = 10; System.out.println(a == b); // true System.out.println(a > b); // false System.out.println(a < b); // false System.out.println(a != b); // false Relational operators help programs evaluate conditions and make logical decisions. 🔹 Unary Operators (Single Value Operations) Unary operators perform operations on a single variable. Operators: + , - , ++ , -- They are commonly used to increase or decrease values, especially in counters and loops. 🔹 Increment Operators Post Increment (a++) Value is used first, then increased. int a = 5; System.out.println(a++); // 5 System.out.println(a); // 6 Pre Increment (++a) Value is increased first, then used. int a = 5; System.out.println(++a); // 6 🔹 Decrement Operators Post Decrement (a--) int a = 5; System.out.println(a--); // 5 System.out.println(a); // 4 Pre Decrement (--a) int a = 5; System.out.println(--a); // 4 💡 Key Concept All increment and decrement operators are unary operators, but not all unary operators are increment or decrement operators. 🎯 Day 7 Takeaways ✨ Relational operators compare values ✨ Comparison results are always true or false ✨ Unary operators work on a single value ✨ Increment and decrement control value changes ✨ Clear understanding of pre vs post operators Learning how Java handles conditions and value updates made programming feel more logical and structured. Grateful for the continuous learning journey 🚀 Special thanks to Krishna Mantravadi, Upendra Gulipilli, and @Fayaz S for explaining these concepts clearly with practical examples. #Java #JavaBasics #Day7 #RelationalOperators #UnaryOperators #IncrementDecrement #JavaLearning #FullStackJourney #FrontlinesEduTech #LearningInPublic #CodingLife

🚀 Day 23 | Core Java Learning Journey 📌 Topic: Collection Framework in Java Today I learned about the Collection Framework, one of the most important parts of Java used to store and manage groups of objects efficiently. 🔹 What is a Collection? ✔ A Collection is a framework that provides architecture to store and manipulate a group of objects. ✔ It allows developers to store, retrieve, and manage data dynamically. ✔ Collections can grow or shrink in size automatically unlike arrays. (Wikipedia) 🔹 Important Characteristics of Collections ✔ Collections store objects (non-primitive types) ✔ If primitive data is needed, use wrapper classes like Integer, Double, etc. ✔ Collection size is dynamic (not fixed) ✔ It helps manage large amounts of data efficiently 🔹 Java Collection Framework ✔ The Collection Framework is a unified architecture that provides interfaces, classes, and algorithms to work with groups of objects. (Wikipedia) ✔ It provides ready-to-use data structures like List, Set, Queue, and Map. 🔹 Main Interfaces in Collection Framework 1️⃣ List ✔ Ordered collection ✔ Allows duplicate elements ✔ Example: ArrayList, LinkedList, Vector 2️⃣ Set ✔ Does not allow duplicate elements ✔ Unordered collection ✔ Example: HashSet, LinkedHashSet, TreeSet 3️⃣ Queue ✔ Follows FIFO (First In First Out) principle ✔ Example: PriorityQueue, ArrayDeque 4️⃣ Map ✔ Stores data in key-value pairs ✔ Keys are unique ✔ Example: HashMap, LinkedHashMap, TreeMap ⚠ Note: Map is part of the Collection Framework but it does not extend the Collection interface. 🔹 Packages Used in Collection Framework Most collection classes and interfaces are available in: ✔ import java.util.*; This package includes important interfaces like List, Set, Map, Queue and classes like ArrayList, HashMap, HashSet, LinkedList. (JavaTechOnline) 🔹 Difference Between Collection and Collections ✔ Collection • It is an interface • Root interface of the collection hierarchy • Represents a group of objects ✔ Collections • It is a utility class • Contains static methods for operations like sorting, searching, and synchronization Example methods: Collections.sort() Collections.reverse() Collections.shuffle() 📌 Key Takeaways ✔ Collection Framework helps manage groups of objects efficiently ✔ Collection stores only objects (non-primitive types) ✔ Size of collections is dynamic ✔ Main interfaces: List, Set, Queue, Map ✔ Collection is an interface while Collections is a utility class Understanding the Collection Framework is essential for building efficient and scalable Java applications 💻⚡ Special thanks to Vaibhav Barde Sir. #CoreJava #JavaLearning #JavaCollections #CollectionFramework #JavaDeveloper #Programming #LearningJourney

30 days of Java at Tap Academy. Zero to OOP. Here's my full breakdown. Day 1 — couldn't tell a compiler from an interpreter. Day 30 — built a full Java inheritance hierarchy. That's the Tap Academy effect. And Harshit Sir made every day count. DAY 1–2 | Intro to Computers Hardware, software, JVM, platform independence. Most courses skip this. Tap Academy doesn't. DAY 3–4 | Features of Java WORA, OOP, secure, robust. Set up JDK. Wrote first Hello World. DAY 5–6 | OOP + Main Method 4 pillars of OOP. Decoded public static void main — every word has a purpose. DAY 7–8 | Data Types 8 primitives, type casting, widening & narrowing. DAY 9–10 | Variables Local, instance, static. Scope, lifetime, final keyword. DAY 11–12 | Operators Arithmetic to ternary. Built my first calculator. DAY 13–15 | Methods Parameters, return types, pass by value. Built a utility class. DAY 16–17 | Arrays 1D/2D arrays, Arrays.sort(). Solved 10 graded problems. DAY 18–20 | Strings 30+ methods, immutability, StringBuilder. Built palindrome checker & anagram detector. DAY 21–22 | Method Overloading Same name, different params. Compile-time polymorphism. DAY 23–24 | Encapsulation Private fields + getters/setters. Built a BankAccount class. DAY 25–26 | Constructors Default, parameterized, copy. Constructor chaining with this(). DAY 27–28 | Static Belongs to the class, not the object. Why main() is static — finally clear. DAY 29–30 | Inheritance extends, overriding, super. Built Animal → Mammal → Dog. Mission complete. --- Why Tap Academy stands out: → Teaches the WHY, not just the HOW → Every concept flows into the next — no gaps → Real-world examples that make OOP click → Faculty who genuinely celebrate your growth --- Special mention — Harshit T Sir, Java Trainer at Tap Academy. "The best teachers don't give you the answers — they give you the ability to find them yourself." That's Harshit Sir. Every single day. --- TAP Academy — not just a course. A career launchpad. #Java #TapAcademy #30DaysOfJava #LearningInPublic #OOP #SoftwareDevelopment #100DaysOfCode