N Srikanth’s Post

🔥 Day 25 – Method Overloading in Java Today’s learning was all about Method Overloading. 📌 What is Method Overloading? Method Overloading is the process of creating multiple methods with the same name inside a class but with different parameters. ✅ Methods can be overloaded by: 1️⃣ Changing the number of parameters 2️⃣ Changing the data type of parameters 3️⃣ Changing the order (sequence) of parameters ⚠️ Important Note: Changing only the return type does NOT support method overloading — it will cause a compilation error. 💡 Method Overloading & Type Promotion We also learned how type promotion works during method overloading. Smaller data types can automatically convert into larger data types: byte → short → int → long → float → double This plays an important role when the exact method match is not found — Java promotes the data type and selects the best suitable method. 🎯 Key Takeaways: ✔️ Also known as Compile-Time Polymorphism ✔️ Improves code readability and flexibility ✔️ Achieved through Static Binding (Early Binding) ✔️ Helps perform similar operations with different inputs Looking forward to learning more advanced concepts! 🚀 #Day25 #Java #MethodOverloading #JavaDeveloper #LearningJourney #Coding #Programming #TapAcademy

🚀 Java Learning Journey – Day 5 Why Java Says "No" to Multiple Inheritance (and "Yes" to Interfaces) 💎 Ever wondered why Java doesn't allow a class to inherit from two parents? It all comes down to the Diamond Problem. When two parent classes have the same method, the compiler gets confused: "Which one should I use?" To keep things clean and prevent bugs, Java blocks this at the class level. But wait—you can still achieve the same goal! 💡 By using Interfaces, you get the flexibility of multiple inheritance without the ambiguity. Check out this quick visual guide I put together to break it down. 👇 #Java #Programming #ObjectOrientedProgramming #SoftwareDevelopment #CodingTips #TechCommunity

While studying object oriented programming in Java, access modifiers explain how data and methods can be accessed from different places in a program. They help control visibility and protect the internal structure of classes. Things that became clear : • access modifiers define where a variable or method can be accessed • private members are accessible only inside the same class • default members are accessible within the same package • protected members are accessible within the same package and also in subclasses • public members can be accessed from anywhere These access levels help control how different parts of a program interact with each other. A simple structure shows how access modifiers appear in code : class Example { private int a; int b; protected int c; public int d; } Using the correct access level helps maintain better control over data and keeps the program structure organized. #java #oop #programming #learning #dsajourney

🚀 Java Concepts Made Simple (Visual Notes) While learning Java, I created my own notes to understand concepts like: • JVM & JRE • Platform Independent Programming • Classes & Objects • Variables & Data Types • Naming Conventions • Type Casting Later I enhanced these notes using AI to make them cleaner and more readable, so anyone starting with Java can understand them easily. Swipe through the slides to explore the concepts 📚 If you are learning Java, save this post for revision. Anshika Sinha Sonam Yadav Roshani Kumari #java #programming #coding #javadeveloper #learnjava #computerscience #codingjourney

🚀 Learning Java Star Patterns and Pattern Logic Today I practiced some Java pattern programs using nested loops in VS Code and ran them using the command prompt (javac and java). Along with writing the code, I also tried to understand the logic behind each pattern. 1. X Pattern *  *  * *  *  * * *  * • Use two nested loops for rows and columns. • Print * when the row number equals the column number (i == j). • Print * when the sum of row and column equals n + 1 (i + j == n + 1). • Otherwise print space. This creates two diagonals forming the X shape. 2.Inverted Triangle Pattern * ** *** **** ***** **** *** ** * • First loop prints stars increasing from 1 to n. • Second loop prints stars decreasing from n-1 to 1. • This combination creates a diamond-like pattern without spaces. 3.Alphabet Pattern – Letter D **** *  * *  * *  * *  * **** • First and last rows print continuous stars (****). • Middle rows print stars only at the first and last column. • Spaces are printed between them to form the shape of letter D. Grateful for the guidance from my mentors 🙏 Special thanks to: Dr. Tushar Ram Sangole sir Sushma Nair Mam Milind Ankleshwar sir #Java #Programming #CodingPractice #StarPatterns #LearningJava #ProblemSolving

🌱 Learning the Basics of OOP in Java While learning Java, I understood that Object-Oriented Programming (OOP) is built on 4 simple but powerful concepts: 🔹 1. Inheritance One class can use properties and methods of another class. 👉 This helps in reusing code. 🔹 2. Encapsulation Keeping data safe by wrapping variables and methods inside a class. 👉 We use private variables and getters/setters for security. 🔹 3. Polymorphism One method can behave differently in different situations. 👉 Example: Method overloading and method overriding. 🔹 4. Abstraction Showing only important details and hiding internal implementation. 👉 Done using abstract classes and interfaces. Understanding these concepts makes Java much clearer and helps in building real-world applications. I’m currently improving my Java fundamentals step by step. Every small concept I learn gives me more confidence. 💪 #Java #OOP #ProgrammingBasics #LearningJava #BeginnerDeveloper #SoftwareDevelopment

One of today’s most interesting learning was understanding the platform-independent nature of Java. Why language like java/python are platform independent and C/C++ are platform dependent? A common misconception is that high-level languages themselves are platform independent. In reality, platform independence comes from how the code is processed internally. First let's see what happens when a C/C++ code is run? The high level language code is translated using compiler into a machine level Object code (.obj file). [Key note: Machine level code are machine dependent because underlying operating system has it's own way of processing(specific to OS + CPU architecture)]. Object code is further linked with library files (.lib) using linker and than executable file (.exe) is generated and executed. Now, let's come to Java. Java follows a different path, the source code is compiled to Byte code(.class) using java compiler. Byte Code is neither in HLL nor in MLL i.e secure and platform independent. Now byte code is given to JVM. Since every operating system has its own JVM, the same bytecode can run anywhere. JVM takes the byte code and translates it into MLL using interpreter and executed statement by statement. That's the magic behind Write Once, Run Anywhere (WORA) This design choice is what makes Java incredibly portable and one of the reasons it remains so widely used. Greatful for the insightful session and guidence by Syed Zabi Ulla sir. Always fascinating to see how much happens behind the scenes when we run even a simple program. #Java #Programming #ComputerScience #Coding #JVM #PlatformIndependence #ObjectOrientedProgramming

📚 Today’s Learning: String Concatenation & "concat()" Method in Java In today’s class, I explored an important concept in Java called String Concatenation and the "concat()" method. 🔹 String Concatenation String concatenation is the process of combining two or more strings into a single string. In Java, this is commonly done using the "+" operator. It helps developers create meaningful text outputs by joining variables and messages together. 🔹 "concat()" Method Java also provides the "concat()" method, which is a built-in method of the String class. This method is used to append one string to another string, producing a new combined string. 🔹 Important Concept – String Immutability One key concept behind these operations is that Strings in Java are immutable. This means the original string cannot be changed; instead, a new string object is created when concatenation happens. 💡 Key Takeaway: - "+" is an operator used for concatenation - "concat()" is a method of the String class used to join strings Learning these fundamental concepts strengthens my Java programming foundation and helps me understand how strings work internally. #Java #Programming #LearningJourney #StudentDeveloper #Coding TapAcademy

🚀 Understanding Polymorphism in Java Polymorphism is one of the core concepts of Object-Oriented Programming (OOP). The word Polymorphism means “many forms.” In Java, it allows the same method or object to behave differently depending on the context or object calling it. 🔹 Types of Polymorphism 1️⃣ Compile-Time Polymorphism (Method Overloading) Occurs when multiple methods have the same name but different parameters. The decision of which method to call is made at compile time. 2️⃣ Run-Time Polymorphism (Method Overriding) Occurs when a child class provides a different implementation of a method defined in the parent class. The method call is resolved at runtime. 💡 Why Polymorphism is Important ✔ Improves code reusability ✔ Makes programs flexible and scalable ✔ Helps represent real-world scenarios in programming Understanding concepts like Polymorphism strengthens the foundation of writing clean, maintainable, and efficient code. 📚 Always learning and improving as a developer. #TAPAcademy #SharathR #LearningJourney #Java #OOP #Polymorphism #Programming #SoftwareDevelopment #LearningJourney

Another important concept while learning object oriented programming was understanding how variables behave inside a program. Depending on where a variable is declared and how it is used, Java treats it differently. Things that became clear : • local variables are declared inside methods and exist only during that method execution • instance variables are declared inside a class but outside methods, and each object gets its own copy • static variables belong to the class itself and are shared among all objects • local variables do not get default values, while instance and static variables do • the place where a variable is declared affects its lifetime and accessibility Seeing these differences made it clearer how memory and data management work inside a Java program. Understanding variable behaviour also helps avoid common mistakes when writing larger programs. #java #oop #programming #learning #dsajourney