Does Java have sum types now?

Yes via sealed classes. It also has pattern matching.

So they are there, but ugly to define:

    public abstract sealed class Vehicle permits Car, Truck {
      public Vehicle() {}
    }

    public final class Truck extends Vehicle implements Service {
      public final int loadCapacity;

      public Truck(int loadCapacity) {
        this.loadCapacity = loadCapacity;
      }
    }

    public non-sealed class Car extends Vehicle implements Service {
      public final int numberOfSeats;
      public final String brandName;

      public Car(int numberOfSeats, String brandName) {
        this.numberOfSeats = numberOfSeats;
        this.brandName = brandName;
      }
    }

In Kotlin it's a bit better, but nothing beats the ML-like langs (and Rust/ReScript/etc):

    type Truck = { loadCapacity: int }
    type Car = { numberOfSeats: int, brandName: string }
    type Vehicle = Truck | Car

You could use Java records to make things more concise:

  record Truck(int loadCapacity) implements Vehicle {}
  record Car(int numberOfSeats, String brandName) implements Vehicle {}
  sealed interface Vehicle permits Car, Truck {}

Scala 3 has:

  enum Vehicle:
    case Truck(loadCapacity: Int)
    case Car(numberOfSets: Int, brandName: String)

You implemented this much more verbosely than needed

    sealed interface Vehicle {
        record Truck(int loadCapacity) implements Vehicle {}
        record Car(int numberOfSeats, String brandName) implements Vehicle {}
    }

Ah! Thanks, I didn't know that. I should have RTFMD better - https://docs.oracle.com/en/java/javase/21/language/sealed-cl...

Turns out you can do this and not have the annoying inner class e.g. Vehicle.Car too:

  package com.example.vehicles;

  public sealed interface Vehicle
      // The permits clause has been omitted
      // as its permitted classes have been
      // defined in the same file.
  { }
  record Truck(int loadCapacity) implements Vehicle {}
  record Car(int numberOfSeats, String brandName) implements Vehicle {}

I think Java 21 does. Scala and Kotlin do as well.

Python has it as well.

Ah my mistake. It’s been at least 5 years since I’ve written it. I’m honestly surprised that JS has moved no where on it considering all of the fancy things they’ve been adding.

It has been proposed, but since there is all the process on how features get added into the standard, someone needs to champion it, and then there is the "at least two implementations" factor.

https://github.com/tc39/proposal-pattern-matching