Java OOP Clarity: Printing Objects & References

Day8 🚀: Variables & Memory Structure in Java Today’s learning was about what is variable and Types of variables and how Java uses RAM when a program executes. and how program execution works in java This helped me understand what happens behind the scenes when we run a Java program. A variable is a container that stores data values. In Java, every variable must be declared with a specific data type. 🔹 Syntax: data Type variable Name = value; 🔹 Example: int age = 21; double salary = 25000.50; char grade = 'A'; String name = "Theja"; 🔹 Types of Variables Covered 1️⃣ Local Variables *Declared inside methods *Stored in Stack memory *Created when method starts and destroyed when method ends 2️⃣ Instance Variables *Declared inside a class but outside methods *Stored in Heap memory *Each object has its own separate copy 🔹 How Java Uses RAM During Execution When we run a Java program, memory is divided into different segments: 🧠 1. Code Segment °Stores the compiled bytecode °Contains the program instructions 🧠 2. Static Segment °Stores static variables °Memory is allocated only once 🧠 3. Stack Segment °Stores local variables °Stores method calls °Works in LIFO (Last In First Out) order 🧠 4. Heap Segment °Stores objects and instance variables °Managed by Garbage Collector 🔹 How Program Execution Works in Java 1️⃣ Code is written and compiled into bytecode 2️⃣ JVM loads the class into memory 3️⃣ main() method is pushed into Stack 4️⃣ Objects are created in Heap 5️⃣ Variables are allocated memory 6️⃣ After execution, unused objects are removed by Garbage Collector 🔹 What I Understood Today Understanding variables is not enough. Knowing where they are stored in memory and how Java manages RAM gives deeper clarity about performance and program behavior. Learning how Java works internally is making my foundation stronger 💻🔥 #Java #MemoryManagement #JVM #Programming #LearningJourney #Day8

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

DAY 11: CORE JAVA 🔹 Understanding Variables in Java & Memory Allocation in JRE While learning Java, one concept that truly strengthened my foundation is understanding how variables work and how memory is allocated inside the JRE. 📌 Types of Variables in Java: 1️⃣ Local Variables Declared inside methods, constructors, or blocks Stored in Stack Memory Exist only during method execution 2️⃣ Instance Variables Declared inside a class but outside methods Stored in Heap Memory Each object gets its own copy 🧠 How Memory is Allocated in JRE When a Java program runs, memory is divided mainly into: 🔹 Stack Memory Stores method calls, local variables Works in LIFO (Last In First Out) order Automatically cleared after method execution 🔹 Heap Memory Stores objects and instance variables Managed by Garbage Collector Objects remain until no longer reference 💡 Why This Matters Understanding memory allocation helps in: ✔ Writing optimized code ✔ Avoiding memory leaks ✔ Understanding stack overflow errors ✔ Building strong OOP fundamentals Learning these internal concepts makes Java much more logical and structured rather than just syntax-based coding. TAP Academy #Java #Programming #OOP #LearningJourney #SoftwareDevelopment #CoreJava

𝗦𝗧𝗔𝗖𝗞 𝘃𝘀 𝗛𝗘𝗔𝗣 𝗶𝘀𝗻’𝘁 𝗷𝘂𝘀𝘁 𝘁𝗵𝗲𝗼𝗿𝘆. It’s the difference between confusion and clarity when debugging Java. 𝗪𝗲𝗹𝗰𝗼𝗺𝗲 𝘁𝗼 𝗝𝗮𝘃𝗮 𝗕𝗲𝗴𝗶𝗻𝗻𝗲𝗿 𝗦𝗲𝗿𝗶𝗲𝘀 🚀 𝗣𝗮𝗿𝘁 𝟭 → 𝗣𝗿𝗶𝗺𝗶𝘁𝗶𝘃𝗲 𝗧𝘆𝗽𝗲𝘀 𝗣𝗮𝗿𝘁 𝟮 → 𝗥𝗲𝗳𝗲𝗿𝗲𝗻𝗰𝗲 𝗧𝘆𝗽𝗲𝘀 If you truly understand how Stack and Heap work, debugging becomes dramatically easier. ⚠️ 𝗪𝗵𝘆? Because most common Java errors happen here. 𝟭️⃣ 𝗡𝘂𝗹𝗹𝗣𝗼𝗶𝗻𝘁𝗲𝗿𝗘𝘅𝗰𝗲𝗽𝘁𝗶𝗼𝗻 This happens when: You try to use a 𝘳𝘦𝘧𝘦𝘳𝘦𝘯𝘤𝘦 stored in the 𝗦𝘁𝗮𝗰𝗸 that points to 𝗻𝗼𝘁𝗵𝗶𝗻𝗴 𝗶𝗻 𝘁𝗵𝗲 𝗛𝗲𝗮𝗽. In simple words: The variable exists. The object doesn’t. That’s when Java throws: 𝗡𝘂𝗹𝗹𝗣𝗼𝗶𝗻𝘁𝗲𝗿𝗘𝘅𝗰𝗲𝗽𝘁𝗶𝗼𝗻 𝟮️⃣ 𝗠𝗲𝗺𝗼𝗿𝘆 𝗟𝗲𝗮𝗸𝘀 This happens when: You forget to clear references. The object stays in the 𝗛𝗲𝗮𝗽 because the Garbage Collector thinks you’re still using it. Result? Memory slowly fills up. 🔥 𝗦𝗼 𝗪𝗵𝘆 𝗗𝗼𝗲𝘀 𝗧𝗵𝗶𝘀 𝗠𝗮𝗸𝗲 𝗗𝗲𝗯𝘂𝗴𝗴𝗶𝗻𝗴 “𝟭𝟬𝘅 𝗘𝗮𝘀𝗶𝗲𝗿”? Because when you understand:  • 𝗪𝗵𝗲𝗿𝗲 𝘃𝗮𝗹𝘂𝗲𝘀 𝗮𝗿𝗲 𝘀𝘁𝗼𝗿𝗲𝗱  • 𝗪𝗵𝗲𝗿𝗲 𝗼𝗯𝗷𝗲𝗰𝘁𝘀 𝗮𝗿𝗲 𝗰𝗿𝗲𝗮𝘁𝗲𝗱  • 𝗛𝗼𝘄 𝗿𝗲𝗳𝗲𝗿𝗲𝗻𝗰𝗲𝘀 𝗯𝗲𝗵𝗮𝘃𝗲 You stop guessing. You start reasoning. And debugging becomes logical instead of frustrating. 𝗣𝗿𝗶𝗺𝗶𝘁𝗶𝘃𝗲 → 𝘷𝘢𝘭𝘶𝘦 𝘴𝘵𝘰𝘳𝘦𝘥 𝘥𝘪𝘳𝘦𝘤𝘵𝘭𝘺 𝘪𝘯 𝘚𝘵𝘢𝘤𝘬 𝗢𝗯𝗷𝗲𝗰𝘁 → 𝘳𝘦𝘧𝘦𝘳𝘦𝘯𝘤𝘦 𝘪𝘯 𝘚𝘵𝘢𝘤𝘬, 𝘰𝘣𝘫𝘦𝘤𝘵 𝘪𝘯 𝘏𝘦𝘢𝘱 Once this clicks, OOP makes much more sense. 𝗝𝗮𝘃𝗮 𝗕𝗲𝗴𝗶𝗻𝗻𝗲𝗿 𝗦𝗲𝗿𝗶𝗲𝘀 🚀 Part 1 → Primitive Types Part 2 → Reference Types Next: Variables & Memory Deep Dive 💬 What confused you more at first - Stack or Heap? 🔖 Save this for revision 🔁 Share with someone learning Java 🔥 Hashtags #Java #JavaBeginner #JavaDeveloper #Programming #SoftwareEngineering #BackendDevelopment #LearnJava #ComputerScience #Developers

🚀 Day 8 — Restarting My Java Journey with Consistency Today’s topic looked familiar: 🔹 while loop 🔹 do-while loop 🔹 for loop 🔹 break & continue Most of this was already known to me. But revision with depth always reveals something new. 🔁 Loops — More Than Just Repetition We often write: for(int i = 0; i < n; i++) { // code } But today I revisited some important insights: ✔ All three parts in a for loop are optional ✔ Multiple variables can be initialized using comma separation ✔ Conditional statements rely completely on logical operators ✔ do-while is very useful in menu-driven programs (runs at least once) 🤯 Interesting Question Why don’t we usually use short instead of int in loops? Because in Java, due to type promotion, short gets promoted to int during arithmetic operations. So practically, using short in loops doesn’t provide any benefit. That’s not syntax knowledge. That’s understanding how Java works internally. 🆕 The New Concept I Learned — Labels in Java This was something I had never used before. outer: for(int i = 1; i <= 10; i++) { inner: for(int j = 1; j <= i; j++) { break outer; // breaks the outer loop directly } } 🔹 Labels allow us to control outer loops from inside inner loops 🔹 Useful in nested loop scenarios 🔹 Makes flow control very powerful (if used wisely) Learning daily with Coder Army and Aditya Tandon Bhaiya and Rohit Negi Bhaiya #Day8 #Java #Consistency #BackendDevelopment #LearningJourney #SoftwareEngineering #CoderArmy

Day 6 | Full Stack Development with Java Today’s learning made me realize how important data conversion is while working with Java programs. I explored Type Casting — a concept that controls how data moves between different data types. What is Type Casting? Type casting is the process of converting one data type into another. In Java, this becomes important because Java is a strongly typed language. Two Types of Type Casting I Learned Today: Implicit Casting (Widening) – Automatic Happens when converting a smaller data type to a larger one. No data loss occurs. Example flow: byte → short → int → long → float → double The compiler handles it automatically. Explicit Casting (Narrowing) – Manual Used when converting a larger data type into a smaller one. Requires programmer intervention. Syntax example: byte b = (byte) a; May cause loss of precision, so it must be used carefully. Realization of the Day Understanding type casting helped me see how Java manages memory and prevents unexpected behavior during calculations. Even a small conversion can change program output — which shows why fundamentals matter so much in backend development. Learning step by step and connecting theory with real code is making this journey more interesting every day. #Day6 #Java #TypeCasting #FullStackDevelopment #LearningInPublic #ProgrammingJourney #SoftwareDevelopment

Day 2 of Learning Java & Now I Know What Happens Behind the Scenes 👀 Yesterday was about why Java exists. Today was about how Java actually works. And honestly… this is where things got interesting. When we write Java code, it doesn’t directly talk to the computer. Here’s the real flow: .java → javac → .class (Bytecode) → JVM → Machine Code → CPU The magic? ✨ That bytecode is platform independent. And who handles everything? 👉 JVM – The Heart of Java Inside JVM: • Interpreter converts bytecode line-by-line • JIT (Just-In-Time Compiler) compiles frequently used code into native machine code • Garbage Collector manages memory • Security sandbox keeps execution safe This is why Java is called Hybrid It’s both compiled AND interpreted. Now the hierarchy finally makes sense: JVM → Runs bytecode JRE → JVM + Libraries (to run programs) JDK → JRE + Tools (to develop programs) In simple words: Want to run Java? → JRE Want to build Java? → JDK Day 2 and things are already connecting deeper. Not just learning syntax but understanding actual architecture. Foundation > Frameworks 🔥 Special thanks to Aditya Tandon Sir & Rohit Negi Sir 🙌 #Java #CoreJava #BackendDevelopment #LearningJourney #Developers #BuildInPublic

Many developers believe that Java is a fully Object-Oriented Programming (OOP) language, but it technically falls short of being pure OOP. A pure OOP language treats everything as an object, as seen in languages like Smalltalk. Java does support core OOP principles, including: ✔ Encapsulation ✔ Inheritance ✔ Polymorphism ✔ Abstraction However, it does not achieve purity for two main reasons: 🔴 1. Primitive Data Types Exist Java includes primitive types like "int," "char," "boolean," and "float," which are not objects. In pure OOP languages, even numbers are treated as objects. Example: int a = 5; // Not an object 🔴 2. Static Members Break Object Dependency Static methods and variables can be accessed without creating objects, which contradicts the strict OOP philosophy. 🔴 3. Wrapper Classes Don’t Truly Fix It Using wrapper classes like "Integer" instead of "int" still involves internal conversion to primitives (autoboxing/unboxing). Example: Integer x = 10; Integer y = 20; Integer z = x + y; // internally uses primitive int In conclusion, while Java is Object-Oriented, it is not Pure Object-Oriented, as not everything is treated as an object. Understanding this distinction can deepen your insights into language design, memory efficiency, and performance trade-offs. #Java #OOP #Programming #SoftwareDevelopment #ComputerScience for more info please visit GeeksforGeeks

Most people think learning Java is about syntax. It’s not. Java is really about 𝗵𝗼𝘄 𝘆𝗼𝘂 𝘁𝗵𝗶𝗻𝗸 when you write code. Early on, I treated Java like a checklist: • Learn variables • Learn loops • Learn classes • Move on But that approach creates fragile developers. What actually matters is understanding 𝘄𝗵𝘆 𝗝𝗮𝘃𝗮 𝗳𝗼𝗿𝗰𝗲𝘀 𝘀𝘁𝗿𝘂𝗰𝘁𝘂𝗿𝗲 : • Why everything lives inside a class • Why types are strict • Why compilation errors exist before runtime Java doesn’t try to be convenient. It tries to be 𝗽𝗿𝗲𝗱𝗶𝗰𝘁𝗮𝗯𝗹𝗲, 𝗿𝗲𝗮𝗱𝗮𝗯𝗹𝗲, 𝗮𝗻𝗱 𝘀𝗮𝗳𝗲 𝗮𝘁 𝘀𝗰𝗮𝗹𝗲. That’s uncomfortable at first — and that’s the point. Today was about setting the foundation: • Understanding how Java programs actually run • Why JVM exists • Why Java looks “verbose” compared to other languages This isn’t about speed. This is about building discipline that compounds over time. Consistency > shortcuts. Clarity > cleverness. I’m building this habit one step at a time. #Java #100DaysOfCode #SoftwareEngineering #Programming #DeveloperJourney #LearningInPublic

🚀 Day 12 – Core Java TAP Academy | Variables (Instance vs Local) 💻🔥 Today’s Core Java session was a super important foundation topic: VARIABLES ✅ Not just “variables store data” — we went deeper into how Java stores them in memory and what happens inside RAM while executing a program 🧠⚙️ 📌 What is a Variable? A variable is like a container that stores data 🧺 In Java, variables help us store values, access them, and manipulate them during program execution. 🔥 Types of Variables Covered Today 1️⃣ Instance Variables (Class Level) 🏛️ ✅ Declared directly inside a class ✅ Memory allocated in Heap (inside Object) 🧱 ✅ Java automatically assigns Default Values 🎯 📌 Default values examples: int → 0 float → 0.0f boolean → false char → empty character ('\u0000') (not space ❗) 2️⃣ Local Variables (Method Level) 🧩 ✅ Declared inside a method (like main) ✅ Memory allocated in Stack 📚 ❌ Java will NOT assign default values ⚠️ If you try to print without initializing → Compilation Error ❌ 👉 So we must initialize local variables manually before using them ✅ 🧠 Key Takeaway Understanding variables with memory layout (Stack vs Heap) is a game-changer 💡 It helps us debug better, write clean code, and think like a real developer — not just copy-paste from AI 🤖➡️👨💻 ✅ Consistent Learning + Daily LinkedIn Posting = Growth 📈✨ On to the next day with more Java concepts! 🚀🔥 Trainer:Sharath R #CoreJava #Java #TapAcademy #Variables #InstanceVariable #LocalVariable #JVM #Stack #Heap #Programming #JavaDeveloper #LearningJourney #TechSkills #PlacementPreparation #InterviewPrep #DailyLearning 🚀💻