From 1a9942900c129c835f29ecd75867bbe8e6c31ee1 Mon Sep 17 00:00:00 2001 From: Kaique Vieira <123115955+kaiquevieirasoares@users.noreply.github.com> Date: Sun, 14 Jul 2024 17:57:44 -0300 Subject: [PATCH 1/9] Create 16-records.md --- "4 - Intermedi\303\241rio/16-records.md" | 113 +++++++++++++++++++++++ 1 file changed, 113 insertions(+) create mode 100644 "4 - Intermedi\303\241rio/16-records.md" diff --git "a/4 - Intermedi\303\241rio/16-records.md" "b/4 - Intermedi\303\241rio/16-records.md" new file mode 100644 index 0000000..9ca835a --- /dev/null +++ "b/4 - Intermedi\303\241rio/16-records.md" @@ -0,0 +1,113 @@ +# Records + +Os Records são uma nova forma de declarar classes no Java. Eles são imutáveis por padrão, o que significa que não podemos alterar seus valores após a criação do objeto. Além disso, eles são bastante úteis para representar dados, como, por exemplo, uma entidade de banco de dados. Esse tipo de classe foi introduzida oficialmente ao Java na versão 17, portanto, podemos utilizar em nossos programas. + + +## Exemplo de utilização + +```java +// Essa classe não é um Record. +import java.util.Objects; + +public class User { + + private String name; + + private String password; + + public User(String name, String password) { + this.name = name; + this.password = password; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public String getPassword() { + return password; + } + + public void setPassword(String password) { + this.password = password; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + User user = (User) o; + return name.equals(user.name) && password.equals(user.password); + } + + @Override + public int hashCode() { + return Objects.hash(name, password); + } + + @Override + public String toString() { + return "User{" + + "name='" + name + '\'' + + ", password='" + password + '\'' + + '}'; + } +} + +``` + +Observe que a classe possui Gets e Sets para acessá-la, construtor e métodos implementados como o To String. No entanto, dependendo da utilização essas informações podem ser redundantes e gerar replicação de código desnecessária. Assim, surgiram os records. + +## Mesma classe utilizando Records. + +Observe como o código foi simplificado em apenas uma linha. Esse é o poder dessa classe, agora os métodos de acesso a classe não precisam ser criados manualmente, logo, serão instanciados de acordo com a necessidade do código. + +```java +public record User(String name, String password){} +``` + +Vamos instanciar um objeto User. + +```java +User user = new User("admin", "45454*aa"); +``` + +Agora vamos acessar esses dados. + +```java +String name = user.name(); + +String password = user.password(); + +``` +## Conclusão + +O recurso de Records no Java nos dá algumas vantagens, como, por exemplo: + +` + +- Sintaxe mais concisa: Records permitem definir classes de dados imutáveis de forma mais concisa, eliminando a necessidade de escrever o código repetitivo que normalmente é necessário para definir uma classe Java. + +- Redução de código boilerplate: Como os Records fornecem métodos padrão, como `equals()`, `hashCode()` e `toString()`, eles reduzem a quantidade de código boilerplate necessário para definir uma classe Java. + +- Imutabilidade: Como os Records são imutáveis por padrão, eles fornecem uma maneira mais segura e fácil de trabalhar com dados imutáveis. + +- Mais fácil de ler e manter: A sintaxe simplificada do Records torna mais fácil de ler e manter o código, pois é mais fácil de entender a intenção do código. + +- Melhor compatibilidade com APIs existentes: Os Records foram projetados para serem compatíveis com as APIs existentes, permitindo que os desenvolvedores usem +Records em conjunto com outras classes Java sem problemas. + + +Por outro lado, eles também possuem algumas desvantagens, como, por exemplo: + +- Restrições na personalização de métodos: Por padrão, os Records fornecem métodos padrão, como `equals()`, `hashCode()` e `toString()`, que não podem ser personalizados. Embora seja possível fornecer uma implementação personalizada desses métodos, isso pode ser menos conveniente do que simplesmente estendê-los ou anulá-los em uma classe normal. + +- Limitações na herança: Os Records não suportam herança de classe, o que significa que não é possível estender um Record em outra classe. Isso pode ser um problema se você precisar adicionar funcionalidade a uma classe Record existente. + +- Maior complexidade em casos complexos: Em casos complexos, os Records podem se tornar mais difíceis de entender e manter do que as classes Java normais, devido a uma sintaxe mais compacta e a recursos específicos que podem ser difíceis de entender. + +- Restrições de visibilidade: a visibilidade dos campos e métodos em um record é limitada. Todos os campos são automaticamente finais e privados, e os métodos são todos públicos. \ No newline at end of file From 81acfffc2e98ac4ee8e95429342bc537e7177e46 Mon Sep 17 00:00:00 2001 From: Kaique Vieira <123115955+kaiquevieirasoares@users.noreply.github.com> Date: Fri, 23 Aug 2024 07:12:58 -0300 Subject: [PATCH 2/9] =?UTF-8?q?docs:=20=204=20-=20Intermedi=C3=A1rio/16-re?= =?UTF-8?q?cords.md=20-=20refatorando=20texto.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Eduardo Cabral <47820549+FerroEduardo@users.noreply.github.com> --- "4 - Intermedi\303\241rio/16-records.md" | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git "a/4 - Intermedi\303\241rio/16-records.md" "b/4 - Intermedi\303\241rio/16-records.md" index 9ca835a..b135756 100644 --- "a/4 - Intermedi\303\241rio/16-records.md" +++ "b/4 - Intermedi\303\241rio/16-records.md" @@ -60,7 +60,7 @@ public class User { ``` -Observe que a classe possui Gets e Sets para acessá-la, construtor e métodos implementados como o To String. No entanto, dependendo da utilização essas informações podem ser redundantes e gerar replicação de código desnecessária. Assim, surgiram os records. +Observe que a classe possui Getters e Setters para acessá-la, construtor e métodos implementados, como o `toString`. No entanto, dependendo da utilização essas informações podem ser redundantes e gerar replicação de código desnecessária. Assim, surgiram os records. ## Mesma classe utilizando Records. From 742de08ed6bc75c95def5ff3ec3bb5ab74c1890c Mon Sep 17 00:00:00 2001 From: Kaique Vieira <123115955+kaiquevieirasoares@users.noreply.github.com> Date: Fri, 23 Aug 2024 07:13:58 -0300 Subject: [PATCH 3/9] =?UTF-8?q?docs:=20=204=20-=20Intermedi=C3=A1rio/16-re?= =?UTF-8?q?cords.md=20-=20arrumando=20espa=C3=A7amento.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Eduardo Cabral <47820549+FerroEduardo@users.noreply.github.com> --- "4 - Intermedi\303\241rio/16-records.md" | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git "a/4 - Intermedi\303\241rio/16-records.md" "b/4 - Intermedi\303\241rio/16-records.md" index b135756..9dc0645 100644 --- "a/4 - Intermedi\303\241rio/16-records.md" +++ "b/4 - Intermedi\303\241rio/16-records.md" @@ -41,7 +41,7 @@ public class User { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; User user = (User) o; - return name.equals(user.name) && password.equals(user.password); + return name.equals(user.name) && password.equals(user.password); } @Override From 6821d9e585baeb313080b081e4d39d4e6b6f7695 Mon Sep 17 00:00:00 2001 From: Kaique Vieira <123115955+kaiquevieirasoares@users.noreply.github.com> Date: Fri, 23 Aug 2024 07:14:46 -0300 Subject: [PATCH 4/9] =?UTF-8?q?docs:=20=204=20-=20Intermedi=C3=A1rio/16-re?= =?UTF-8?q?cords.md=20-=20removendo=20linha=20desnecess=C3=A1ria..?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Eduardo Cabral <47820549+FerroEduardo@users.noreply.github.com> --- "4 - Intermedi\303\241rio/16-records.md" | 2 -- 1 file changed, 2 deletions(-) diff --git "a/4 - Intermedi\303\241rio/16-records.md" "b/4 - Intermedi\303\241rio/16-records.md" index 9dc0645..b2f4656 100644 --- "a/4 - Intermedi\303\241rio/16-records.md" +++ "b/4 - Intermedi\303\241rio/16-records.md" @@ -88,8 +88,6 @@ String password = user.password(); O recurso de Records no Java nos dá algumas vantagens, como, por exemplo: -` - - Sintaxe mais concisa: Records permitem definir classes de dados imutáveis de forma mais concisa, eliminando a necessidade de escrever o código repetitivo que normalmente é necessário para definir uma classe Java. - Redução de código boilerplate: Como os Records fornecem métodos padrão, como `equals()`, `hashCode()` e `toString()`, eles reduzem a quantidade de código boilerplate necessário para definir uma classe Java. From 7a0b4434ee6d0ed2b6ed525d4d6f79edb1809402 Mon Sep 17 00:00:00 2001 From: Kaique Vieira <123115955+kaiquevieirasoares@users.noreply.github.com> Date: Fri, 23 Aug 2024 07:16:28 -0300 Subject: [PATCH 5/9] =?UTF-8?q?docs:=20=204=20-=20Intermedi=C3=A1rio/16-re?= =?UTF-8?q?cords.md=20-=20refatorando=20texto.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Eduardo Cabral <47820549+FerroEduardo@users.noreply.github.com> --- "4 - Intermedi\303\241rio/16-records.md" | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git "a/4 - Intermedi\303\241rio/16-records.md" "b/4 - Intermedi\303\241rio/16-records.md" index b2f4656..d035ceb 100644 --- "a/4 - Intermedi\303\241rio/16-records.md" +++ "b/4 - Intermedi\303\241rio/16-records.md" @@ -90,7 +90,7 @@ O recurso de Records no Java nos dá algumas vantagens, como, por exemplo: - Sintaxe mais concisa: Records permitem definir classes de dados imutáveis de forma mais concisa, eliminando a necessidade de escrever o código repetitivo que normalmente é necessário para definir uma classe Java. -- Redução de código boilerplate: Como os Records fornecem métodos padrão, como `equals()`, `hashCode()` e `toString()`, eles reduzem a quantidade de código boilerplate necessário para definir uma classe Java. +- Redução de código boilerplate: Como os Records fornecem métodos padrão, como `equals()`, `hashCode()` e `toString()`, eles reduzem a quantidade de código boilerplate em classes tradicionais. - Imutabilidade: Como os Records são imutáveis por padrão, eles fornecem uma maneira mais segura e fácil de trabalhar com dados imutáveis. From 2eb8a2d30625361d84202923d6692c7fb61e949d Mon Sep 17 00:00:00 2001 From: Kaique Vieira <123115955+kaiquevieirasoares@users.noreply.github.com> Date: Fri, 23 Aug 2024 07:17:35 -0300 Subject: [PATCH 6/9] =?UTF-8?q?docs:=20=204=20-=20Intermedi=C3=A1rio/16-re?= =?UTF-8?q?cords.md=20-=20refatorando=20texto.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Eduardo Cabral <47820549+FerroEduardo@users.noreply.github.com> --- "4 - Intermedi\303\241rio/16-records.md" | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git "a/4 - Intermedi\303\241rio/16-records.md" "b/4 - Intermedi\303\241rio/16-records.md" index d035ceb..bd4a0bb 100644 --- "a/4 - Intermedi\303\241rio/16-records.md" +++ "b/4 - Intermedi\303\241rio/16-records.md" @@ -108,4 +108,4 @@ Por outro lado, eles também possuem algumas desvantagens, como, por exemplo: - Maior complexidade em casos complexos: Em casos complexos, os Records podem se tornar mais difíceis de entender e manter do que as classes Java normais, devido a uma sintaxe mais compacta e a recursos específicos que podem ser difíceis de entender. -- Restrições de visibilidade: a visibilidade dos campos e métodos em um record é limitada. Todos os campos são automaticamente finais e privados, e os métodos são todos públicos. \ No newline at end of file +- Restrições de visibilidade: a visibilidade dos campos e métodos em um record é limitada. Todos os campos são automaticamente finais e privados, e os métodos gerados são todos públicos. \ No newline at end of file From 409b2854ae6af194c92d1988618b485c26dcc7e3 Mon Sep 17 00:00:00 2001 From: Kaique Vieira <123115955+kaiquevieirasoares@users.noreply.github.com> Date: Fri, 23 Aug 2024 07:18:08 -0300 Subject: [PATCH 7/9] =?UTF-8?q?docs:=20=204=20-=20Intermedi=C3=A1rio/16-re?= =?UTF-8?q?cords.md=20-=20refatorando=20texto.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Eduardo Cabral <47820549+FerroEduardo@users.noreply.github.com> --- "4 - Intermedi\303\241rio/16-records.md" | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git "a/4 - Intermedi\303\241rio/16-records.md" "b/4 - Intermedi\303\241rio/16-records.md" index bd4a0bb..668d451 100644 --- "a/4 - Intermedi\303\241rio/16-records.md" +++ "b/4 - Intermedi\303\241rio/16-records.md" @@ -3,10 +3,9 @@ Os Records são uma nova forma de declarar classes no Java. Eles são imutáveis por padrão, o que significa que não podemos alterar seus valores após a criação do objeto. Além disso, eles são bastante úteis para representar dados, como, por exemplo, uma entidade de banco de dados. Esse tipo de classe foi introduzida oficialmente ao Java na versão 17, portanto, podemos utilizar em nossos programas. -## Exemplo de utilização +## Exemplo de uma classe tradicional ```java -// Essa classe não é um Record. import java.util.Objects; public class User { From 7c6a2a1555881d6ee01441fad6b230a8c259d1a3 Mon Sep 17 00:00:00 2001 From: Kaique Vieira <123115955+kaiquevieirasoares@users.noreply.github.com> Date: Fri, 23 Aug 2024 07:19:59 -0300 Subject: [PATCH 8/9] =?UTF-8?q?docs:=20=204=20-=20Intermedi=C3=A1rio/16-re?= =?UTF-8?q?cords.md=20-=20refatorando=20texto.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Eduardo Cabral <47820549+FerroEduardo@users.noreply.github.com> --- "4 - Intermedi\303\241rio/16-records.md" | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git "a/4 - Intermedi\303\241rio/16-records.md" "b/4 - Intermedi\303\241rio/16-records.md" index 668d451..31ec2d9 100644 --- "a/4 - Intermedi\303\241rio/16-records.md" +++ "b/4 - Intermedi\303\241rio/16-records.md" @@ -61,10 +61,9 @@ public class User { Observe que a classe possui Getters e Setters para acessá-la, construtor e métodos implementados, como o `toString`. No entanto, dependendo da utilização essas informações podem ser redundantes e gerar replicação de código desnecessária. Assim, surgiram os records. -## Mesma classe utilizando Records. +## Exemplo utilizando Records. Observe como o código foi simplificado em apenas uma linha. Esse é o poder dessa classe, agora os métodos de acesso a classe não precisam ser criados manualmente, logo, serão instanciados de acordo com a necessidade do código. - ```java public record User(String name, String password){} ``` From 45054e1a9ae42c526154593185dcbb0bab514f70 Mon Sep 17 00:00:00 2001 From: Kaique Vieira <123115955+kaiquevieirasoares@users.noreply.github.com> Date: Fri, 23 Aug 2024 07:44:36 -0300 Subject: [PATCH 9/9] docs: 4 - 16 - records.md - refatorando texto. --- "4 - Intermedi\303\241rio/16-records.md" | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git "a/4 - Intermedi\303\241rio/16-records.md" "b/4 - Intermedi\303\241rio/16-records.md" index 31ec2d9..c35f508 100644 --- "a/4 - Intermedi\303\241rio/16-records.md" +++ "b/4 - Intermedi\303\241rio/16-records.md" @@ -100,9 +100,9 @@ Records em conjunto com outras classes Java sem problemas. Por outro lado, eles também possuem algumas desvantagens, como, por exemplo: -- Restrições na personalização de métodos: Por padrão, os Records fornecem métodos padrão, como `equals()`, `hashCode()` e `toString()`, que não podem ser personalizados. Embora seja possível fornecer uma implementação personalizada desses métodos, isso pode ser menos conveniente do que simplesmente estendê-los ou anulá-los em uma classe normal. +- Imutabilidade e Encapsulamento: Os Records são projetados para ser imutáveis, o que significa que seus campos são finais e acessíveis apenas através de métodos de acesso. Como resultado, você não pode modificar os campos diretamente, e isso limita as formas como você pode personalizar equals(), hashCode(), e toString(), já que essas operações são geralmente baseadas no estado dos campos da instância. -- Limitações na herança: Os Records não suportam herança de classe, o que significa que não é possível estender um Record em outra classe. Isso pode ser um problema se você precisar adicionar funcionalidade a uma classe Record existente. +- Limitações na herança: Os Records não suportam herança de classe, o que significa que não é possível estender um Record em outra classe. Isso pode ser um problema se você precisar adicionar funcionalidade a uma classe Record existente. No entanto, o record pode implementar interfaces e fornecer implementações para métodos abstratos definidos na interface. Isso permite que você aproveite os benefícios dos records (como a imutabilidade e a concisão) enquanto adere aos contratos definidos por interfaces. A implementação de métodos de interface em records segue as mesmas regras e práticas que em classes comuns, com algumas considerações para a imutabilidade e os métodos automáticos fornecidos pelos records. - Maior complexidade em casos complexos: Em casos complexos, os Records podem se tornar mais difíceis de entender e manter do que as classes Java normais, devido a uma sintaxe mais compacta e a recursos específicos que podem ser difíceis de entender.