I've been a fan of Java for years, loving its object-oriented design and its rich standard library. However, there's one missing feature that bugs me: postnumerical letters for the `byte` and `short` types. In Java, when you work with numbers, you have `0` for `int`, `0L` for `long`, `0.0f` for `float`, and `0.0d` for `double`. But you can't write something like `0b` or `0s` for `byte` and `short`.
For instance, when you create a byte with `byte b = 1;`, it works fine. However, if I call a function expecting a `short`, like `test(short s)` with `test(171)`, it throws an error about a possible lossy conversion from `int` to `short`. This forces me to write `test((short)171)`, which feels clunky. I tend to avoid using `byte` and `short` despite knowing they can save memory space, which isn't a big deal these days anyway.
So, is there a clear reason why these types don't have their own postnumerical letters? Will this feature ever be added to Java? And if it's in the works, can it be included in Java 8 without breaking existing code?
5 Answers
The lack of literals for `byte` and `short` likely boils down to practicality. The major primitives `long`, `int`, `float`, and `double` have more common bytecode operations, while `byte` and `short` are less frequently utilized. Adding operations for them in bytecode would complicate things significantly without much benefit for most developers.
Exactly. If they had their own literals, I'd expect they would just complicate the type system for minimal gain.
While it's a legitimate request, Java has its reasons for sticking to `int` by default. You only really need the wider literals when you're dealing with extended ranges. But it doesn’t harm the overall structure of Java as it is now.
You might find it interesting to know that internally `short` and `byte` values are treated as 32 bits, meaning they don’t provide the memory efficiency you might expect. In fact, using them can sometimes slow down performance compared to just using `int` due to how the JVM processes them.
True, that adds to the confusion! It seems like using smaller types doesn't always optimize performance the way you'd hope.
Exactly, and that's why many projects don't bother with `byte` and `short` unless they have a specific need for those types.
The main issue is that using `byte` or `short` in Java doesn’t actually save memory in most scenarios unless you're working with primitive arrays. If you're just using them as properties in objects, they still incur the overhead of their object wrapper, so performance gain is minimal. It's more about readability.
Asking for a change to a language version that's been out since 2014 is quite ambitious! But some people think it's a good idea, even if the odds are low for a change. But keep in mind that most developers may not need these literals often in modern coding practices.
I get that it's a long shot. Still, the simplification aspect could encourage more developers to utilize these types, which can lead to cleaner and more efficient code, right?
Right, many programmers don't often delve into the minor types anymore. But perhaps it's an oversight that wouldn’t need much effort to correct.
Right? They're just not as commonly used, and changing that would require a lot more than just adding syntax.