Java Strings: Concatenation, Methods, and Tokenizer

📘 **Day 17 – Java Learning Journey** Today I explored one of the most important concepts in Java: **Strings**. Here are some key points I learned while practicing and analyzing my notes: 🔹 **What is a String?** A String is a sequence (collection) of characters enclosed within double quotes. Example: `"Java"` 🔹 **Strings are Objects in Java** Unlike primitive data types, Strings are objects created from the `String` class. 🔹 **Immutable Nature of Strings** Strings in Java are **immutable**, meaning once a String object is created, its value cannot be changed. 🔹 **Different Ways to Create Strings** 1️⃣ `String s = "Java";` → Stored in the **String Constant Pool** 2️⃣ `String s = new String("Java");` → Stored in **Heap Memory** 3️⃣ Using character arrays 🔹 **String Comparison Methods** ✔ `==` → Compares **references (memory location)** ✔ `.equals()` → Compares **values/content** ✔ `.compareTo()` → Compares **character by character** ✔ `.equalsIgnoreCase()` → Compares **ignoring case differences** 🔹 **String Concatenation** Strings can be combined using: • `+` operator • `concat()` method Understanding concepts like **String Constant Pool, Heap Memory, and Reference Comparison** helped me clearly see how Java manages memory. Every day I’m learning something new and strengthening my Java fundamentals step by step. 🚀 #Java #Programming #LearningJourney #JavaDeveloper #ComputerScience #Coding TAP Academy

🚀 Learning Update: Java — Method Overloading, Type Promotion, CLI Args & Encapsulation (OOP) In today’s live Java session, I revised some core concepts that are frequently tested in interviews and also form the foundation for Object-Oriented Programming. ✅ Key Learnings: 🔹 Method Overloading (Compiler-based / Compile-time Polymorphism) Multiple methods with the same name in the same class Java Compiler checks in order: Method Name Number of Parameters Type of Parameters If all 3 are the same → Duplicate method error If exact match isn’t found → Java tries Type Promotion (closest match) If more than one method becomes eligible after promotion → Ambiguity error 🔹 Can we overload main()? ✅ Yes, main method can be overloaded But JVM always starts execution from: public static void main(String[] args) Other overloaded main() methods can be called manually using an object/reference. 🔹 Command Line Arguments (CLI) Inputs passed in terminal get stored in String[] args Args are always Strings (even numbers) + with args performs concatenation, not addition (unless you convert manually) 🔹 OOP Introduction + Encapsulation (1st Pillar) Encapsulation = Protecting the most important data + giving controlled access Use private variables for security Provide controlled access using: ✅ Setter → set/update data (usually void) ✅ Getter → get/return data (has return type) Add validations inside setter (ex: prevent negative bank balance) 📌 Realization: These concepts are not just theory — they directly relate to writing secure, industry-ready code. #Java #OOP #Encapsulation #MethodOverloading #CommandLineArguments #LearningUpdate #FullStackDevelopment #PlacementPreparation #TapAcademy #SoftwareDevelopment TAP Academy

 Key Concepts I Learned in Core Java – Method Overriding & Important Keywords As part of my Core Java learning, I explored some important rules related to Method Overriding, Covariant Return Types, Method Overloading, and Java keywords like "final" and "super". Here are the key takeaways: 🔹 Access Modifier Rule In method overriding, the child class method can keep the same access modifier or increase the visibility, but it cannot decrease it. 🔹 Return Type Rule When overriding a method, the return type should be the same. For primitive data types (int, float, double, etc.), the return type cannot be changed. 🔹 Covariant Return Type Java allows the child class method to return a subclass object of the parent method’s return type, provided there is a parent–child relationship between the classes. 🔹 Method Parameter Rule While overriding a method: * Type of parameters must be the same * Number of parameters must be the same * Order of parameters must be the same 🔹 Method Overloading If the method name is the same but parameters are different, it is called Method Overloading, not overriding. 🔹 "final" Keyword in Java "final" can be applied to: * Variables – value cannot be changed * Methods – cannot be overridden * Classes – cannot be inherited 🔹 "super" Keyword The "super" keyword is used to access parent class methods, variables, and constructors from the child class. 🔹 Difference Between "final", "finally", and "finalize" * final → used for variables, methods, classes * finally → block used in exception handling * finalize() → method used in garbage collection Understanding these concepts helped me strengthen my knowledge of OOP principles in Java and how inheritance and method behavior work in real applications. #Java #CoreJava #OOP #MethodOverriding #Programming #JavaDeveloper #LearningJourney

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

🚀 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 30 | Core Java Learning Journey 📌 Topic: Map Hierarchy in Java Today, I explored the Map Hierarchy in Java Collections Framework — understanding how different Map interfaces and classes are structured and related. 🔹 What is Map in Java? ✔ Map is an interface that stores key-value pairs ✔ Each key is unique and maps to a specific value ✔ It is part of java.util package 🔹 Map Hierarchy (Understanding Structure) ✔ Map (Root Interface) ⬇ ✔ SortedMap (extends Map) ⬇ ✔ NavigableMap (extends SortedMap) ⬇ ✔ TreeMap (implements NavigableMap) 🔹 Important Implementing Classes ✔ HashMap • Implements Map • Does NOT maintain order • Allows one null key ✔ LinkedHashMap • Extends HashMap • Maintains insertion order ✔ TreeMap • Implements NavigableMap • Stores data in sorted order • Does NOT allow null key ✔ Hashtable • Implements Map • Thread-safe (synchronized) • Does NOT allow null key/value 🔹 Key Differences ✔ HashMap → Fast, no ordering ✔ LinkedHashMap → Maintains insertion order ✔ TreeMap → Sorted data ✔ Hashtable → Thread-safe but slower 📌 When to Use What? ✅ Use HashMap → when performance is priority ✅ Use LinkedHashMap → when insertion order matters ✅ Use TreeMap → when sorting is required ✅ Use Hashtable → when thread safety is needed 💡 Key Takeaway: Understanding Map hierarchy helps in choosing the right data structure based on use-case rather than just coding blindly. 🙏 Special thanks to Vaibhav Barde Sir for the guidance! 🔥 #CoreJava #JavaLearning #JavaDeveloper #Map #HashMap #TreeMap #LinkedHashMap #Hashtable #JavaCollections #Programming #LearningJourney

DAY 22 : CORE JAVA 🔹 Understanding "this" Keyword vs "this()" Method in Java 🔹 While learning Java, one common confusion is the difference between the "this" keyword and the "this()" method. Let’s break it down in a simple way 👇 ✅ 1️⃣ "this" Keyword The "this" keyword refers to the current object of a class. 📌 It is mainly used to: - Resolve variable shadowing (when instance variables and constructor/method parameters have the same name). - Refer to current class instance variables. - Call current class methods. 💡 Example: class Student { String name; Student(String name) { this.name = name; // Resolves shadowing problem } } Here, "this.name" refers to the instance variable, while "name" refers to the constructor parameter. 👉 "this" can be used in any line of a constructor or method. ✅ 2️⃣ "this()" Method The "this()" method is used for constructor chaining — calling one constructor from another constructor within the same class. 📌 Key Rule: - "this()" must always be the first statement inside a constructor. - It cannot be used inside regular methods. 💡 Example: class Student { String name; int age; Student() { this("Unknown", 0); // Calls parameterized constructor } Student(String name, int age) { this.name = name; this.age = age; } } 👉 This improves code reusability and avoids duplication. 🔎 Key Differences "this" Keyword| "this()" Method Refers to current object| Calls another constructor Used to resolve shadowing| Used for constructor chaining Can be used in methods & constructors| Used only inside constructors Can appear anywhere in method/constructor| Must be first statement in constructor 💬 Mastering small concepts like "this" and "this()" builds a strong foundation in Object-Oriented Programming. Keep learning. Keep building. 🚀 TAP Academy #Java #OOP #Programming #SoftwareDevelopment #CodingJourney

🚀 Starting My Java Learning Journey – Day 6 🔹 Topic: Loops in Java Loops in Java are used to execute a block of code repeatedly until a certain condition is met. Java mainly provides three types of loops: 1️⃣ for Loop Used when the number of iterations is known. Example: public class Main { public static void main(String[] args) { for(int i = 1; i <= 5; i++) { System.out.println(i); } } } 2️⃣ while Loop Used when the number of iterations is not known beforehand. Example: public class Main { public static void main(String[] args) { int i = 1; while(i <= 5) { System.out.println(i); i++; } } } 3️⃣ do-while Loop The do-while loop executes the code at least once even if the condition is false. Example: public class Main { public static void main(String[] args) { int i = 1; do { System.out.println(i); i++; } while(i <= 5); } } 💡 Key Point: Loops help automate repetitive tasks and make programs more efficient. #Java #JavaLearning #Programming #BackendDevelopment #CodingJourney #JavaLoops

🚀 Learning Update: Java Encapsulation, POJO Classes & Real-World Object Handling Today’s live session helped me understand how Encapsulation works practically in Java by building a complete program step-by-step. 🔹 Encapsulation in Java Encapsulation protects data by making variables private and providing controlled access through public methods like getters and setters. 🔹 Building a POJO Class We created an Employee class with: • Private variables (empId, empName, empSalary) • Zero-parameterized constructor • Parameterized constructor • Getter and Setter methods This type of class is called a POJO (Plain Old Java Object) and is widely used in real-world Java applications. 🔹 Understanding the this Keyword The this keyword refers to the currently executing object and helps resolve the shadowing problem when local variables and instance variables have the same name. 🔹 Handling Multiple Objects Efficiently Instead of repeatedly creating objects, we used: ✔ Loops to handle multiple inputs ✔ Arrays of objects to store multiple Employee objects ✔ Scanner input handling to read user input dynamically 🔹 Important Debugging Insight While working with Scanner, I learned about the input buffer problem when mixing nextInt() and nextLine() and how to fix it by flushing the buffer. 🔹 Working with CSV Input & Wrapper Classes We also handled input like: 1,Alex,50000 Using: • split() method to separate values • Integer.parseInt() to convert String to integer • Wrapper classes for type conversion 💡 Key Takeaway Writing programs step-by-step and understanding how objects, constructors, arrays, and input handling work together makes Java concepts much clearer. Excited to keep improving my Core Java and problem-solving skills through continuous practice. #Java #Encapsulation #OOP #POJO #Programming #SoftwareDevelopment #LearningJourney #JavaDeveloper TAP Academy

📚 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