DEV Community: Bárbara Salla

"Pesquei, Java!": Transformações do Switch: Novidades e Recursos

Bárbara Salla — Fri, 24 Jan 2025 03:14:41 +0000

O switch no Java, desde quando surgiu, já passou por várias atualizações, tornando-se cada vez mais versátil e poderoso. Essas melhorias impactaram tanto o comportamento, sintaxe, exaustividade e a capacidade de trabalhar com diferentes tipos de dados.

Inicialmente, o switch foi introduzido como uma declaração, e, mais tarde, evoluiu para incluir o conceito de expressão em versões mais recentes. Para entender melhor o que esses dois conceitos significam, podemos descreve-los como:

Declaração: É usada para controlar o fluxo do programa, executando diferentes blocos de código com base no valor de uma variável. Não retorna diretamente um valor.
Expressão: Avalia uma condição e retorna um valor diretamente, que pode ser atribuído a uma variável, por exemplo.

A seguir, exploraremos as mudanças ao longo das versões do Java e suas implicações práticas.

1.Switch como Declaração (Forma Clássica)

Quando falamos do switch como declaração, estamos nos referindo à forma clássica de uso dessa estrutura. Em versões anteriores do Java, o switch só era utilizado apenas como uma declaração básica de controle de fluxo. Ele podia ser usado com tipos int, char, byte, short e outros, mas sempre sem retornar um valor diretamente.

Limitações da forma clássica do switch:

Tipos restritos: Apenas funcionava com tipos primitivos numéricos (int, short, char, byte) e, posteriormente, com String (a partir do Java 7) e enums (Java 5).
Repetitividade: Não permitia a reutilização de lógica ou a utilização de blocos mais compactos.
Inflexibilidade: Não suportava expressões complexas ou a possibilidade de retornar diretamente valores.
Escalabilidade: O switch clássico era inadequado para cenários em que era necessário lidar com múltiplos tipos de dados ou condições compostas, como intervalos de valores.

Exemplo: Switch clássico com números inteiros

public static void main(String[] args) {
    var dayValue = 1;
    String day = "";

    switch (dayValue){
        case 1:
            day = "sunday";
            break;
        case 2:
            day = "monday";
            break;
        case 3:
            day = "Tuesday";
            break;
        case 4:
            day = "Wednesday";
            break;
        case 5:
            day = "Thursday";
            break;
        case 6:
            day = "Friday";
            break;
        case 7:
            day = "Saturday";
            break;
        default:
            System.out.println("Invalid Value: "+ dayValue);
    }

    System.out.println("\nValue: "+dayValue+"\nDay: "+ day+"");
}

Resposta do console:

Nesse cenário, por exemplo, se retirarmos o break, o programa executará todos os blocos a partir do caso correspondente ao valor, resultando no comportamento que conhecemos como "Fall Through".

public static void main(String[] args) {
        var dayValue = 1;
        String day = "";

        switch (dayValue){
            case 1:
                day = "Sunday";
            case 2:
                day = "Monday";
            case 3:
                day = "Tuesday";
            case 4:
                day = "Wednesday";
            case 5:
                day = "Thursday";
            case 6:
                day = "Friday";
            case 7:
                day = "Saturday";
            default:
                System.out.println("Invalid Value: "+ dayValue);
        }

        System.out.println("\nValue: "+dayValue+"\nDay: "+ day+"");
    }

Resposta do console:

2.Suporte a String no Switch (Java 7):

A partir do Java 7, podemos então passar valores do tipo String como parâmetro no switch, ampliando significativamente o seus casos de uso, por exemplo:

public static void main(String[] args) {
        String day = "Monday";

        switch (day) {
            case "Monday":
                System.out.println("Start of the work week.");
                break;
            case "Tuesday":
            case "Wednesday":
            case "Thursday":
                System.out.println("Midweek days.");
                break;
            case "Friday":
                System.out.println("Almost the weekend!");
                break;
            case "Saturday":
            case "Sunday":
                System.out.println("Weekend!");
                break;
            default:
                System.out.println("Invalid day.");
        }
}

Resposta do console:

3.Switch com Expressões (Java 12+):

O Java 12 introduziu as Switch Expressions (inicialmente como recurso preview). Com isso, o switch ganhou uma nova sintaxe e a capacidade de permitir ao switch retornar diretamente valores a uma variável, eliminando a necessidade de utilizar o break. No exemplo a seguir, podemos observar a implementação direta do switch após o sinal de atribuição de valor (=) da variável day.

 public static void main(String[] args) {
        int dayValue = 6;
        String day = switch (dayValue){
            case 1 -> "Sunday";
            case 2 -> "Monday";
            case 3 -> "Tuesday";
            case 4 -> "Wednesday";
            case 5 -> "Thursday";
            case 6 -> "Friday";
            case 7 -> "Saturday";
            default -> "invalid day.";
        };

        System.out.println("\nValue: "+dayValue+"\nDay: "+ day);
    }

Resposta do console:

4.Uso do Yield (Java 13/14)

O yield foi introduzido no Java 13 como parte das Switch Expressions, sendo apenas oficializado no Java 14. O termo yield é usado para retornar um valor em bloco de código dentro do switch. Tornando possível usar blocos de código mais complexos e retornar valores a partir deles.

public String getDayType(int day) {
    String dayType = switch (day) {
        case 1 -> "Monday";
        case 2 -> "Tuesday";
        case 3 -> "Wednesday";
        default -> {
            System.out.print("Invalid day");
            yield null;
        }
    };
    return dayType;
}

No exemplo acima, o yield permite adicionar blocos de código em um case usando {} e retornar valores específicos ao final do processamento, tornando possível implementar diferentes comportamentos para os diversos cases. Diferentemente do já conhecido return, que sai e finaliza imediatamente a execução do método, o yield apenas retorna um valor para a expressão switch.

5.Múltiplos Valores por Case (Java 14)

Com o Java 14, as Switch Expressions foram formalizadas e, além disso, tornou-se possível combinar vários valores em um único case, simplificando condições que compartilham o mesmo comportamento, como no exemplo abaixo:

public static void main(String[] args) {
            String day = "Monday";
            switch (day) {
                case "Saturday", "Sunday":
                    System.out.println("Weekend");
                    break;
                case "Monday", "Tuesday", "Wednesday", "Thursday":
                    System.out.println("Weekday");
                    break;
                default:
                    System.out.println("Invalid day");
            }
}

Resposta do console:

6.Exaustividade no Switch (Java 12 e Java 14)

Com o switch e as Switch Expressions, se os valores possíveis forem completamente definidos, como quando trabalhamos com Enum, o compilador pode verificar se todos os casos foram cobertos, garantindo maior controle e segurança na implementação. Assim, o compilador consegue interpretar se todas as opções foram tratadas nos cases e sinalizar caso não esteja cobrindo todas as possibilidades, evitando comportamentos inesperados em tempo de execução.

Portanto, se todos os casos não forem cobertos, o compilador emitirá um erro de compilação, como mostrado no exemplo abaixo:

public class Main {
    enum Day {
        MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
    }

    public static void main(String[] args) {
        Day day = Day.FRIDAY;
        System.out.println("This day falls on a  " + getDayType(day));
    }

    public static String getDayType(Day day) {
        return switch (day) {
            case MONDAY,TUESDAY,WEDNESDAY,THURSDAY,FRIDAY -> "Weekday";
            case SATURDAY -> "Weekend";
        };
    }
}

Erro de compilação:

Já com todas as opções tratadas, o código compila e roda conforme esperado:

public class Main {
    enum Day {
        MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
    }

    public static void main(String[] args) {
        Day day = Day.FRIDAY;
        System.out.println("This day falls on a  " + getDayType(day));
    }

    public static String getDayType(Day day) {
        return switch (day) {
            case MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY -> "Weekday";
            case SATURDAY, SUNDAY -> "Weekend";
        };
    }
}

Resposta do console:

7.Exaustividade no switch com Classes Seladas (Java 17)

A exaustividade no switch também se aplica a classes seladas a partir do Java 17. Uma classe selada controla diretamente quais outras classes ou interfaces podem estendê-las ou implementá-las, limitando a hierarquia de herança, permitindo que o compilador verifique se todos os casos possíveis foram tratados.

sealed class Day permits Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday { }

final class Monday extends Day { }
final class Tuesday extends Day { }
final class Wednesday extends Day { }
final class Thursday extends Day { }
final class Friday extends Day { }
final class Saturday extends Day { }
final class Sunday extends Day { }

public class Main {
    public static void main(String[] args) {
        Day day = new Monday(); 
        System.out.println("Today is: " + dayType(day));
    }

    public static String dayType(Day day) {
        return switch (day) {
            case Tuesday t -> "Weekday";
            case Friday f -> "Weekday";
            case Saturday s -> "Weekend";
        };
    }
}

Conforme o exemplo acima, verificamos que:

Temos uma classe selada Day que permite apenas que as classe Monday, Tuesday, Wednesday, Thursday, Friday, Saturday e Sunday herdam seus atributos e comportamentos.
Temos no método main a chamada de um método (dayType()) que utiliza o switch com classes seladas.
Não temos todas as opções de subclasses da Classe Day contempladas nos cases do switch, resultando num erro de compilação:

8.Pattern Matching no Switch (Java 17)

Outra novidade introduzida no Java 17 foi a integração do switch ao recurso Pattern Matching, permitindo verificar se determinado objeto é do tipo de uma classe especifica a partir de um switch.

Antes do Java 17, a verificação de tipos era feita com instanceof e exigia blocos separados de código, como no exemplo abaixo:

public static void main(String[] args) {
        Object object = "text";

        if(object instanceof String){
            System.out.println("This object is a String");
        } else if (object instanceof Long) {
            System.out.println("This object is a long");
        } else {
            System.out.println("Unidentified object type");
        }
}

Resposta console:

Já quando aplicamos o Pattern Matching com switch temos a seguinte sintaxe:

public static void main(String[] args) {
    Object object = "text";

    switch (object){
        case String s-> System.out.println("This object is a String");
        case Integer i ->  System.out.println("This object is a Integer");
        default -> System.out.println("Unidentified object type");
    }
}

Resposta console:

Esse recurso facilita a verificação de tipos, evitando a necessidade do instanceof e de blocos separados para diferentes tipos de objetos.

9.Uso de null como case (Java 17)

A partir do Java 17, tornou-se possível atribuir valor null a um case no switch, por exemplo:

     case null -> System.out.println("This is a null object");

Espero que essas informações tenham sido úteis para você e agreguem ao seu código. Até mais!

"Pesquei, Java!": Por que deixar o java.io.File para Trás?

Bárbara Salla — Thu, 16 Jan 2025 10:22:45 +0000

A classe File, do pacote java.io, em Java representa de forma abstrata o caminho de um arquivo ou diretório no sistema de arquivos. Com ela, é possível criar, deletar, renomear e consultar informações básicas, como metadados de arquivos. No entanto, a utilização da classe java.io.File, apesar de já ter sido amplamente adotada, vem sendo desestimulada desde o lançamento do pacote java.nio.file no Java SE 7.

Essa mudança foi incentivada pela Oracle devido a várias limitações apontadas no artigo Legacy File I/O Code, que, de forma geral, traduzido para o português, destaca:

Exceções genéricas: Os métodos não lançavam exceções detalhadas em casos de falha. Por exemplo, ao excluir um arquivo, não era possível identificar se o problema era falta de permissão, inexistência do arquivo ou outra razão.
Comportamento inconsistente: Métodos como rename não apresentavam comportamento uniforme entre diferentes sistemas operacionais.
Falta de suporte para links simbólicos: Não havia suporte para links simbólicos ou acesso eficiente a metadados avançados, como permissões e proprietários.
Problemas de desempenho: Operações em diretórios grandes frequentemente causavam problemas de desempenho ou até falhas na aplicação.
Percurso de diretórios não confiável: Não era possível percorrer diretórios de forma segura e evitar loops causados por links simbólicos circulares.

Com a introdução do pacote java.nio.file, a API trouxe soluções mais seguras e modernas, sendo a escolha mais recomendada para manipulação de arquivos e diretórios.

De maneira prática, podemos demonstrar alguns dos problemas mais comuns da classe File e compará-los com as soluções oferecidas pela classe Path (escolha recomendada), nos seguintes códigos:

1. Exclusão de Arquivos com Detalhamento de Exceções:

Usando File:

public static void main(String[] args) {
        try {
            File file = new File("example.txt");
            System.out.println("Arquivo excluido com sucesso: "+ file.delete());
        } catch (Exception e){
            e.printStackTrace();
        }
}

Resposta do Console:

Usando Path:

public static void main(String[] args) {
        try {
            Path path = Path.of("example.txt");
            Files.delete(path);
        } catch (NoSuchFileException e) {
            System.out.println("Erro: O arquivo não existe - " + e.getMessage());
        } catch (AccessDeniedException e) {
            System.out.println("Erro: Permissão negada - " + e.getMessage());
        } catch (IOException e) {
            System.out.println("Erro inesperado ao excluir o arquivo - " + e.getMessage());
        } catch (Exception e){
            e.printStackTrace();
        }
}

Resposta do Console:

2. Renomear Arquivos de Forma Confiável:

Usando File:

public static void main(String[] args) {
        try {
            File oldFile = new File("old_name.txt");
            File newFile = new File("new_name.txt");
            System.out.println("Renomeou o arquivo com sucesso: "+ oldFile.renameTo(newFile));
        } catch (Exception e){
            e.printStackTrace();
        }
}

Resposta do Console:

Usando Path:

public static void main(String[] args) {
        Path oldPath = Path.of("old_name.txt");
        Path newPath = Path.of("new_name.txt");
        try {
            Files.move(oldPath, newPath);
            System.out.println("Arquivo renomeado com sucesso.");
        } catch (FileAlreadyExistsException e) {
            System.out.println("Erro: O novo nome já está sendo usado por outro arquivo.");
        } catch (NoSuchFileException e) {
            System.out.println("Erro: O arquivo original não existe.");
        } catch (IOException e) {
            System.out.println("Erro inesperado ao renomear o arquivo: " + e.getMessage());
        } catch (Exception e){
            e.printStackTrace();
        }
}

Resposta do Console:

"Ah, Mas todos os meus projetos utilizam o File":

De acordo com a própria documentação da Oracle, caso o custo de substituir o uso da classe java.io.File por funcionalidades do pacote java.nio.file seja muito alto, existem soluções para facilitar a migração e minimizar o impacto no código.

Por exemplo, a classe java.io.File oferece o método toPath(), que converte uma instância de File para uma instância de Path. No exemplo que tentamos excluir um arquivo, podemos fazer essa conversão:

public static void main(String[] args) {
        try {
            File file = new File("example.txt");
            Path path = file.toPath();
            Files.delete(path);
        } catch (NoSuchFileException e) {
            System.out.println("Erro: O arquivo não existe - " + e.getMessage());
        } catch (AccessDeniedException e) {
            System.out.println("Erro: Permissão negada - " + e.getMessage());
        } catch (IOException e) {
            System.out.println("Erro inesperado ao excluir o arquivo - " + e.getMessage());
        } catch (Exception e){
            e.printStackTrace();
        }
}

Dessa forma, você pode migrar seu código de forma gradual e aproveitar os novos recursos e correções implementada no pacote java.nio.

Espero que essa informação tenha sido útil para você e venha agregar ao seu código. Até mais!

Fontes:

ORACLE. Legacy I/O. Oracle Java Tutorials. Disponível em: https://docs.oracle.com/javase/tutorial/essential/io/legacy.html. Acesso em: 10 jan. 2025.

ORACLE. Class File (Java SE 21 & JDK 21). Oracle Java Documentation. Disponível em: https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/io/File.html. Acesso em: 15 jan. 2025.

ORACLE. Package java.nio.file (Java SE 21 & JDK 21). Oracle Java Documentation. Disponível em: https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/nio/file/package-summary.html. Acesso em: 15 jan. 2025.

"Pesquei, Java!": Classe e Objeto em Foco: Da Abstração à Realidade

Bárbara Salla — Thu, 09 Jan 2025 18:57:55 +0000

Na Programação Orientada a Objetos (POO), buscamos representar elementos do mundo real dentro dos nossos programas. Para isso, abstraímos do objeto suas características (o que eles têm) e seus comportamentos (o que eles fazem), traduzindo essas ideias em classes e objetos. Dessa maneira, podemos encapsular estados e comportamentos de um tipo específico de objeto, facilitando sua manutenção e reutilização no código.

Por exemplo, imagine que queremos representar uma caneta em nosso programa. Quais seriam as suas características? e quais seriam seus comportamentos? Vamos, então, projetar a caneta da seguinte forma:

Para traduzir essa abstração em código, criamos uma classe que funciona como o "molde" ou "projeto" que estabelece as características e comportamentos de uma caneta. A classe define o que todo objeto desse tipo terá (como atributos) e poderá fazer (como métodos). Assim, a classe serve como uma representação abstrata, enquanto o objeto é uma instância concreta/real dessa classe.

Quando criamos um objeto a partir de uma classe, ele se torna uma instância única, com valores específicos atribuídos às suas variáveis de instância. Assim, de acordo com Paul Deitel e Harvey Deitel (2017, p.56): “cada nova classe que você desenvolve torna-se um novo tipo que pode ser utilizado para declarar variáveis e delinear objetos”. Ou seja, diferentes objetos de um mesmo tipo (criados a partir da mesma classe), como no caso de uma “caneta”, podem ser criados e poderão compartilhar os mesmos comportamentos, mas cada um terá valores distintos para seus atributos, tornando-os únicos. Por exemplo, ao criar a Caneta A:

Com essas definições em mente, ao projetar uma classe, deve-se refletir sobre o que o objeto sabe sobre si e o que ele faz (BATES, Bert; SIERRA, Kathy, 2005). O que ele conhece sobre si mesmo chamamos de variáveis de instância (estado) e o que faz são os seus métodos (comportamento). A classe sintetiza a estrutura e o comportamento que o objeto deve possuir. Ao criar um objeto a partir da classe, ele será construído com as mesmas características gerais descritas na classe, representando uma instância concreta do conceito abstrato. No entanto, cada objeto terá seus próprios valores para os atributos, refletindo suas características únicas.

Classe ou objeto: Quem nasce primeiro?

Ao compreender a classe como um “molde” abstrato para a construção do objeto, ela torna-se, de fato, a fundação, enquanto o objeto é a concretização desse modelo. Em outras palavras, a classe nasce primeiro e se estabelece como um tipo de objeto. Não é possível criar um objeto sem que exista uma classe, pois a classe fornece a estrutura necessária para sua criação. Assim, a classe representa o ponto de partida, enquanto o objeto é a materialização desse projeto em uma instância real e utilizável dentro do programa.

Agora, podemos aplicar o conceito de classe e objeto diretamente no código, com um exemplo prático de como modelar um carro em programação orientada a objetos.

Primeiramente, devemos nos perguntar: o que sabemos sobre carros? O que todo carro possui? Ele tem portas, é movido a álcool, gasolina ou outros combustíveis, pode ser automático ou manual, possui um modelo, cor e capacidade de passageiros. Essas características representam o estado do carro, ou seja, os atributos que o definem.

E o que ele pode fazer? Ele pode acelerar, frear, ligar, desligar, buzinar, abrir as portas ou acionar o farol. Essas ações representam o comportamento do carro, ou seja, os métodos que descrevem o que ele é capaz de executar.

Abaixo, temos a implementação de um Carro como classe (Car), combinando seus atributos e os seus métodos. Seguindo as boas práticas, colocamos todo o código em inglês:

public class Car {

    private String model;
    private String color;
    private String fuelType;
    private int passengerCapacity;

    public Car(String model, String color, String fuelType, int passengerCapacity) {
        this.model = model;
        this.color = color;
        this.fuelType = fuelType;
        this.passengerCapacity = passengerCapacity;
    }

    public void accelerate() {
        System.out.println("The car is accelerating.");
    }

    public void brake() {
        System.out.println("The car is braking.");
    }

    public void start() {
        System.out.println("The car is started.");
    }

    public void stop() {
        System.out.println("The car is stopped.");
    }

    public void honk() {
        System.out.println("The car is honking.");
    }

    public void displayDetails() {
        System.out.println("Model: " + model);
        System.out.println("Color: " + color);
        System.out.println("Fuel Type: " + fuelType);
        System.out.println("Passenger Capacity: " + passengerCapacity);
    }
}

Agora, vamos criar um objeto Car a partir da classe Car para utilizá-lo no nosso código, e assim demonstrar a função da classe como um modelo para construção do objeto e o objeto como a versão real criada a partir desse modelo.

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

        Car carA = new Car("Fusca", "Blue", "Gasoline", 4);

        carA.displayDetails();

        carA.start();
        carA.accelerate();
        carA.honk();
        carA.brake();
        carA.stop();
    }
}

Neste exemplo, demonstramos que ao projetarmos uma classe, estamos, na verdade, criando um modelo abstrato que pode ser concretizado em múltiplas instâncias, cada uma com dados próprios. Essa é a essência da Programação Orientada a Objetos: transformar ideias abstratas em representações concretas para aplicação no código.

Agora que você sabe como funcionam as classes e o objetos, quais outros objetos você conseguiria representar em código? E para os que já possuem vasta experiência: qual foi a classe mais criativa ou desafiadora que você já criou em um projeto?

Fontes:

DEITEL, Paul; DEITEL, Harvey. Java: como programar. São Paulo: Pearson
Education do Brasil, 2017.

SIERRA, Kathy; BATES, Bert. Use a Cabeça! Java. 2ªEd. Rio de Janeiro: Editora Alta Books, 2005.

"Pesquei, Java!": Introdução à nova série semanal sobre Java.

Bárbara Salla — Wed, 08 Jan 2025 19:03:34 +0000

"Pesquei, Java!" é uma série semanal que busca explorar os conceitos do vasto "mar" do Java. Toda semana, lançamos nossa linha no oceano da programação e fisgamos uma ideia, conceito ou prática que possam contribuir para os estudos sobre Java e estimular debates enriquecedores sobre os conteúdos. Aqui, você encontrará desde fundamentos de POO até insights avançados. Prepare sua xícara de café e venha conosco pescar ideias que farão diferença no seu código.

A tecnologia é um vasto oceano, convido a todos(as) a navegar juntos e explorar as descobertas que ela nos reserva. Até mais!