Java Mutable Strings: StringBuffer vs StringBuilder

Day 15 – Learning Java Full Stack. Today, let’s strengthen two important fundamentals in Java: 🔹 Scanner (User Input) 🔹 Identifiers & Naming Conventions Scanner Class-Scanner is a built-in class present in the java.util package. It is used to read input from the keyboard. Step 1: Import Scanner Java import java.util.Scanner; Step 2: Create Scanner Object Java Scanner sc = new Scanner(System.in); Step 3: Read Values int val = sc.nextInt(); System.out.println("value = " + val); 📌 Common Scanner Methods nextInt() → reads integer nextFloat() → reads float nextDouble() → reads double nextBoolean() → reads boolean next() → reads single word nextLine() → reads full line If invalid input is entered → InputMismatchException occurs. 🔹 Reading a Character (Important Trick) Scanner does not provide a direct method to read char. So we use: char ch = sc.next().charAt(0); Here:next() reads input as String charAt(0) extracts the first character Identifiers – Naming in Java Any name given by the programmer is called an Identifier. Examples: Class names Method names Variable names 📌 Rules for Identifiers ✔ Must start with an alphabet ✔ Numbers are allowed (but not as first character) ✔ Cannot use Java keywords ✔ Cannot contain spaces ✔ Special characters like $ and _ are allowed but not recommended 🔹 Industry Naming Conventions ✔ Class Names → PascalCase ex- class StudentDetails class DatabaseTriggerManager ✔ Method & Variable Names → camelCase ex- void printBill() int employeeSalary void generateTextReport() Clean naming improves: Readability Maintainability Professionalism #Java #JavaFullStack #CoreJava #Scanner #Identifiers #CleanCode

DAY 24: CORE JAVA 💻 Understanding Buffer Problem & Wrapper Classes in Java While working with Java input using Scanner, many beginners face a common issue called the Buffer Problem. 🔹 What is the Buffer Problem? When we use "nextInt()", "nextFloat()", etc., the scanner reads only the number but leaves the newline character ("\n") in the input buffer. Example: Scanner scan = new Scanner(System.in); int n = scan.nextInt(); // reads number String name = scan.nextLine(); // reads leftover newline ⚠️ The "nextLine()" does not wait for user input because it consumes the leftover newline from the buffer. ✅ Solution: Use an extra "nextLine()" to clear the buffer. int n = scan.nextInt(); scan.nextLine(); // clears the buffer String name = scan.nextLine(); 📌 This is commonly called a dummy nextLine() to flush the buffer. 🔹 Wrapper Classes in Java Java provides Wrapper Classes to convert primitive data types into objects. Primitive Type| Wrapper Class byte| Byte short| Short int| Integer long| Long float| Float char| Character 💡 Wrapper classes allow: - Converting String to primitive values - Storing primitive data in collections - Using useful utility methods Example: String s = "123"; int num = Integer.parseInt(s); // String → int 🔹 Example Use Case Suppose employee data is entered as a string: 1,Swathi,30000 We can split and convert values using wrapper classes: String[] arr = s.split(","); int empId = Integer.parseInt(arr[0]); String empName = arr[1]; int empSal = Integer.parseInt(arr[2]); 🚀 Key Takeaways ✔ Always clear the buffer when mixing "nextInt()" and "nextLine()" ✔ Wrapper classes help convert String ↔ primitive types ✔ They are essential when working with input processing and collections 📚 Concepts like these strengthen the core Java foundation for developers and interview preparation. TAP Academy #Java #CoreJava #JavaProgramming #WrapperClasses #Programming #SoftwareDevelopment

DAY 26: CORE JAVA 🚀 Understanding the Use Cases of Static Variables and Static Methods in Java In Java, the "static" keyword plays a powerful role in managing shared data and class-level behavior. It allows variables and methods to belong to the class itself rather than to individual objects. Let’s explore why and when we use them. 👇 🔹 Static Variables (Class Variables) Static variables are shared among all objects of a class. Only one copy exists in memory, making them highly efficient. ✅ Use Cases • Storing common data shared by all objects (e.g., interest rate, company name, configuration values) • Reducing memory usage since the variable is created only once • Accessing class-level constants and configuration settings Example: class Businessman { static float rate = 15.2f; // shared interest rate } Here, every object of "Businessman" will use the same interest rate value. 🔹 Static Methods Static methods belong to the class, not the object. They can be called without creating an instance of the class. ✅ Use Cases • Utility or helper methods (e.g., Math calculations) • When method logic does not depend on instance variables • Entry point of Java programs ("main()" method) Example: class Test { static void display() { System.out.println("Inside static method"); } } Called as: Test.display(); 🔹 Key Advantages ✔ Efficient memory utilization ✔ Easy access without object creation ✔ Useful for shared data and utility functions ✔ Improves program organization and readability 📌 Real-world example: In a simple interest calculator, the interest rate can be static because it remains the same for all customers. 💡 Takeaway: Use static variables for shared data and static methods for operations that do not depend on object state. TAP Academy #Java #Programming #JavaDevelopment #Coding #SoftwareEngineering #LearnToCode

🚀 Understanding Strings in Java | TAP Academy In Java, a String is a collection (sequence) of characters enclosed within double quotes (" ").A single character is enclosed within single quotes (' '). 🔹 Types of Strings in Java Strings are classified into two types: ✅ 1. Mutable String A mutable string can be modified or changed after creation. Example classes: StringBuilder, StringBuffer. ✅ 2. Immutable String An immutable string cannot be changed once created. The String class in Java is immutable — any modification creates a new object. 🔹 Creating an Immutable String in Java Like arrays, Strings are objects in Java. They are created using the new keyword or string literals, and memory is allocated in the Heap Segment of the JRE. Ways to create a String: Using String Literal → "Java" Using new Keyword → new String("Java") 🔹 Ways to Compare Two Strings in Java Java provides multiple methods to compare strings based on requirement: ✔ == → Compares memory reference (address) ✔ equals() → Compares actual content (values) ✔ compareTo() → Compares lexicographically (dictionary order) ✔ equalsIgnoreCase() → Compares content ignoring case differences 🔹 Memory Allocation of Strings (Heap Segment) The Heap is further divided into two pools: 📌 1. String Constant Pool (SCP) Strings created using literals. Duplicate values are not allowed (memory optimization). 📌 2. Non-Constant Pool (Heap Area) Strings created using the new keyword. Duplicate objects are allowed. ✨ Key Takeaway: Java Strings are powerful and memory-efficient because of immutability and the String Constant Pool, which help in security, performance, and reusability. #Java #StringsInJava #CoreJava #ProgrammingBasics #LearningJourney #TAPAcademy #JavaDevelopment

☕ Java Generics – Upper Bounded Wildcards Explained In Java Generics, the question mark (?) represents a wildcard, meaning an unknown type. Sometimes, we need to restrict the type of objects that can be passed to a method — especially when working with numbers or specific class hierarchies. That’s where Upper Bounded Wildcards come into play. 🔹 What is an Upper Bounded Wildcard? To restrict a wildcard to a specific type or its subclasses, we use: <? extends ClassName> This means: 👉 Accept ClassName or any of its subclasses. For example, if a method should only work with numeric types, we restrict it to Number and its subclasses like Integer, Double, etc. As explained in the document (Page 1), the syntax uses ? followed by the extends keyword to define the upper bound. 🔹 Practical Example From the example shown (Page 2), a method calculates the sum of elements in a list: public static double sum(List<? extends Number> numberlist) { double sum = 0.0; for (Number n : numberlist) sum += n.doubleValue(); return sum; } 📌 Why ? extends Number? ✔ Ensures only numeric types are allowed ✔ Accepts List<Integer> ✔ Accepts List<Double> ✔ Maintains type safety 🔹 Usage in Main Method List<Integer> integerList = Arrays.asList(1, 2, 3); System.out.println("sum = " + sum(integerList)); List<Double> doubleList = Arrays.asList(1.2, 2.3, 3.5); System.out.println("sum = " + sum(doubleList)); 🔹 Output (Page 3) sum = 6.0 sum = 7.0 This demonstrates how the same method works seamlessly with different numeric types. 💡 Upper bounded wildcards improve flexibility while maintaining compile-time type safety. They are essential for writing reusable and robust generic methods in Java. #Java #Generics #UpperBoundedWildcards #JavaProgramming #OOP #FullStackJava #Developers #AshokIT

 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 -12 🚀 Understanding Java Strings: Memory Management & Comparison While learning Java, one important concept every developer should understand is how Strings are stored and compared in memory. 🔹 String Constant Pool (SCP) When a string is created using a literal: Java Copy code String s = "Java"; It is stored in the String Constant Pool, which avoids duplicate values and saves memory. Multiple references can point to the same string object. 🔹 Heap Memory When a string is created using the new keyword: Java Copy code String s = new String("Java"); A new object is always created in the heap, even if the same value already exists. 📌 String Comparison Methods ✅ Reference Comparison (==) Checks whether two references point to the same memory location. Java Copy code s1 == s2 ✅ Value Comparison (.equals()) Checks whether the actual characters in the strings are the same. Java Copy code s1.equals(s2) ✅ Case-Insensitive Comparison (.equalsIgnoreCase()) Compares strings ignoring uppercase and lowercase differences. Java Copy code s1.equalsIgnoreCase(s2) 💡 Key Takeaway: Use string literals for memory efficiency and .equals() when comparing string values. Understanding these small concepts helps build strong programming fundamentals and improves coding practices in Java development. #Java #JavaProgramming #Programming #Coding #SoftwareDevelopment #LearnToCode #ComputerScience #CodingJourney #Developers #TechLearning

🌟 Day 7 of 10 – Core Java Recap: Encapsulation, Inheritance & Access Modifiers 🌟 Continuing my 10-day Core Java revision journey 🚀 Today I revised very important OOP concepts used in real-world applications. 🔐 1️⃣ Encapsulation in Java Encapsulation is the process of wrapping data (variables) and code (methods) into a single unit (class). It is mainly used for data hiding and security. In encapsulation: Variables are declared as private Access is provided using public getter and setter methods Key Benefits: ✔ Data hiding ✔ Controlled access to data ✔ Better code security ✔ Improved maintainability Example concept: Private variables + Public getters/setters = Encapsulation ⚙ 2️⃣ Implementation of Encapsulation Key points: Use private data members Provide public getter() and setter() methods Prevent direct access from outside the class Example: private String name; public String getName() { return name; } public void setName(String name) { this.name = name; } 🧬 3️⃣ Inheritance in Java Inheritance is a mechanism in which one class acquires the properties and behaviors of another class. Real-time relation: Parent Class → Child Class Superclass → Subclass Advantages: ✔ Code reusability ✔ Readability ✔ Maintainability 📚 4️⃣ Types of Inheritance Single Inheritance Multilevel Inheritance Hierarchical Inheritance Hybrid Inheritance (supported using interfaces in Java) Note: Java does not support multiple inheritance using classes to avoid ambiguity (Diamond Problem). 🔓 5️⃣ Access Modifiers in Java Access modifiers define the accessibility (scope) of classes, variables, and methods. Types of Access Modifiers: Public Private Protected Default (No modifier) 📊 6️⃣ Scope of Access Modifiers 🔹 Private Accessible only within the same class Provides maximum data security 🔹 Default Accessible within the same package No keyword is used 🔹 Protected Accessible within the same package Also accessible in subclasses (even in different packages) 🔹 Public Accessible from anywhere in the program Access Level Order: Private < Default < Protected < Public 💡 Key Learnings Today: Understood encapsulation and data hiding Learned how getters and setters control data access Revised inheritance and its types Clearly understood access modifiers and their scope Strengthening my OOP concepts step by step for interviews and real-world development 💻🔥 #Java #CoreJava #OOP #Encapsulation #Inheritance #AccessModifiers #JavaLearning #CodingJourney

🚨throw vs throws in Java - One Letter, Completely Different Meaning When I first started learning Java, two keywords confused me a lot: throw & throws They look almost identical... but they do very different things. Let's break it down simply👇 💠throw - Used to actually throw an exception -> Used within methods to explicitly raise an exception instance, allowing one checked or unchecked exception at a time. 🧩Example: if(age < 18){ throw new IllegalArgumentException("Age must be 18 or above"); } Here, the program immediately throws an exception. 💠throws - Used to declare possible exceptions -> Used in method signatures to declare one or more potential checked exceptions, signaling to the caller that the exception must be handled. 🧩Example: public void readFile() throws IOException { FileReader file = new FileReader("data.txt"); } This method itself does not handle the exception - it passes responsibilty to the caller. 🧠Simple way to remember throw->used inside a method (creates) throws->used in method declaration (warns) 💡Understanding this difference helps to: ✅Write cleaner APIs ✅Handle errors properly ✅Make the code easier for others to use. 💬 Quick question for Java developers here: Which exception confused you the most when you were starting out? NullPointerException still haunts many developers 😅 #Java #ExceptionHandling #JavaDeveloper #BackendDevelopment #Programming #SoftwareEngineering #LearningInPublic