Interesting JDK 12 features to watch out for.
Tags: java, beginners, android, productivity
Published: 2018-11-09 01:51:51

---
title: Interesting JDK 12 features to watch out for.
published: true
description: Java is improving, here are some cool improvements.  
tags: #java #beginners #android #productivity
cover_image: https://thepracticaldev.s3.amazonaws.com/i/e8xn8z34krypfqfnhnkr.jpg
---

With the new 6 months Java release cycle, you should expect cool features to get to developers at a faster rate. I have seen some cools features which you could expect to see in the JDK 12 release next year. You can get the Open JDK 12 early access build and try these *preview features* out.


##Switch expressions
For example, you have an enum for the days of the week and you want to use switch statement to return the number of letters in the string. There are better ways to do this but we are going to use Switch statements to demonstrate this.

Here is the enum:

```java
enum DayOfWeek{
MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

```

With what we know in Java this would probably be the solution:

```java
      int numLetters;
        switch(day){
            case MONDAY: case FRIDAY: case SUNDAY:
                numLetters=6;
                break;
            case TUESDAY:
                numLetters=7;
                break;
            case THURSDAY: case SATURDAY:
                numLetters=9;
                break;
            case WEDNESDAY:
                numLetters=10;
                break;
            default:
                throw new NoSuchDayException(day);

        }
```

This could really trigger some bugs as it could make the code hard to maintain.
With Switch Expressions, you could write the Switch as an expression. No default is needed in the Switch statement.

Here is how the code would look like:

```java
int numLetters=switch(day)
        {
            case MONDAY, FRIDAY, SUNDAY -> 6;
            case TUESDAY -> 7;
            case THURSDAY, SATURDAY -> 8;
            case WEDNESDAY -> 9;
        };
```

##Records
We all know our POJOs (plain old Java object), they come with a lot of boilerplate code, for example here is a classic POJO:

```java 
class Point {
    double x;
    double y;

    Point(double x, double y) {
        this.x = x;
        this.y = y;
    }

    public void setX(double x) {
        this.x = x;
    }

    public double getX() {
        return x;
    }

    public void setY(double y) {
        this.y = y;
    }

    public double getY() {
        return y;
    }

    @Override
    public int hashCode() {
        return super.hashCode();
    }

    @Override
    public boolean equals(Object obj) {
        return super.equals(obj);
    }


    @Override
    public String toString() {
        return super.toString();
    }
}

```

Well, *Records* (currently not targeted to JDK 12 at the time of this writing) replace all that POJO code with just one line:
```java
 record Point(double x, double y);
```

There are other cool features to expect in JDK 12 and beyond, I personally appreciate the fact that the Java community is responding and aiming to move Java forward.

In case you are interested in learning way more you could check out this video:
{% youtube nKJbDYRsO0s %}