Java String Basics: Mutable & Immutable Types

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 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

🚀 Java Series – Day 18 📌 Serialization in Java (Why Serializable is a Marker Interface?) 🔹 What is it? Serialization is the process of converting a Java object into a byte stream so it can be stored in a file or transferred over a network. The reverse process is called Deserialization. Java uses the Serializable interface to enable serialization. 🔹 Why do we use it? Serialization is useful when we want to save object state or send objects across systems. For example: In a banking or login system, user session data can be serialized and stored, then later restored when needed. 🔹 Why is Serializable a Marker Interface? A marker interface is an empty interface (no methods) that signals the JVM to perform special behavior. "Serializable" does not contain any methods. It simply tells the JVM: 👉 “This object is allowed to be converted into a byte stream.” If a class does not implement "Serializable", Java will throw a NotSerializableException. 🔹 Example: import java.io.*; class Student implements Serializable { int id; String name; Student(int id, String name) { this.id = id; this.name = name; } } public class Main { public static void main(String[] args) throws Exception { Student s = new Student(1, "Raushan"); // Serialization ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("data.txt")); out.writeObject(s); out.close(); System.out.println("Object Serialized"); } } 💡 Key Takeaway: "Serializable" is a marker interface that enables object serialization without defining any methods. What do you think about this? 👇 #Java #Serialization #JavaDeveloper #Programming #BackendDevelopment

Day 34 - Rules for Inheritance in Java Inheritance is a fundamental concept of Object-Oriented Programming (OOP) that allows one class to acquire the properties and methods of another class using the extends keyword. 🔹 Basic Rules of Inheritance in Java 1. Use of extends Keyword A subclass inherits from a superclass using the extends keyword. class Child extends Parent { } 2. Single Inheritance Only (for Classes) Java supports only single inheritance for classes. class B extends A { } // Valid class C extends A, B { } // Not Valid 3. Multiple Inheritance via Interfaces Java does not support multiple inheritance with classes, but it supports multiple inheritance using interfaces. class A implements X, Y { } 4. Private Members Are Not Inherited Private variables and methods of a superclass are not directly accessible in the subclass. 5. Constructor Is Not Inherited Constructors are not inherited, but the superclass constructor can be called using super(). 6. super Keyword Usage To access superclass variables To call superclass methods To invoke superclass constructor 7. Method Overriding Rules Method name must be same Parameters must be same Return type must be same (or covariant) Access modifier cannot be more restrictive than the superclass method 8. Final Methods Cannot Be Overridden If a method is declared as final, it cannot be overridden. 9. Final Class Cannot Be Inherited If a class is declared as final, no other class can extend it. 10. Java Does Not Support Hybrid Inheritance (with Classes) Hybrid inheritance is achieved only through interfaces. 🔹 Types of Inheritance in Java 1. Single Inheritance 2. Multilevel Inheritance 3. Hierarchical Inheritance 4. Multiple Inheritance (Through Interfaces Only) 📌 Key Points to Remember Promotes code reusability Represents IS-A relationship Improves maintainability Supports runtime polymorphism

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

📘 Why Does Java Allow the `$` Symbol in Identifiers? While learning about Java identifiers, I noticed something interesting. Unlike many programming languages, **Java allows the `$` symbol in identifier names.** Example: ```java int $value = 100; int total$amount = 500; ``` But this raises an interesting question: 👉 Why was `$` added to Java identifiers in the first place? 🔹 The historical reason When Java was designed in the 1990s, the language architects included `$` mainly for internal use by Java compilers and tools. The Java compiler often generates special class names automatically. For example, when you create an inner class, the compiled class file often uses `$` in its name: ``` OuterClass$InnerClass.class ``` Here, `$` helps represent the relationship between the outer class and the inner class. 🔹 Use in frameworks and generated code Many frameworks, libraries, and code generation tools also use `$` internally to create unique identifiers without conflicting with normal developer-defined names. 🔹 Should developers use `$` in identifiers? Technically, it is allowed. However, Java naming conventions discourage its use in normal code. The `$` symbol is generally reserved for: • Compiler-generated classes • Framework-generated code • Internal tooling 🔹 Key takeaway Sometimes language features exist not for everyday developers, but to support the ecosystem of compilers, frameworks, and tools that power the language. The `$` symbol in Java identifiers is one such design choice. #Java #Programming #SoftwareDevelopment #Coding #ComputerScience #LearnInPublic

🚀 Java Revision Journey – Day 10 Today I revised the concepts of Abstract Classes and Interfaces in Java and how they help achieve abstraction and flexible application design. 🔖 Abstract Class and Abstract Method: An abstract class is a class that cannot be instantiated and is used to provide partial abstraction. It can contain both abstract methods (without implementation) and concrete methods (with implementation). Abstract methods must be implemented by subclasses. 🔖 Interface: An interface defines a contract for classes by specifying method declarations. It mainly provides abstraction for behavior and allows classes to implement multiple interfaces. Interfaces can also contain default and static methods. 🔖 Abstract Class vs Interface: Abstract classes provide partial abstraction, while interfaces are mainly used to achieve a higher level of abstraction for behavior definition. 🔖Multiple Inheritance through Interface: Java does not support multiple inheritance using classes to avoid complexity. However, a class can implement multiple interfaces, allowing multiple inheritance in a structured way. 🔖Hybrid Inheritance through Interface: Hybrid inheritance is a combination of two or more types of inheritance. In Java, this can be achieved using interfaces. 🔖Diamond Problem and Code Ambiguity: Multiple inheritance using classes can create ambiguity, known as the diamond problem. Java avoids this by not allowing multiple inheritance with classes. Interfaces solve this problem with clear implementation rules. 🔖Loose Coupling vs Tight Coupling: Interfaces help achieve loose coupling, where components depend on abstractions rather than concrete implementations. This makes applications easier to maintain and extend. 💻 Understanding these concepts is essential for designing scalable, maintainable, and well-structured Java applications. Continuing to strengthen my Java fundamentals step by step. #Java #JavaLearning #JavaDeveloper #OOP #BackendDevelopment #Programming #JavaRevisionJourney

DAY 23 : CORE JAVA 🚀 Understanding POJO Class in Java In Java development, one commonly used concept is the POJO class. POJO stands for Plain Old Java Object. It is a simple Java class used to represent data without depending on complex frameworks or special restrictions. 🔹 Key Characteristics of a POJO Class • Private variables (fields) • Public getters and setters • A default (no-argument) constructor • May include parameterized constructors • Does not extend or implement special framework classes 🔹 Simple Example public class Student { private int id; private String name; // Default constructor public Student() {} // Parameterized constructor public Student(int id, String name) { this.id = id; this.name = name; } // Getter and Setter public int getId() { return id; } public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } } 🔹 Why POJO Classes are Important ✔ Improve code readability ✔ Promote reusability ✔ Make applications easier to maintain ✔ Commonly used in frameworks like Spring and Hibernate 💡 In simple terms, a POJO class is a clean and lightweight way to store and transfer data in Java applications. TAP Academy #Java #Programming #OOP #JavaDeveloper #Coding #SoftwareDevelopment

🌟 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