CHF -> Variables and Data Types in Java – advanced

Are you done with the Variables and Data Types basics? Then let’s get digging and actually learn some meat about those.

Please note that this is in no way and exhaustive (or even well organised) list on the topic of Variables and Data Types. Those are all the little (and not so little) pieces of info I gathered about the topic since I started working with Java. If you find yourself not aware of any of those, it’s best to google the topic further and really get to know what it’s about.

Who knows, it may actually be something that will help you impress your interviewer and land you that dream job you’ve been thinking about for ages…?

---

Primitives vs. Reference types

In Java, there are two types of data: primitives and reference types. Primitives are basic data types, such as integers, doubles, and booleans, while reference types are more complex data types that include objects and arrays.

When you declare and initialise a primitive variable, you are creating a block of memory that is dedicated to storing that specific value. For example, if you declare and initialise an integer variable with the value 5, Java creates a block of memory that holds the value 5.

On the other hand, when you declare and initialise a reference variable, you are creating a block of memory that holds a reference to an object. This reference points to the actual object that is stored somewhere else in memory.

The potential risk with reference types is that multiple reference variables can point to the same object in memory. If you modify the object using one reference variable, the changes will be visible when you access the object using any other reference variable. This can lead to unexpected behaviour and bugs in your code.

Additionally, it’s important to understand that when you pass a primitive variable as an argument to a method, you are passing a copy of the value stored in memory. However, when you pass a reference variable as an argument, you are passing a copy of the reference to the object, not a copy of the object itself. This means that if you modify the object within the method, those changes will be visible outside of the method.

To avoid potential issues with reference types, it’s important to understand how Java stores and manipulates data, and to be careful when working with reference variables. Make sure to keep track of which variables point to which objects, and to be mindful of potential side effects when modifying objects in your code.

---

Reference types and mutability

Another potential risk with reference types is that if you assign a reference variable to another reference variable, both variables will point to the same object in memory. This can be useful in some cases, such as when you want to modify the same object from multiple places in your code. However, it can also lead to bugs if you inadvertently modify the object using one reference variable and expect the changes to only affect that variable.

To help avoid these issues, it’s important to follow best practices when working with reference types. For example, it’s often a good idea to make sure that your objects are immutable (unchangeable), meaning that their state cannot be changed after they are created. This can help prevent unexpected side effects and make your code more predictable.

Another best practice is to make sure that your objects are properly encapsulated, meaning that their internal state is not directly accessible from outside the object. You can achieve this by using interfaces and access modifiers. This can help prevent accidental modifications and make your code more maintainable in the long run.

---

Reference types and memory leaks

A common issue with reference types is that they can lead to memory leaks if you’re not careful. A memory leak occurs when an object is no longer needed by your program, but it remains in memory because there are still references to it. This can cause your program to use more and more memory over time, eventually leading to performance problems or crashes.

To avoid memory leaks, it’s important to be mindful of the lifecycle of your objects and to make sure that you properly release any references to them when they are no longer needed. This can be tricky, especially in more complex programs, but there are tools available to help you diagnose and fix memory leaks, such as Java profilers.

Reference typed and NullPointerException (NPE)

Another issue to be aware of is the potential for NullPointerExceptions (NPEs) when working with reference types. An NPE occurs when you try to dereference a null reference, meaning a reference that doesn’t point to any object in memory. This can happen if you forget to initialise a reference variable, or if you assign it to null at some point in your code.

To avoid NPEs, it’s important to always check your reference variables for null before dereferencing them. This can be done using the if statement or the ternary operator, for example. It’s also a good idea to use defensive programming techniques, such as null checks and assertions, to catch potential issues early on and make your code more robust.

public String getUserName(long userId) {
    User user = userDTO.getUserById(userId);
    if (user != null) {
        return user.getName();
    } else {
        return "There is no user with ID: " + userId;
    }
}

Java 8 introduced Optionals that help to address the issue of NullPointerExceptions when working with reference types. Optionals are essentially a wrapper around a value that may or may not be null, allowing you to explicitly handle the case where a value is absent.

Instead of directly accessing a reference type variable and potentially triggering an NPE, you can use the Optional class to check whether the value is present or not, and then take appropriate action. This can help to make your code more robust and avoid unexpected errors.

public Optional<String> getUserName(long userId) {
    return Optional.ofNullable(userDTO.getUserById(userId))
                   .map(User::getName);
}

---

Alright, folks, that’s a wrap on our deep dive into Variables and Data Types in Java! I hope you learned something new and exciting that will help you level up your coding game. Remember, understanding how Java handles primitives and reference types is essential for writing efficient and bug-free code. And don’t forget about those Optional types, they can be a real lifesaver when it comes to handling those pesky NullPointerExceptions.

/*
Until next time,
stay curious and keep coding!
eMs
*/