DEV Community: Marcos Gabriel de Oliveira Favaretto

Replacing If-Else Statements with Enums in Java

Marcos Gabriel de Oliveira Favaretto — Sat, 04 Mar 2023 04:43:58 +0000

Introduction

That post shows a simple way of how if-else statements can be changed with enums in Java. On that tutorial, we will use a simple application which was written solely using if-else statements, and remove all of them by creating an enum with constructor.

The example program

The Java program we are going to use for this tutorial is a simple command-line application that returns a HTTP status code after the user provides a required message.

For example, if we execute it with the argument "SUCCESS", then its return is "200".

The old code

Our application is composed of several if-else statements. Therefore, basing on user's message, it is tested on four conditions to define the corresponding HTTP status code and return it to the user.

public class Application {

    public static void main(String[] args) {

        if (args.length < 1) {
            System.out.println("No args provided!");
            System.exit(0);
        }

        String providedMessage = args[0];
        int returnCode = 0;

        if ("SUCCESS".equalsIgnoreCase(providedMessage)) {
            returnCode = 200;
        } else if ("CREATED".equalsIgnoreCase(providedMessage)) {
            returnCode = 201;
        } else if ("MOVED".equalsIgnoreCase(providedMessage)) {
            returnCode = 301;
        } else if ("UNAUTHORIZED".equalsIgnoreCase(providedMessage)) {
            returnCode = 401;
        }

        System.out.println("Your HTTP code is: " + returnCode);
    }
}

Running that Java program:

marcos@Desktop: javac Application.java
marcos@Desktop: java Application success
Your HTTP code is: 200.

The refactored code

To make that possible, we can use a property of java ENUMS: the constructors. Using it, for each value provided for our ENUM, we can define a default return value.

Writing our ENUM

The first change to be done is define our enum class.

enum HttpCode {

    SUCCESS,
    CREATED,
    MOVED,
    UNAUTHORIZED;

}

As much as the class is declared, we are not allowed to use it for replace our if-else statements, since Java will not know the code that needs to be returned after the instantiation of our enum HttpCode.

This can be ajusted very simply, by defining a constructor for HttpCode.

enum HttpCode {

    SUCCESS(200),
    CREATED(201),
    MOVED(301),
    UNAUTHORIZED(401);

    private int code;

    HttpCode(int code) {
        this.code = code;
    }

    public int getCode(){
        return this.code;
    }
}

Notice that a field code was created inside our enum class. Since each options of HttpCode has a default status defined for the contructor, after an instantiation using the method HttpCode.valueOf(String message), one of the default values will be stored at the field code, which can be obtained by the method HttpCode.getCode().

Adjusting the main method

Now that we have an enum class, we just need to change our original main code to use it.

public static void main(String[] args) {

    if (args.length < 1) {
        System.out.println("No args provided!");
        System.exit(0);
    }

    String providedMessage = args[0];
    HttpCode httpStatusCode = HttpCode.valueOf(providedMessage.toUpperCase());

    System.out.println("Your HTTP code is: " + httpStatusCode.getCode());
}

Done! Now, our application can return for user a HTTP status code for a provided message. The following code shows our entire class, already refactored.

public class Application {

    public static void main(String[] args) {

        if (args.length < 1) {
            System.out.println("No args provided!");
            System.exit(0);
        }

        String providedMessage = args[0];
        HttpCode httpStatusCode = HttpCode.valueOf(providedMessage.toUpperCase());

        System.out.println("Your HTTP code is: " + httpStatusCode.getCode());
    }
}

enum HttpCode {

    SUCCESS(200),
    CREATED(201),
    MOVED(301),
    UNAUTHORIZED(401);

    private int code;

    HttpCode(int code) {
        this.code = code;
    }

    public int getCode() {
        return this.code;
    }
}

Running that Java program:

marcos@Desktop: javac Application.java
marcos@Desktop: java Application UNAUTHORIZED
Your HTTP code is: 401.

The first thing we can think on that case is: "Okay, I removed my statements, but I also improved the quantity of lines of my code!". In the truth, it seems that our application is much bigger, but on real cases, that can decrease the quantity of lines, since the ENUM can be reused on another parts of our code.

Also, makes the code more readable, since the if-else structures, with several validations, ceases to exist, and Java starts to do this verification for us.

Another good thing is that we can add more options at enums's class without the need of change at all occurrences of status code validations, giving it only exists in the enum that was created.

Conclusion

This is a simple, and not that much applicable, example. However, it can demonstrate a better way to use enums. It's also important to note: do not change every if-else statement you see without think on consequences. This is an idea of how to do things on other way, every scenario is different, you must check, agreed ;D?

That's all!
Please, leave your suggestions, corrections and tests on comments. Thank you for reading :D.

Strings in Java are immutable, once declared they cannot be changed.

Marcos Gabriel de Oliveira Favaretto — Sat, 21 Jan 2023 18:51:06 +0000

String Pool

Strings in Java are immutable. It means that its value once declared cannot be changed anymore. The String variables just stores references to the String value on Heap memory, and it can be changed, like we used to do during the execution of our program.

When a literal String is declared, it is saved on a specific local of the Heap memory: the String Pool.

To clarify it better, let's declare a new String variable on our Java class.

public class Application {
    public static void main(String[] args) {
        String myFirstString = "Hello";
    }
}

When we declare a String variable and initialize it with the literal way, that is what happen at the memory allocated to our application.

Declaring another String variable using the same literal attribution, another local on String Pool won't be created, since the JVM knows that there already exists a String value declared as Hello.

Code

public class Application {
    public static void main(String[] args) {
        String myFirstString = "Hello";
        String mySecondString = "Hello";
    }
}

If we look at memory:

At the beginning, the String Pool is empty. After declaring the myFirstString, JVM looks inside it and search for the value "Hello". If it still doesn't exist, JVM stores that value and return the address. If already exists, returns the address of the value.

To make sure that myFirstString and mySecondString are appointing to the same local of memory, we can compare them with the == operator, which returns true if they have the same address.

Code

public class Application {
    public static void main(String[] args) {
        String myFirstString = "Hello";
        String mySecondString = "Hello";

        System.out.println("Has same address: " + (myFirstString == mySecondString));
    }
}

Result

Has same address: true

If we change both values, the Hello will not be removed from memory, it just will not have a pointer with its address, and another allocation on String Pool will be created, having the new declared value.

Code

public class Application {
    public static void main(String[] args) {
        String myFirstString = "Hello";
        String mySecondString = "Hello";

        myFirstString = "World";
        mySecondString = "World";

        System.out.println("Has same address: " + (myFirstString == mySecondString));
        System.out.println("Has same address as \"Hello\" value: " + (myFirstString == "Hello"));
    }
}

Result

Has same address: true
Has same address as "Hello" value: false

Memory Representation

There we can see the immutable propriety, since the value stored did not change after an alteration of variables's value attribution, and other local on String Pool was occupied with the new value.

It is important to say that if we declare a String variable with the new keyword, that value will not be created at String Pool, instead of it, will be saved at Heap Space every time a String is declared with the new keyword.

Code

public class Application {
    public static void main(String[] args) {
        String myLiteralString = "Hello";
        String myNewString = new String("Hello");

        System.out.println("Has same address: " + (myLiteralString == myNewString));
    }
}

Result

Has same address: false

Memory Representation

To allocate that value on String Pool, we can manually use the String.intern() method.

Code

public class Application {
    public static void main(String[] args) {
        String myLiteralString = "Hello";
        String myNewString = new String("Hello");

        System.out.println("Has same address: " + (myLiteralString == myNewString));

        myNewString = myNewString.intern();
        System.out.println("Has same address after intern: " + (myLiteralString == myNewString));
    }
}

Result

Has same address: false
Has same address after intern: true

Memory Representation

Advantages

The use of String Pool improves the performance of our application, since it works as a cache, allowing the JVM to also spend less memory.
Allows reusability of String values.
Allows more security for Strings that cannot be change during the execution of our project (like passwords).

Disadvantages

Every time a String is changed, another value will be allocated in memory, and the old value will be still existing, using unnecessary space. When working with some String variable that changes a lot, that can be a memory problem.

It is possible to use Strings on a mutable way through Java StringBuilders. Using that resource, the String value will not be stored on String Pool and the allocated value will be changed at the same address, not being reallocated.

Of course, we can have some cases that Immutable Strings cannot solve our problem, and be a problem of performance. You need to understand your case for the best application.

That topic about String Pool is based on Scaler, Baeldung, Coding with John and Vogella.

That's all ;D
Please any feedbacks, improvements or revisions are welcome.

Functional Interfaces: a simpler way to use interfaces in Java.

Marcos Gabriel de Oliveira Favaretto — Sat, 14 Jan 2023 20:51:25 +0000

Functional Interfaces

Functional Interfaces are simple Interfaces with only one abstract method. The big thing to use then is for implement its behavier without create another class for it or even need of Anonymous Classes, which can reduce the number of lines of your code and make it more easily to read.

Every Interface with has only one abstract method is a Funcional Interface. However, use the @FunctionalInterface Annotation at the Interface's declaration is a good practice, since that one makes the Java Compiler throws an error in case the annotated Interface has more than one abstract method or if its type isn't an interface.

Another indirect advantage of using that type of implementations is the support of Streams with parallel operations which can improve our software performance.

Use example.

Let's create a simple example. Like said before, an Interface can be a Functional Interface if it has only one abstract method. With it on mind, the Interface MyFuncionalInterface has the following code:

@FunctionalInterface // Makes the compiler throws an error.
interface MyFuncionalInterface {
    public double calculate(double num1, double num2);
}

To implement that calculate method, we can create a new class or use an Anonymous Class, like usual. However, because it is a functional interface, we can implement the method by using Lambdas.

The following snippet of code shows two implementations: using Anonymous Class and using Lambdas.

class Application {
    public static void main(String args[]) {

        double num1 = Double.valueOf(args[0]);
        double num2 = Double.valueOf(args[1]);

        // Implementation with anonymous class.
        MyFuncionalInterface calcWithAnonymousClass = new MyFuncionalInterface() {
            @Override
            public double calculate(double num1, double num2) {
                return num1 + num2;
            }
        };

        // Implementation with lambda.
        MyFuncionalInterface calcWithLamba = (parameter1, parameter2) -> parameter1 + parameter2;

        double resultWithAnonymousClass = calcWithAnonymousClass.calculate(num1, num2);
        double resultWithLambda = calcWithLamba.calculate(num1, num2);

        System.out.println("The sum between " + num1 + " and " + num2 + " is:");
        System.out.println("Anonymous Class: " + resultWithAnonymousClass);
        System.out.println("Lamba: " + resultWithLambda);
    }
}

For run that code, we can use the following commands at the location of Application.java file.

javac Application.java; java Application 1 1

After run it, the result showed at terminal is:

The sum between 1.0 and 1.0 is:
Anonymous Class: 2.0
Lamba: 2.0

Notice that the implementation maded for calcWithAnonymousClass needed of much more lines to make the same thing as calcWithLamba. That is the big deal of using Functional Interfaces and Lambdas: less code and more readability.

Of course, during our daily lives, many classes cannot be implemented in a functional way for many reasons: legacy code, dependency or even lack of knowledge. That resource is very useful, but on right places.

Thank you for reading, any suggestions are valid, please, let your feedback ;).

You can check the code on GitHub

References

That post was based on Vogella's introduction about Java, Marcelo Carvalho post on Medium, Oracle Documentation and Pankaj post on Digital Ocean.

Java's priority for inheritance of methods

Marcos Gabriel de Oliveira Favaretto — Sat, 07 Jan 2023 20:51:27 +0000

Introduction

That post was based on Vogella's post about an introduction of Java.

Multiple Inheritance of Methods.

Java follows an especific priority order to decide which method should be used among the classes (Super Classes or Interfaces) that have their implementations.

Overrides methods.
Super Class methods.
Subtype methods (instead of Supertypes one).

For example, let's consider the following Interfaces and Super Class:

interface MyFirstInterface { // Supertype
    public default void myMethod(String myParameter) {
        System.out.println("First Message: " + myParameter);
    }
}

interface MySecondInterface extends MyFirstInterface { // Subtype
    public default void myMethod(String myParameter) {
        System.out.println("Second Message: " + myParameter);
    }
}

class MySuperClass {
    public void myMethod(String myParameter) { // Super class
        System.out.println("Super Class Message: " + myParameter);
    }
}

Using MySuperClass as Super Class, implemmenting both Interfaces and overriding the myMethod method in a test class, according to the priority order, it is expected that the overrided method will be executed.

Code:

class Application extends MySuperClass implements MyFirstInterface, MySecondInterface {
    public static void main(String args[]) {
        Application myApp = new Application();
        myApp.myMethod("Hello World!");
    }

    @Override
    public void myMethod(String myParameter) {
        System.out.println("Overrided Message: " + myParameter);
    }
}

Result:

Overrided Message: Hello World!

Using MySuperClass as Super Class and implemmenting both Interfaces at the same test class, according to the priority order, it is expected that the Super Class's method will be executed.

Code:

class Application extends MySuperClass implements MyFirstInterface, MySecondInterface {
    public static void main(String args[]) {
        Application myApp = new Application();
        myApp.myMethod("Hello World!");
    }
}

Result:

Super Class Message: Hello World!

Implemmenting only both Interfaces at the test class, according to the priority order, it is expected that the Subtype's method (MySecondInterface.myMethod) will be executed.

Code:

class Application implements MyFirstInterface, MySecondInterface {
    public static void main(String args[]) {
        Application myApp = new Application();
        myApp.myMethod("Hello World!");
    }
}

Result:

Second Message: Hello World!

As shown above, this is the list of priorities that Java assumes when encountering these scenarios. You can see the code by clicking here.

Any suggestions are accepted, thank you for reading ;D.

Calling C native code from Java using JNI

Marcos Gabriel de Oliveira Favaretto — Wed, 28 Dec 2022 02:15:36 +0000

Hello community!
This is my first post, hope you like it! Notice that all content here is about my studies on JNI. Feel free to make suggestions, corrections, etc. :D

Good read!^^

NATIVE CALL FROM JAVA CODE TO C CODE.

The keyword "native" on Java allow us to call native libraries, by using the JNI.

That document was based on Baeldung post, Prof. Gustavo Leitão video and Oracle documentation about JNI.

1. Introduction

The JNI (Java Native Interface) allows Java to access codes on C and C++.

Commonly used for specifics performance cases, to handle hardwares or even use an existing library (not to need to rewrite).

2. The "native" key word.

When we are working with JNI, the native key word need to be used.

That key word says for JVM: "That method has an implementation on other language".

Here is an example of a native method:

public native void myNativeMethod();

Native methods are like abstracts one, with the difference that its implementation will be done in a separated native code file instead of a .java one.

3. The "System.loadLibrary()" method.

In order for the JVM to use the native code, it is necessary to use the static method System.loadLibrary(String libName). That one will load the provided library from the file system into our memory.

Here is a call example:

System.loadLibrary(mylibrary);

It is very important to say that the library's name provided as parameter needs to follow some rules, depending on the platform that the JVM is being executed. For example, lets suppose a library called as "taxcalculator". The following table shows which names should be used for that example.

System Name	Parameter Value	Name of File (without blank spaces)
Windows	taxcalculator	taxcalculator .dll
Solaris	taxcalculator	libtaxcalculator .so

The provided parameter is converted automatically by JVM like as showed from column "Parameter Value" to "Name File".

Alternatively, we can use the command System.load(D:\\my\\library\\path\\libmylibrary.dll) to find a library by its fully path.

4. Step by step.

After a simple introduction, let's make a simple example by creating a calculator in Java but making all calculations on C.

4.1. Creating a Java program.

The first step is to create our Java class and declare its methods to be implemented on another language. As said before, we need to load our library, by using the method System.loadLibrary(mylibrary).

Note that, the native methods does not have implementations here since it will be done at a C file later. After compile this Java class, there are no errors.

4.2. Generating C header.

Java's compiler allows us to generete our C header automatically, using the command below:

javac Calculator.java -h ../c/

Where:

javac: Executes the Java compiler.

Calculator.java: Is the class that needs to be implemented in C.

-h: Says for compiler where to save the native header file.

../c/: Is the path where the header is going to be saved.

NOTE: If you are running a version before 10, use the javah instead of javac -h <path>

After execute that command, a new .h is generated. There, we can see all method's signature that we defined as native using the "native" key word.

4.3. Implementing the methods with native code.

After all these steps, now we need to create the implementation of C code to the Java declared methods.

Let's create a new .c file, there, we included the generated header file and implement a function for all methods, following its signature.

Notice that the methods signature was copy from the generated header, with the difference that all parameters have been changed to have a name that can be referenced in the code.

4.4. Compiling C class.

For compile the C class, I will use the GCC. If you are using Windows (like me), use that step-by-step for stalling it. If you are using Linux, you must already have it installed.

To compile it, we can use the following command (you will have to change it for your case).

gcc -o libcalculator.dll -shared -I"your\java\home\include" -I"your\java\home\include\win32" -I"your\project\c" ./Calculator.c;

Where:

gcc: Executes the GNU Compiler C.

-o: Says for compiler where to save the generated file.

libcalculator.dll: Is the name of the generated file.

-shared: Says for compiler to create a shared library.

-I"your\java\home\include": Is the location of jni.h, that is used by Calculator.h.

-I"your\java\home\include\win32": Is the location of jni_md.h for Windows, that is also used by Calculator.h.

-I"your\project\c": Is the location of Calculator.h, that is used by Calculator.c.

./Calculator.c: This is the file we want to compile

All that code needs to be executed in one line. After it, a libcalculator.dll will be generated.

4.5. Executing our program.

After all these steps, we are able to execute our program. Just do it by using the following command on your/project/java:

java -Djava.library.path=location/of/libcalculattor Calculator 2 2

NOTE: If you used the System.load instead of System.loadLibrary, the -Djava.library.path=location/of/libcalculattor argument does not need to be provided.

The following image shows the application working:

This is a basic example of how to use JNI. You can see the code by clicking here.

As Junior, I am really curious: How's to make commits on programming languages core?

Marcos Gabriel de Oliveira Favaretto — Sat, 24 Sep 2022 01:34:18 +0000