Um caso de uso popular para correspondência de padrões com switch é ao trabalhar com diferentes tipos de dados em um programa. Considere o seguinte exemplo de uma classe WeatherStation que possui diferentes tipos de sensores e retorna a temperatura atual:

`classe pública Estação Meteorológica {

private Sensor sensor;

 public double getCurrentTemperature() {
    return switch (sensor) {
        case TemperatureSensor t -> t.reading();
        case HumiditySensor h -> h.reading() * 0.9; // apply a 10% moisture correction
        default -> 0.0; // in case of an unhandled sensor type, return 0
    };
}

}
`
Aqui, podemos ver que uma interface Sensor é usada para a expressão do seletor, e os rótulos de caso usam padrões baseados em implementações específicas do Sensor: TemperatureSensor e HumiditySensor. Isso permite uma maneira mais concisa e legível de lidar com diferentes tipos de dados na instrução switch.

Outro caso de uso para correspondência de padrões com switch é ao lidar com enums. Antes da introdução da correspondência de padrões, enums só podiam ser usados ​​como constantes em rótulos de caso, restringindo os valores que poderiam ser testados em uma instrução switch. Com o novo recurso, enums agora podem ser qualificados em rótulos de casos, permitindo uma correspondência mais precisa e flexível.

direção de enum público {
NORTE,
LESTE,
SUL,
OESTE
}

movimento vazio público (direção direção) {
mudar (direção) {
caso NORTE, NORTE_OESTE, NORTE_EAST -> moveUp();
caso EAST,EAST_NORTH,EAST_SOUTH -> moveRight();
caso SUL, SOUTH_EAST, SOUTH_WEST -> moveDown();
caso WEST,WEST_NORTH,WEST_SOUTH -> moveLeft();
}
}

Aqui, o método move() usa uma instrução switch para lidar facilmente com movimentos em diferentes direções com base no valor enum Direction especificado. Com a correspondência de padrões, também podemos especificar combinações direcionais, como NORTH_WEST e EAST_SOUTH, tornando nosso código mais robusto e flexível.

Finalmente, vejamos um exemplo de como a correspondência de padrões pode ajudar no tratamento de erros em uma instrução switch. Na opção tradicional, se a expressão do seletor não corresponder a nenhum dos rótulos de caso, um caso padrão poderá ser usado para tratar o erro. No entanto, isso pode ser entediante ao lidar com vários rótulos de casos e pode levar à duplicação de código. Na correspondência de padrões, uma exceção é lançada se nenhum dos padrões de rótulo de caso corresponder à expressão do seletor, tornando o tratamento de erros mais uniforme e menos sujeito a erros.

public String getPlanetaryObject(corpoPlanetaryBody) {
interruptor de retorno (corpo) {
case Planeta p && p.getMass() > 1e29 -> p.getName() "é um gigante gasoso";
case Planeta p && p.getMass() > 1e23 -> p.getName() "é um planeta rochoso";
case Star s && s.getLuminosity() > 1e32 -> s.getName() "é uma estrela brilhante";
case Star s && s.getLuminosity() s.getName() "é uma estrela fraca";
padrão -> throw new MatchException("Não foi possível determinar o tipo de objeto planetário: " body.getName());
};
}

Neste exemplo, o método getPlanetaryObject() recebe um objeto PlanetaryBody, que pode ser um planeta ou uma estrela. Os padrões usados ​​nas etiquetas das caixas consideram condições adicionais, como a massa do planeta ou a luminosidade da estrela. Se nenhum dos padrões corresponder, uma MatchException será lançada, tornando o tratamento de erros mais consistente e evitando possíveis erros.

Conclusão
A correspondência de padrões para switch é um dos recursos mais significativos introduzidos em Java nos últimos tempos. Ele permite estruturas de fluxo de controle mais flexíveis e concisas.

Atualize suas habilidades em Java obtendo a certificação Java SE 21 Professional Certified Developer.