Understanding Shallow vs Deep Copy in Programming

💡 Call by Value vs. Call by Reference: How Data is Passed in Programming 🤝 Understanding how functions/methods receive arguments is critical for predicting a program's behavior, especially when dealing with data manipulation. The two main ways to pass arguments are: 1. Call by Value (Copying the Data) What it does: A copy of the argument's actual value is passed to the method. Result: Changes made to the parameter inside the method do not affect the original variable outside the method. In Java: All primitive types (int, char, boolean, etc.) are always passed by Call by Value. 2. Call by Reference (Passing the Memory Address) What it does: The actual memory address (or a reference to the data) is passed to the method. Result: Changes made to the object inside the method will affect the original object outside the method. The key takeaway for Java: When you pass an object to a method, you're passing a copy of the reference (Call by Value), but since that copy points to the original object in memory, the method can modify the object's content (e.g., changing a value in an array or a field in an object). You just can't make the original reference variable point to an entirely new object outside the method. Mastering this distinction is key to debugging subtle data-related bugs! Thank you sir Anand Kumar Buddarapu,Saketh Kallepu,Uppugundla Sairam,Codegnan #Java #Programming #CodingFundamentals #SoftwareDevelopment #Codegnan

🔹Static and Non-Static 🔹 Static The static keyword in programming is used to define class-level members (variables, methods, or blocks) that are common to all objects of that class. A static member belongs to the class itself, not to any specific object (instance). Static members are loaded into memory only once, when the class is first loaded. This helps in saving memory and improving performance. Since static members belong to the class, they can be accessed without creating an object of that class. Static members are generally used when a particular property or method needs to be shared among all objects, for example: a counter, constants, or utility methods. Static methods cannot directly access non-static members, because non-static members belong to individual objects, and static methods do not have any object reference. Static members exist independently of objects, meaning they remain in memory until the class is unloaded. 🔹 Non-Static Non-static members are also known as instance members because they belong to a specific instance (object) of the class. Each time a new object is created, a separate copy of all non-static members is created in memory for that object. Non-static members can only be accessed through objects of the class. Non-static members can access both static and non-static members of the class. Non-static members are used when each object should have its own unique data or behavior. Memory for non-static members is allocated when an object is created and released when the object is destroyed. Non-static methods can use this keyword to refer to the current object, while static methods cannot use 🔹 Summary Static members are class-level and common to all instances. Non-static members are instance-level and unique to each object. Static members improve memory efficiency and are ideal for shared data, while non-static members represent individual object behavior. #Java #JavaFullStack #Programming #Static and Non-Static #Codegnan Anand Kumar Buddarapu Uppugundla Sairam Saketh Kallepu

🎯 Difference Between Static and Non-Static Methods in Java In Java, understanding the difference between static and non-static methods is very important . 💡 Static Methods: Declared using the static keyword. Belong to the class, not to any specific object. Can be called directly using the class name. Cannot access non-static (instance) variables or methods directly. ⚙️ Non-Static Methods: Do not use the static keyword. Belong to an object of the class. Can access both static and non-static members. Need an object to be called. ✨ In short: Use static when behavior is common to all objects, and non-static when behavior depends on each object’s data. 🙌 Special Thanks to my mentors Anand Kumar Buddarapu and the team at Codegnan Institute for guiding me through these core Java concepts. #Java #Programming #Learning #Codegnan #StaticVsNonStatic #JavaConcepts #OOPs

Method,Brief Explanation for Beginners **equals(Object obj)**,"Used to check if two objects are logically equal (by default, it just checks if they are the same object)."🎯🌐💻 **hashCode()**,"Returns a unique integer hash code for an object, mainly used in collection classes like HashMap and HashSet."💡🎯🌐 **toString()**,Provides a string representation of the object (often overridden to give meaningful details).💡🎯🌐😇 **getClass()**,Returns the runtime class of this object (the Class object). **clone()**,Creates and returns a copy of this object. Requires the class to implement the Cloneable interface.😇🤩✔️ **notify()**,Wakes up a single waiting thread on this object's monitor. Used for inter-thread communication.😇🌐🎯 **notifyAll()**,Wakes up all waiting threads on this object's monitor. Used for inter-thread communication.✔️💡💻 **wait()**,Causes the current thread to wait until another thread invokes notify() or notifyAll().✔️💡💻🌐 **finalize()**,"Called by the garbage collector on an object when it determines there are no more references to the object (rarely used now, and its usage is generally discouraged)."✔️💡💻✨🤩.. Thank you sir Anand Kumar Buddarapu sir Saketh Kallepu sir, Uppugundla Sairam Sir,💻✨🤩✔️🌐🎯 Codegnan #120DaysOfCode #Java #Programming #CodingChallenge #Polymorphism #objectclass #OOP #SoftwareDevelopment

Reversing a string is one of the fundamental exercises in programming that strengthens logical thinking and understanding of loops and string operations. This program demonstrates how to reverse a string in Java using a for loop and character concatenation without using any inbuilt methods like append() or reverse(). 📌💻🌐Logic Behind the Program: 1 Take a string input from the user. 2 Initialize an empty string variable, rev = "". 3 Use a for loop to iterate from the last character of the string to the first. 4 In each iteration, concatenate the character to rev using: + rev = rev + name.charAt(i); 5 Once the loop completes, print the reversed string stored in rev. Key Concepts Demonstrated: Using loops to traverse characters in reverse order. Applying string concatenation to form a new string. Avoiding built-in methods to understand the core logic clearly. Strengthening the concept of string immutability in Java. Enhancing problem-solving skills and control flow understanding. Key Takeaway: Reversing a string using rev = rev + name.charAt(i) provides a clear view of how loops, indices, and string concatenation work together. It's a simple yet powerful logic that builds a strong foundation for mastering string manipulation in Java. Special thanks to our mentor Anand Kumar Buddarapu Sir for his constant guidance and concept clarity. Thanks to Saketh Kallepu Sir, Uppugundla Sairam Sir, and the entire Codegnan Team for their continuous motivation and support. #Java #StringReversal #Codegnan #FullStackDevelopment #Learning Journey #Loops #StringManipulation #Programming #LogicBuilding

🔥Python prioritizes developer speed & flexibility, while Java prioritizes code safety and clarity. Python: Dynamic & Flexible Offers flexibility and speed for prototyping and scripting, with less code. Java: Static & Safe Provides type safety, catching errors early at compile time. This makes code more robust & easier for tools to support. Connect Sabari Balaji for Tech Insights 💡

Reflecting on a fundamental concept today: the journey from struct in C to class in Java! 💡 I was thinking about how C's struct allowed us to group related data, providing a powerful way to organize information. But then, the jump to class in Java introduced a revolutionary idea: not just grouping data, but also encapsulating the functions (methods) that operate on that data. This isn't just about syntax; it's a paradigm shift. Classes enable us to model real-world entities much more closely, where data and its behavior are inherently linked. It brings us closer to the principles of Object-Oriented Programming, promoting better organization, reusability, and maintainability in our code. It's a beautiful evolution in how we think about and structure our programs. What are your thoughts on this progression? #Programming #C #Java #OOP #SoftwareDevelopment #Structs #Classes #Tech Here's an image that visualizes this concept generated by Gemini :

💬 Day 6 of My Journey to Learning Java ☕ Today’s focus was on making my programs more interactive and logical — learning how to take user input, perform calculations, and use operators effectively. Here’s what I explored 👇 🔹 Basic I/O in Java: Learned how to use the Scanner class to take input from users. Example: import java.util.Scanner; Scanner sc = new Scanner(System.in); int num = sc.nextInt(); It’s amazing how a few lines can make a program feel alive — accepting input and responding dynamically. 🔹 Arithmetic & Unary Operators: Practiced how operators control the logic of calculations: Arithmetic Operators: +, -, *, /, % — used for performing basic mathematical operations. Unary Operators: ++ and -- — used to increase or decrease a value by 1. Example: int a = 5; System.out.println(++a); // Pre-increment → 6 System.out.println(a++); // Post-increment → 6, then becomes 7 🔹 Hands-On Practice: Solved small but powerful problems today 💡 ✔️ Swapping two numbers without a third variable ✔️ Calculating Simple Interest ✔️ Practiced several MCQs to strengthen fundamentals 💡 Reflection: Today’s practice helped me connect syntax with problem-solving. Writing code that actually takes input, performs logic, and returns output — that’s when programming starts to feel real. #Java #JavaLearning #ProgrammingJourney #100DaysOfCode #CodeEveryday #LearnInPublic #DeveloperInMaking #BackendDevelopment #JavaDeveloper

✅ Day 116: Weighted Job Scheduling Today’s #nationskillup challenge was a powerful Dynamic Programming + Greedy + Sorting problem 💼 — focused on finding the maximum profit from non-overlapping jobs. ⚡ Problem Statement: Given n jobs where each job has a start time, end time, and profit, find the maximum profit you can earn by scheduling non-overlapping jobs. 🧠 Example: Input: jobs[][] = [[1, 2, 50], [3, 5, 20], [6, 19, 100], [2, 100, 200]] Output: 250 Explanation: The first and fourth jobs (time ranges [1, 2] and [2, 100]) can be selected for a total profit of 50 + 200 = 250. 💡 Approach Summary: 1️⃣ Sort all jobs by their start time. 2️⃣ Use a Priority Queue (Min-Heap) to efficiently track jobs by their end times. 3️⃣ For each job: Remove all jobs that end before the current job’s start time and update the maximum profit. Add the current job with its cumulative profit to the heap. 4️⃣ The maximum profit is the best value found after processing all jobs. 🔹 Time Complexity: O(n log n) 🔹 Space Complexity: O(n) 🧩 Key Idea: Dynamic Programming with overlapping intervals can be optimized using sorting and heaps — giving an elegant mix of efficiency and clarity! 🤝 Thanks to GeeksforGeeks and Sandeep Jain Sir for another amazing problem that reinforces DP fundamentals! 🙌 Shoutout to Tarun Seshank Gorisi for keeping the #nationskillup journey motivating every day 🚀 📚 Course Link: https://lnkd.in/gG3G2QFW #skillupwithgfg #nationskillup #DSA #Java #DynamicProgramming #GreedyAlgorithm #GeeksforGeeks #CodingChallenge #CodeEveryday

📐 Java Hypotenuse Calculator – Quick Geometry in Action! Built a simple yet efficient Java console application that calculates the hypotenuse of a right-angled triangle using the Pythagorean theorem. This project helped me practice user input handling, mathematical operations, and output formatting in Java. ⚙️ Features: • Accepts side lengths A and B as user input • Calculates the hypotenuse C using Math.sqrt() and Math.pow() • Displays the result with two-decimal precision 🧠 Concepts used: Scanner class, Java Math library, and basic geometry 🔧 Tools in use: Java SE, IntelliJ IDEA / VS Code 🎯 Goal: Strengthen Java fundamentals while applying mathematical logic to real-world problems GitHub: https://lnkd.in/dUJEkMPg #JavaDevelopment #JavaProjects #ConsoleApplication #SoftwareEngineering #CodingProjects #Programming #LearningByDoing #BeginnerProjects #CodeNewbie #DeveloperJourney #ObjectOrientedProgramming #JavaCommunity