Java Static Variables, Blocks & Methods Explained

🚀 Day 22/100 – Java Learning Series Today I explored important looping and control concepts in Java, along with handling user input in programs. 🔹 while Loop The while loop executes a block of code as long as a condition remains true. It is useful when the number of iterations is not known beforehand. Syntax: while(condition){ // code } 🔹 do-while Loop The do-while loop is similar to the while loop, but it executes the code at least once, even if the condition is false. Syntax: do{ // code } while(condition); 🔹 Jumping Statements Jumping statements control the flow of loops and program execution. ✔ break – terminates the loop immediately ✔ continue – skips the current iteration and moves to the next ✔ return – exits from a method 🔹 Scanner Class The Scanner class (from java.util package) is used to take input from the user during program execution. Example: import java.util.Scanner; Scanner sc = new Scanner(System.in); int num = sc.nextInt(); 💡 Key Learning: Combining loops + jumping statements + user input helps build interactive and dynamic Java programs. Consistency in learning is the path to mastering programming. 💻🔥 #Java #JavaProgramming #CodingJourney #LearnJava #Programming #SoftwareDevelopment #JavaDeveloper #100DaysOfCode #10000 Coders #Meghana M

🚀 Day 24 | Core Java Learning Journey 📌 Topic: Collection Hierarchy in Java Today I explored the Collection Hierarchy, which explains how different interfaces and classes in the Java Collection Framework are organized. Understanding this hierarchy helps developers choose the right data structure for storing and managing data efficiently. 🔹 What is Collection Hierarchy? ✔ Collection Hierarchy represents the structure of interfaces and classes in the Java Collection Framework. ✔ It shows how different collections are related through inheritance and implementation. ✔ It starts from the Iterable interface, which is the root for all collection classes that can be iterated. 🔹 Root Interface: Iterable ✔ Iterable is the top-level interface of the collection hierarchy. ✔ It allows objects to be traversed using loops, especially the enhanced for-each loop. ✔ It provides the iterator() method used to iterate through elements. 🔹 Collection Interface ✔ Collection extends the Iterable interface. ✔ It is the root interface for most collection types in Java. ✔ It defines basic operations such as adding, removing, and managing elements. 🔹 Main Subinterfaces of Collection 1️⃣ List ✔ Ordered collection ✔ Allows duplicate elements ✔ Elements can be accessed by index Examples: • ArrayList • LinkedList • Vector • Stack 2️⃣ Set ✔ Does not allow duplicate elements ✔ Stores unique values only Examples: • HashSet • LinkedHashSet • TreeSet Additional interfaces: • SortedSet • NavigableSet 3️⃣ Queue ✔ Follows FIFO (First In First Out) principle ✔ Mainly used for processing elements in order Examples: • PriorityQueue • Deque Deque implementations: • ArrayDeque • LinkedList 🔹 Map Interface (Special Case) ✔ Map is also part of the Java Collection Framework ✔ But it does not extend the Collection interface ✔ It stores elements as key-value pairs Examples: • HashMap • LinkedHashMap • TreeMap 📌 Key Takeaways ✔ Collection Hierarchy shows the relationship between interfaces and classes ✔ The hierarchy starts from Iterable → Collection → List/Set/Queue ✔ Different implementations provide different performance and behavior ✔ Understanding the hierarchy helps developers choose the right collection type Learning the Collection Hierarchy makes it easier to understand how Java manages different data structures efficiently 💻⚡ Special thanks to Vaibhav Barde Sir for guiding through these concepts. #CoreJava #JavaLearning #CollectionFramework #CollectionHierarchy #JavaDeveloper #Programming #LearningJourney

🚀 Day 27 | Core Java Learning Journey 📌 Topic: Vector & Stack in Java Today, I learned about Vector and Stack, two important Legacy Classes in Java that are part of the early Java library and later became compatible with the Java Collections Framework. 🔹 Vector in Java ✔ Vector is a legacy class that implements the List interface ✔ Data structure: Growable (Resizable) Array ✔ Maintains insertion order ✔ Allows duplicate elements ✔ Allows multiple null values (not "NILL" ❌ → correct term is null ✔) ✔ Can store heterogeneous objects (different data types using Object) ✔ Synchronized by default (thread-safe, but slower than ArrayList) 📌 Important Methods of Vector • add() – add element • get() – access element • remove() – delete element • size() – number of elements • capacity() – current capacity of vector 💡 Note: Due to synchronization overhead, ArrayList is preferred in modern Java. 🔹 Stack in Java ✔ Stack is a subclass (child class) of Vector ✔ It is also a Legacy Class ✔ Data structure: LIFO (Last In, First Out) 📌 Core Methods of Stack • push() – add element to top • pop() – remove top element • peek() – view top element without removing 📌 Additional Useful Methods • isEmpty() – check if stack is empty • search() – find element position 💡 Note: In modern Java, Deque (ArrayDeque) is preferred over Stack for better performance. 📌 Key Difference: Vector vs Stack ✔ Vector → General-purpose dynamic array ✔ Stack → Specialized for LIFO operations 💡 Understanding these legacy classes helps in learning how Java data structures evolved and why modern alternatives are preferred today. Special thanks to Vaibhav Barde Sir for the guidance! #CoreJava #JavaLearning #JavaDeveloper #Vector #Stack #JavaCollections #Programming #LearningJourney

🚀 Day 27 and 28 of Learning Java @ Tap Academy 📘 Constructor Chaining & POJO in Java Today, I explored Constructor Chaining and also learned about POJO (Plain Old Java Object) concepts. 🔹 What is Constructor Chaining? Constructor chaining is a process where one constructor calls another constructor in the same class using this(). ✔️ Helps in code reusability ✔️ Must be the first statement inside the constructor 🔹 POJO (Plain Old Java Object): A POJO class is a simple Java class that contains: ✔️ Private fields ✔️ Zero-argument constructor (default constructor) ✔️ Parameterized constructor ✔️ Getter and Setter methods 🔹 Example of POJO Class: class Student { private int id; private String name; // Zero-parameter constructor Student() {} // Parameterized constructor Student(int id, String name) { this.id = id; this.name = name; } // Getter public int getId() { return id; } public String getName() { return name; } // Setter public void setId(int id) { this.id = id; } public void setName(String name) { this.name = name; } } 🔹 Wrapper Classes in Java: ✔️ Primitive data types (int, float, etc.) are not objects ✔️ Wrapper classes (Integer, Float, etc.) convert primitives into objects ✔️ Helps Java achieve better object-oriented programming concepts 🔹 Performance Note: ✔️ Java is slightly slower compared to C and C++ ✔️ Because Java uses JVM and abstraction features ✔️ C & C++ are faster due to low-level memory access 💡 Key Takeaway: Understanding POJO, constructor chaining, and wrapper classes helps build strong foundations in Java and object-oriented programming. #TapAcademy #Java #LearningJava #CodingJourney #JavaBasics #OOPS #POJO #ConstructorChaining

🚀 My Java Learning Journey – Understanding Interfaces Today I learned about Interfaces in Java, one of the most important concepts used to achieve pure abstraction and standardization in software design. An interface acts like a contract. It defines what methods must exist, but it does not define how they work. Any class that implements the interface must provide the method bodies. 💡 Why Interfaces Exist When different developers or companies build similar functionality, they might use different method names for the same task, which creates inconsistency and makes systems hard to maintain. Interfaces solve this problem by enforcing standard method names. Real-world analogy: 🤝 Contract Example When two companies sign a contract, both agree to follow the same rules. Similarly, when a class implements an interface, it promises to follow the method definitions declared in that interface. Example idea in Java: interface Calculator { void add(); void sub(); } class MyCalculator implements Calculator { public void add() { } public void sub() { } } 📌 Key Takeaways: ✔ Interface = Pure abstraction ✔ Methods are public abstract by default ✔ Promotes polymorphism and loose coupling ✔ Ensures standardization across implementations Learning interfaces made me realize how large systems stay consistent even when multiple developers build different components. #Java #OOP #Interfaces #JavaDeveloper #Programming #SoftwareEngineering #CodingJourney #LearnJava

🚀 Understanding Functional Interfaces in Java | Core Java (JDK 8 Feature) As part of my learning journey at TAP Academy, I explored the concept of Functional Interfaces, which play a key role in enabling modern Java features like Lambda Expressions. 🔹 What is a Functional Interface? A Functional Interface is an interface that contains only one abstract method. This concept was introduced as part of JDK 8 to support functional programming in Java. We use Annotation as @FunctionalInterface 🔹 Ways to Implement Functional Interface There are multiple ways to implement a functional interface: ✔ 1. Regular Class class A { // implementation } ✔ 2. Inner Class class A { class B { // implementation } } ✔ 3. Anonymous Inner Class class A { { // implementation without class name } } ✔ 4. Lambda Expressions (Most Efficient Way) () -> { } (int a) -> { } (a) -> { } a -> { } ❌ Invalid: a, b -> { } // Not allowed without proper syntax 🔹 Lambda Expressions Lambda expressions provide a concise way to implement functional interfaces. 📌 Important Note: ✔ Lambda expressions can be used only with functional interfaces ❌ They cannot be used with regular interfaces 🔹 Built-in Functional Interfaces Some commonly used built-in functional interfaces in Java include: ✔ Runnable ✔ Comparable ✔ Comparator 🔹 Key Takeaway Functional Interfaces help achieve: ✔ Cleaner and shorter code ✔ Improved readability ✔ Better support for functional programming ✔ Efficient implementation using Lambda expressions Grateful to TAP Academy for helping me strengthen my understanding of modern Java concepts and improving my coding skills step by step. 💻✨ #Java #CoreJava #FunctionalInterface #LambdaExpressions #Programming #OOPS #JavaLearning #SoftwareDevelopment #TAPAcademy #LearningJourney TAP Academy

🚀 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

🚀 Starting My Java Learning Journey – Day 9 🔹 Topic: Method Overloading in Java Method Overloading is a feature in Java that allows a class to have multiple methods with the same name but different parameters. It helps improve code readability and flexibility. 📌 Ways to Achieve Method Overloading 1️⃣ Different number of parameters 2️⃣ Different data types of parameters 📌 Example Program public class Main { // Method with two int parameters static int add(int a, int b) { return a + b; } // Method with three int parameters static int add(int a, int b, int c) { return a + b + c; } public static void main(String[] args) { System.out.println(add(5, 10)); System.out.println(add(5, 10, 15)); } } Output: 15 30 💡 Key Points: ✔ Method overloading allows multiple methods with the same name ✔ Methods must differ in number or type of parameters ✔ Helps make programs more flexible and readable #Java #JavaLearning #Programming #BackendDevelopment #CodingJourney #MethodOverloading

🚀 Learning Update: Understanding How a Java Program Actually Executes Today’s session helped me gain a deeper understanding of how Java programs execute internally beyond just writing code. 🔹 Java Compilation Process A Java program written in high-level language is first compiled using the Java Compiler (javac) which converts it into bytecode (.class files). If a file contains multiple classes, the compiler generates separate class files for each class. 🔹 Program Execution in JVM When we run a Java program: 1️⃣ The JVM loads the class containing the main method. 2️⃣ The bytecode is converted into machine-level instructions. 3️⃣ The program is executed inside the Java Runtime Environment (JRE). 🔹 Memory Structure in Java (JRE) During execution, the program uses different memory areas: • Code Segment – Stores compiled bytecode • Stack Segment – Stores method stack frames • Heap Segment – Stores objects created using new • Static Segment – Stores static variables 🔹 Role of Class Loader The Class Loader dynamically loads classes into memory when they are required during program execution. 🔹 Static vs Instance Concept • Static elements → belong to the class • Instance elements → belong to objects This concept explains why static methods can be accessed without creating an object, while instance methods require object creation. 💡 Key Insight: Understanding how JVM, class loading, memory segments, and object creation work internally helps in writing better and more optimized Java programs. Excited to keep exploring deeper concepts in Core Java and Object-Oriented Programming. #Java #JVM #Programming #OOP #SoftwareDevelopment #LearningJourney #JavaDeveloper TAP Academy

While learning Java, I realized something important: 👉 Writing code is easy 👉 Handling failures correctly is what makes you a good developer So here’s my structured understanding of Exception Handling in Java 👇Java Exception Handling — the part most tutorials rush through. If you're writing Java and your only strategy is wrapping everything in a try-catch(Exception e) and hoping for the best, this is for you. A few things worth understanding properly: 1. Checked vs Unchecked isn't just trivia Checked exceptions (IOException, SQLException) are compile-time enforced — the language is telling you these failure modes are expected and you must plan for them. Unchecked exceptions (RuntimeException and its subclasses) signal programming bugs — they shouldn't be caught and hidden, they should be fixed. 2. finally is a contract, not a suggestion That block runs regardless of what happens. Use it for resource cleanup. Better yet, use try-with-resources in modern Java — it handles it automatically. 3. Rethrowing vs Ducking "Ducking" means declaring throws on a method and letting the caller deal with it. Rethrowing means catching it, maybe wrapping it with more context, and throwing again. Know when each makes sense. 4. Custom exceptions add clarity A PaymentDeclinedException tells the next developer (and your logs) far more than a generic RuntimeException with a message string. The image attached gives a clean visual overview — bookmarking it might save you a Google search or two. TAP Academy kshitij kenganavar What's your go-to rule for exception handling in production systems? #Java #SoftwareDevelopment #CleanCode #JavaDeveloper #BackendEngineering #TechEducation #100DaysOfCode