Java Execution Order: A Common Mistake

public static void main(String[] args) This line is the main method in Java — the entry point of every Java program. 1. public - It is an access modifier. - It means this method is accessible from anywhere. - The Java Virtual Machine (JVM) must be able to call this method from outside the class — that’s why it must be public. Example : If it’s not public, JVM cannot access it → program won’t run. 2. static - It means the method belongs to the class and not to any specific object. - JVM can call this method without creating an object of the class. Example : ClassName.main(args); // called directly without creating object 3. void - It is the return type. - It means this method does not return any value to the program. Example : If we write int instead of void, we’d have to return an integer value — but main() doesn’t return anything. 4. main This is the method name recognized by JVM as the starting point of every program. Execution always begins from this method. Example : public static void main(String[] args) {   System.out.println("Hello, World!"); } Here, execution starts at main(). 5. (String[] args) - This is a parameter (an array of strings). - It stores command-line arguments that you can pass when running the program. Example : If you run: java Test Hello World Then: args[0] = "Hello" args[1] = "World" -- Here we have simple way to understand Part Meaning Purpose public Access Modifier JVM can access it static Belongs to class Called without object void Return Type Doesn’t return anything main Method Name Program entry point String[] args Parameter Stores command-line inputs #Java #Programming #Core java #Codegnan Anand Kumar Buddarapu Uppugundla Sairam Saketh Kallepu

💡 String vs. StringBuffer: Why Mutability Matters in Java 📝 When working with text in Java, understanding the core difference between String and StringBuffer—Mutability—is key to writing efficient code. 1. String (Immutable) Immutability: Once a String object is created, its value cannot be changed. Behavior: Any operation that appears to modify a String (like concatenation using the + operator) actually creates a brand new String object in the Heap memory. Performance: This continuous creation of new objects is slow and consumes extra memory, especially when concatenating strings repeatedly within a loop. Use Case: Ideal for storing text that is constant and will not change (e.g., names, final identifiers, or configuration values). 2. StringBuffer (Mutable & Synchronized) Mutability: The value of a StringBuffer object can be changed in the same memory location. Behavior: Methods like append(), insert(), or delete() modify the sequence of characters directly within the existing object's allocated memory buffer. No new object is created for intermediate changes. Synchronization: StringBuffer is thread-safe (synchronized), meaning its methods can be safely used by multiple threads simultaneously without causing data corruption. Performance: Much faster than String for repeated text manipulation because it avoids the overhead of creating numerous temporary objects. Use Case: Ideal for text manipulation in a multi-threaded environment where concurrent access to the string data is a concern. The Golden Rule: If the text is constant, use String. If the text needs to be repeatedly changed (modified, appended, or inserted into), use StringBuffer. Thank you sir Anand Kumar Buddarapu,Saketh Kallepu,Uppugundla Sairam,Codegnan #Java #ProgrammingTips #String #StringBuffer #Codegnan

* Exception Handling in Java: In Java, Exception Handling helps us deal with unexpected events (errors) gracefully without crashing the program * What is an Exception? An exception is an event that disrupts the normal flow of execution. It can occur due to runtime errors like: Division by zero File not found Null reference access ⚙️ Key Keywords: 1)try → Block of code to test for errors. 2)catch → Handles the exception. 3)finally → Executes code whether exception occurs or not. 4)throw → Used to throw an exception manually. 5)throws → Declares exceptions in method signature. 🧩 Example: public class ExceptionExample { public static void main(String[] args) { try { int a = 10 / 0; // ArithmeticException } catch (ArithmeticException e) { System.out.println("Cannot divide by zero!"); } finally { System.out.println("Execution complete!"); } } } ✅ Output: Cannot divide by zero! Execution complete! 📘 Types of Exceptions: 1️⃣ Checked Exceptions – Checked at compile time (e.g., IOException, SQLException). 2️⃣ Unchecked Exceptions – Occur at runtime (e.g., NullPointerException, ArithmeticException). 3️⃣ Errors – Serious issues (e.g., OutOfMemoryError) – not handled by application code. 💡 Best Practices ✔️ Use specific exception types ✔️ Avoid empty catch blocks ✔️ Don’t overuse checked exceptions ✔️ Always close resources using finally or try-with-resources. 🚀 In Short: Exception Handling = Writing safe, reliable, and crash-free Java code! #Java #ExceptionHandling #Coding #JavaInterview #LearnJava #SoftwareDevelopment #TechCareers #ProgrammingTips.

* Exception Handling in Java: In Java, Exception Handling helps us deal with unexpected events (errors) gracefully without crashing the program * What is an Exception? An exception is an event that disrupts the normal flow of execution. It can occur due to runtime errors like: Division by zero File not found Null reference access ⚙️ Key Keywords: 1)try → Block of code to test for errors. 2)catch → Handles the exception. 3)finally → Executes code whether exception occurs or not. 4)throw → Used to throw an exception manually. 5)throws → Declares exceptions in method signature. 🧩 Example: public class ExceptionExample { public static void main(String[] args) { try { int a = 10 / 0; // ArithmeticException } catch (ArithmeticException e) { System.out.println("Cannot divide by zero!"); } finally { System.out.println("Execution complete!"); } } } ✅ Output: Cannot divide by zero! Execution complete! 📘 Types of Exceptions: 1️⃣ Checked Exceptions – Checked at compile time (e.g., IOException, SQLException). 2️⃣ Unchecked Exceptions – Occur at runtime (e.g., NullPointerException, ArithmeticException). 3️⃣ Errors – Serious issues (e.g., OutOfMemoryError) – not handled by application code. 💡 Best Practices ✔️ Use specific exception types ✔️ Avoid empty catch blocks ✔️ Don’t overuse checked exceptions ✔️ Always close resources using finally or try-with-resources. 🚀 In Short: Exception Handling = Writing safe, reliable, and crash-free Java code! #Java #ExceptionHandling #Coding #JavaInterview #LearnJava #SoftwareDevelopment #TechCareers #ProgrammingTips.

🚀 Mastering Strings in Java – The Backbone of Text Handling! 🧵 In Java, Strings are more than just text — they’re objects that make text manipulation powerful and efficient. Let’s break it down 👇 🔹 1. What is a String? A String in Java is an object that represents a sequence of characters. Example: String name = "Java"; Yes, even though it looks simple — it’s backed by the String class in java.lang package! 🔹 2. Immutable by Nature 🧊 Once created, a String cannot be changed. If you modify it, Java creates a new object in memory. String s = "Hello"; s = s + " World"; // Creates a new String object ✅ Immutability ensures security, caching, and thread-safety. 🔹 3. String Pool 🏊♂️ Java optimizes memory by storing String literals in a special area called the String Constant Pool. If two Strings have the same literal value, they point to the same memory! 🔹 4. Common String Methods 🛠️ s.length(); // Returns length s.charAt(0); // Returns first character s.toUpperCase(); // Converts to uppercase s.equals("Java"); // Compares values s.substring(0, 3);// Extracts substring 🔹 5. Mutable Alternatives 🧱 For performance-heavy string manipulations, use: StringBuilder (non-thread-safe, faster) StringBuffer (thread-safe) 💡 Pro Tip: Use StringBuilder inside loops for better performance instead of concatenating Strings repeatedly. #Java #Programming #Coding #100DaysOfCode #JavaDeveloper #StringsInJava #SoftwareDevelopment #TechLearning

☕ Day 10 of my “Java from Scratch” Series – “Operators in Java” In Java, operators are used to perform operations between variables. We perform operations on variables (operands) instead of directly on values. 📘 Example: a + b; Here, ‘a’ and ‘b’ are “Operands”, and ‘+’ is the “Operator”. 🔹 Types of Operators in Java 1️⃣ Arithmetic Operators 2️⃣ Relational Operators 3️⃣ Assignment Operators 4️⃣ Unary Operators 5️⃣ Logical Operators 1. Arithmetic Operators: Operator Meaning + Addition - Subtraction * Multiplication / Division % Modulo (Remainder) 📘 Examples: 5 + 10 => 15 (addition) 10 - 5 => 5 (subtraction) 11 / 2 => 5 (quotient) 11 % 2 => 1 (remainder) 9 * 2 => 18 (multiplication) 🧩 String Concatenation: When we add two strings, concatenation happens. Eg: String add = "a" + "b"; ✅ Result: "ab" When we add an int value to a String, the int is converted to String automatically. int a = 5; String result = "ab" + a; ✅ Result: "ab5" If two int values are concatenated with a String, the numeric operation happens first, then the concatenation. int a = 5; int b = 20; System.out.println(a + b + "ab"); ✅ Result: "25ab" 💡 Java performs operations from left to right. ⚠️ A Few Important Points: ❌ You cannot subtract a number from a String. ✅ You can subtract a number from a char — because chars have ASCII values. Example: int b = 20; System.out.println('a' - b); // 97 - 20 = 77 💡 In short: Operators help us perform arithmetic, relational, logical, and assignment operations efficiently — and Java handles them from left to right. #Java #Programming #Coding #Learning #SoftwareEngineering #JavaDeveloper #Operators #JavaFromScratch #InterviewQuestions #Tech #ArithmeticOperatorsInJava #NeverGiveUp

☕ Day 16 of my “Java from scratch” series “Dynamic Inputs in Java” 🎯 What is it? The values for variables can be decided at runtime. For this, we use the Scanner class. 🧩 Syntax: Scanner sc = new Scanner(System.in); int value1 = sc.nextInt(); String string = sc.nextLine(); String string2 = sc.next(); ⚠️ Note: There is a small issue in Java when taking inputs of different types (like int and String) one after another. If we take an int input first and then a String input immediately, the string input might be skipped 😅 👉 This happens because after entering the integer, we press Enter, and that newline character (\n) is still left in the input buffer. So when the next input (like nextLine()) is called, it reads that leftover newline instead of waiting for new input. ✅ Solution: To fix this, we add an extra sc.nextLine() to consume the leftover newline character before reading the next string. 🧠 Example: Scanner sc = new Scanner(System.in); System.out.print("Enter an integer: "); int value1 = sc.nextInt(); sc.nextLine(); // consume the leftover newline System.out.print("Enter a string: "); String string = sc.nextLine(); System.out.println("Integer: " + value1); System.out.println("String: " + string); 💡 Key takeaway: Always remember to handle newline characters properly when using Scanner for mixed inputs — it’s one of those small details that separates a beginner from a smart Java developer 😎 #Java #Programming #JavaBeginners #Coding #SoftwareDevelopment #JavaFromScratch #LearnJava #Tech #InterviewQuestions #NeverGiveUp

🚀 Constructor vs Method in Java – A Must-Know Difference for Every Developer! When you dive deeper into Java, one of the most fundamental yet commonly misunderstood concepts is the difference between a Constructor and a Method. Both may look similar — they can have parameters, perform actions, and even look almost identical in syntax — but their purpose and behavior are quite different 👇 🔹 Constructor 👉Used to initialize objects. 👉Has the same name as the class. 👉No return type, not even void. 👉Automatically invoked when an object is created. 🔹 Method 👉Used to define behavior or functionality of an object. 👉Can have any name (except the class name). 👉Always has a return type (or void). 👉Invoked explicitly after object creation. Here’s a simple and clear example 👇 class Car { String model; int year; // Constructor Car(String model, int year) { thismodel = model; this.year = year; System.out.println("Car object created!"); } // Method void displayDetails() { System.out.println("Model: " + model + ", Year: " + year); } public static void main(String[] args) { Car c1 = new Car("Tesla Model 3", 2024); // Constructor called c1.displayDetails(); // Method called } } ✅ Key Takeaway: Think of a constructor as giving life to an object, while a method defines what that object can do once it’s alive! #Java #OOP #ProgrammingConcepts #LearnJava #CodeBetter #SoftwareDevelopment #JavaDevelopers

🎯 Java Generics — Why They Matter If you’ve been writing Java, you’ve probably used Collections like List, Set, or Map. But have you ever wondered why List<String> is safer than just List? That’s Generics in action. What are Generics? Generics let you parameterize types. Instead of working with raw objects, you can define what type of object a class, method, or interface should work with. List<String> names = new ArrayList<>(); names.add("Alice"); // names.add(123); // ❌ Compile-time error Why use Generics? 1. Type Safety – Catch errors at compile-time instead of runtime. 2. Code Reusability – Write flexible classes and methods without losing type safety. 3. Cleaner Code – No need for casting objects manually. public <T> void printArray(T[] array) { for (T element : array) { System.out.println(element); } } ✅ Works with Integer[], String[], or any type — one method, many types. Takeaway Generics aren’t just syntax sugar — they make your Java code safer, cleaner, and more reusable. If you’re still using raw types, it’s time to level up! 🚀 ⸻ #Java #SoftwareEngineering #ProgrammingTips #Generics #CleanCode #TypeSafety #BackendDevelopment