Java Static Keyword Clarified: Misconceptions and Facts

🚀 Understanding Instance Variables vs Local Variables in Java This visual breaks down one of the most important yet confusing concepts in Core Java: 🔹 Instance Variables Declared inside a class, outside methods Stored in Heap Memory Created when the object is created JVM automatically assigns default values (0, null, false, etc.) Object reference is stored in the Stack, while the object lives in the Heap 🔹 Local Variables Declared inside methods or blocks Stored in Stack Memory JVM does NOT provide default values Must be explicitly initialized before use Scope is limited to the method/block 📌 Key Takeaway: If you don’t understand where your variables live in memory, you’re just writing code — not engineering solutions. Mastering memory concepts = stronger fundamentals + better interviews + cleaner code 🔥 #Java #CoreJava #JVM #JavaMemory #InstanceVariables #LocalVariables #ProgrammingConcepts #LearnJava #DeveloperMindset #TAP Academy

Understanding Global Variables in Java 🌐: Unlock the power of variables that live throughout your program! Learn how they simplify data sharing across methods while keeping your code clean and efficient. #JavaProgramming #CodingTips #LearnJava #GlobalVariables #DeveloperLife #SoftwareEngineering"

Understanding Java String & Garbage Collection 🧠☕ String objects created using String literals are stored in the String Constant Pool and are not eligible for Garbage Collection, even after setting the reference to null. This example clearly shows why the same hashCode() is returned and how Java optimizes memory using immutability and pooling. 📌 Key concepts: ✔ String Pool ✔ Immutability ✔ Garbage Collection ✔ hashCode() Java String + GC explained with a simple example 🚀 Even after calling System.gc(), String literals are not removed because they live in the String Pool. Same content ➝ same hashCode() ➝ same object reference. Learning Java step by step ☕📘 #Java #CoreJava #JavaInterview #GarbageCollection #StringPool #LearningJava #OOPs

Advanced Java – Day 1 Day 1 was less about “advanced” stuff and more about getting into the core •Revisited the basics that actually matter: •How Java works internally (source code ➡️ bytecode ➡️JVM) •Why Java is platform independent •Difference between JDK, JRE, and JVM •Primitive vs non-primitive data types •Core OOP concepts like class, object, encapsulation, abstraction, and polymorphism •How memory works (stack, heap, static, string pool) I also practised these concepts by building a simple calculator program to understand how logic, methods, and objects actually come together and a constrain based if-else problem. Seeing it run made things clearer. Looking forward to learning more step by step. #Java #LearningInPublic #AdvancedJava #ProgrammingBasics #StudentLife #Consistency

Today, I learned about one of the most important parts of a Java program — the main() method, which is the entry point of execution in Java. 🔹 Key learnings : public → Makes the method accessible to the JVM static → Allows JVM to call main() without creating an object void → Specifies that the method returns no value String[] args → Used to accept command-line arguments Code inside the method body {} is executed first by the JVM I also wrote my first Java program and successfully printed output using System.out.println() 🎉 Understanding the structure of the main() method is a crucial step toward building a strong foundation in Core Java. #Java #CoreJava #JavaProgramming #LearnJava #JavaBasics #JVM #CodingJourney #ProgrammingLife #SoftwareDevelopment #DeveloperLife #ProgrammingFundamentals #TechLearning

Java☕ — Interface vs Abstract Class finally clicked 💡 For a long time, I used them randomly. If code compiled, I thought it was correct. Then I learned the real difference 👇 📝Interface = what a class CAN do 📝Abstract class = what a class IS #Java_Code interface Flyable { void fly(); } abstract class Bird { abstract void eat(); } A plane can fly — but it’s not a bird. That single thought cleared everything for me. Use interface when: ✅Multiple inheritance needed ✅Behavior matters ✅You’re defining a contract Use abstract class when: ✅You share base state ✅You provide common logic ✅Relationship is strong Understanding this saved me from messy designs. #Java #Interface #AbstractClass #OOP #LearningJava

🔹 Java String Immutability — Explained Simply Understanding why String is immutable in Java helps you write safer, more efficient, and more reliable code. 📌 What this visual covers: 🔒 Security — prevents unintended data changes ⚡ Performance — enables String Constant Pool reuse 🧵 Thread-safety — safe to share across threads 🧠 Memory behavior — how new objects are created Strong fundamentals lead to better software design and cleaner codebases. 💬 What Java concept do you think every developer should master? #Java #CoreJava #Programming #SoftwareEngineering #JavaDevelopers #TechEducation #JavaProgramming #LearnJava #JavaString

🚀 Day 29 | #100Days100ProgrammingChallenge #Language: Java * Concept: Sorting Algorithm – Selection Sort #Today, I implemented Selection Sort using Java 🧑💻✨ #What the program does: * Takes number of elements from the user * Accepts array elements using Scanner * Sorts the array using Selection Sort algorithm * Displays the sorted array in ascending order #Key learnings today: * Better understanding of nested for loops * How Selection Sort works step-by-step * Swapping elements using a temporary variable * Improved logic-building skills #Sample Output: Input : 12 13 22 123 3 Output : 3 12 13 22 123 * Consistency is the key. Moving forward to Day 30 🚀 #Day29 #Java #SelectionSort #DSA #LearningJava #100DaysOfCode #ProgrammingChallenge

Behind the scenes: How Java objects are created:- What happens step by step inside the JVM: The Java source code is compiled and .class files are generated. When the program runs, Animal.class and AnimalMain.class are loaded into the Method Area (Metaspace). A java.lang.Class object is created in the Heap, which holds runtime metadata of the class. JVM creates the main thread and its stack. When, new Animal() is executed: Memory is allocated in the Heap Area. All instance variables are initialized with default values (age = 0, legs = 0). The constructor is executed. A reference to the newly created object is returned. This reference is stored in the stack variable buzo. Note:- Heap → stores objects Stack → stores references and method frames Method Area / Metaspace → stores class metadata Important: ->The reference variable does not store the actual object or a memory address. ->HashCode is generated only when hashCode() is called, not during object creation. Learning Java internals makes concepts much clearer. #Java #JVM #CoreJava #ObjectOrientedProgramming #ComputerScience #objects

Understanding Execution Flow and Constructors in Java Today I explored how Java executes static blocks, instance blocks, and constructors when objects are created. Key concepts I practiced: 1--> Static Block Runs only once when the class is loaded. It always prints before anything else in the class. 2--> Instance Block Executes every time an object is created, and it runs before the constructor. Useful when multiple constructors share common initialization logic. 3--> Default & Parameterized Constructors The default constructor initializes objects without arguments The parameterized constructor allows passing custom values By printing messages in each block, I clearly understood Java’s execution order: -->Static block -->Static method -->Instance block -->Constructor -->Other methods Attaching the console output below for clarity. Thanks Prasoon Bidua Sir for the guidance and support in understanding core fundamentals. #Java #Constructors #OOP #ExecutionFlow #CoreJava #LearningInPublic