feat(lang-enh): 🎸 static/default methods interface, translated

Refers: #4

book/02-language-enhancement/sections/04-static-default-in-interfaces.asc

@@ -1,126 +1,122 @@
 :java-package: src/org/j6toj8/languageenhancements
 :section-java-package: ../../../{java-package}
 
-=== Métodos `static` e `default` em Interfaces
+=== Static and default methods of an interface
 
-.Objetivo
+.Objective
 ----
 Use static and default methods of an interface including inheritance rules for a default method.
--
-Usar métodos static e default de uma interface, incluindo regras de herança para um método default. 
 ----
 
-É esperado que o candidato saiba compreender e analisar o uso da dos modificadores `static` e `default` em métodos de interfaces. 
+It is expected that the candidate can understand and analyze the use of `static` and `default` modifiers in interface methods.
 
-Antes de continuar, com base no exemplo a seguir, entenda a execução do método `main` e o que é apresentado no console após sua execução.
+Before proceeding, based on the following example, understand the execution of the `main` method and what is presented on the console after its execution.
 
 [source,java,indent=0]
 .{java-package}/staticdefaultininterfaces/StaticDefaultInInterfaces_Complete.java
 ----
 include::{section-java-package}/staticdefaultininterfaces/StaticDefaultInInterfaces_Complete.java[tag=code]
 ----
 
-.Saída no console
+.console output
 [source,console]
 ----
 10.0
-Correndo
-Pessoa Correndo Rápido
+Running
+Fast Running Person
 ----
 
-O código anterior possui dois modificadores novos para interfaces, possíveis desde o Java 8: `default` e `static`. É possível perceber que esses dois métodos possuem corpo, algo que não era possível antes em uma interface. Então, vamos entender quais são as novas possibilidades.
+The previous code has two new interface modifiers, possible since Java 8: `default` and `static`. You can see that these two methods have a body, something that was not possible before in an interface. So let's understand what the new possibilities are.
 
-. Desde o Java 8, Interfaces podem ter métodos com o modificador `static`.
+. Since Java 8, Interfaces can have methods with the `static` modifier.
 
-. Métodos com o modificador `static` em interfaces são chamados iguais aos de uma classe comum, ou seja, não fazem parte da API da interface. Dessa forma, não são herdados pelas classes que implementam essa interface.
+. Methods with the `static` modifier on interfaces are called the same as those of a standard class, i.e., they are not part of the interface API. So, they are not inherited by classes that implement this interface.
 +
 [source,java,indent=0]
 .{java-package}/staticdefaultininterfaces/StaticDefaultInInterfaces_Static.java
 ----
 include::{section-java-package}/staticdefaultininterfaces/StaticDefaultInInterfaces_Static.java[tag=code]
 ----
 
-. Desde o Java 8, Interfaces podem ter métodos com o modificador `default`.
-
-. Métodos `default` não precisam, mas podem, ser sobrescritos.
+. Since Java 8, Interfaces can have methods with the `default` modifier.
 
+. `Default` methods do not need, but can be overridden.
 +
 [source,java,indent=0]
 .{java-package}/staticdefaultininterfaces/StaticDefaultInInterfaces_Default.java
 ----
 include::{section-java-package}/staticdefaultininterfaces/StaticDefaultInInterfaces_Default.java[tag=code]
 ----
 +
-Veja que a classe `Pessoa` não sobrescreve o método `correr()`, mantendo o comportamento padrão da implementação feita na interface `Corredor`.
+Note that the `Person` class does not override the `run()` method, maintaining the default implementation behavior of the `Runner` interface.
 +
-A classe `Cavalo`, por outro lado, sobrescreve o método `correr()` para ter sua própria implementação.
+The `Horse` class, on the other hand, overrides the `run()` method to have its own implementation.
 +
-.Saída no console
+.console output
 [source,console]
 ----
-Correndo
-Galopando
+Running
+Galloping
 ----
 
-. Assim como os outros método de uma interface, os métodos `static` e `default` *são sempre `public`*, e não podem ser modificados para `private` ou `protected`.
+. Like the other methods of an interface, the `static` and `default` *methods are always `public`*, and cannot be changed to `private` or `protected`.
 +
 [source,java,indent=0]
 .{java-package}/staticdefaultininterfaces/StaticDefaultInInterfaces_AccessModifiers.java
 ----
 include::{section-java-package}/staticdefaultininterfaces/StaticDefaultInInterfaces_AccessModifiers.java[tag=code]
 ----
 
-. Diferente dos outros método de uma interface, os métodos `static` e `default` não são `abstract`, e também não podem ser. Afinal, eles possuem implementação. Apenas métodos sem implementação são `abstract`.
-
+. Unlike other interface methods, the `static` and `default` methods are not `abstract`, nor can they be. After all, they have implementation. Only methods without implementation are `abstract`.
 +
 [source,java,indent=0]
 .{java-package}/staticdefaultininterfaces/StaticDefaultInInterfaces_Abstract.java
 ----
 include::{section-java-package}/staticdefaultininterfaces/StaticDefaultInInterfaces_Abstract.java[tag=code]
 ----
 
-. Se uma classe implementa duas interfaces que possuem métodos `default` repetidos, ela obrigatoriamente deve implementar o seu próprio.
+. If a class implements two interfaces that have repeated `default` methods, it must implement its own.
 +
 [source,java,indent=0]
 .{java-package}/staticdefaultininterfaces/StaticDefaultInInterfaces_RepeatedDefault.java
 ----
 include::{section-java-package}/staticdefaultininterfaces/StaticDefaultInInterfaces_RepeatedDefault.java[tag=code]
 ----
 
-. Ao implementar múltiplas interfaces, é possível acessar a implementação `default` de uma delas.
+. By implementing multiple interfaces, you can access the `default` implementation of one of them.
 +
 [source,java,indent=0]
 .{java-package}/staticdefaultininterfaces/StaticDefaultInInterfaces_RepeatedDefaultSuper.java
 ----
 include::{section-java-package}/staticdefaultininterfaces/StaticDefaultInInterfaces_RepeatedDefaultSuper.java[tag=code]
 ----
 +
-.Saída no console
+.console output
 [source,console]
 ----
-Correndo
+Running
 ----
 
-. Quando uma interface herda de outra interface métodos `default`, estes podem ser mantidos, transformados em `abstract` ou redefinidos.
+. When an interface inherits from another interface, `default` methods can be retained, transformed into `abstract` or redefined.
 +
 [source,java,indent=0]
 .{java-package}/staticdefaultininterfaces/StaticDefaultInInterfaces_InterfaceInheritance.java
 ----
 include::{section-java-package}/staticdefaultininterfaces/StaticDefaultInInterfaces_InterfaceInheritance.java[tag=code]
 ----
 +
-Nesse exemplo, a interface `Piloto` herda de `Corredor` e mostra 3 cenários distintos:
+In this example, the `Pilot` interface inherits from `Runner` and shows 3 distinct scenarios:
 
-* Mantém o método `correr()` inalterado;
-* Altera o método `correrRapido()` para que seja `abstract`, fazendo com que qualquer classe que implemente a interface `Piloto` tenha que implementar esse método;
-* Altera o método `correrDevagar()` para que tenha sua própria implementação
+* Keep `run()` method unchanged;
+* Changes the `runFast()` method to be `abstract`, so any class that implements the `Pilot` interface has to implement this method;
+* Change `runSlow()` method to have its own implementation
 
-.Referências
+.References
 ****
 
 * Designing an Interface
 +
-Boyarsky, Jeanne; Selikoff, Scott. OCP: Oracle Certified Professional Java SE 8 Programmer II Study Guide (p. 48). Wiley. Edição do Kindle.
+Boyarsky, Jeanne; Selikoff, Scott. OCP: Oracle Certified Professional Java SE 8 Programmer II Study Guide (p. 48). Wiley. Kindle Edition.
 
 * https://www.baeldung.com/java-static-default-methods[Static and Default Methods in Interfaces in Java.]
 

src/org/j6toj8/languageenhancements/staticdefaultininterfaces/StaticDefaultInInterfaces_Abstract.java

@@ -5,20 +5,20 @@
 public class StaticDefaultInInterfaces_Abstract {
 
   // tag::code[]
-  interface Corredor {
-    default String correr() { // COMPILA - método default não é abstract
-      return "Correndo";
+  interface Runner {
+    default String run() { // COMPILES - default method is not abstract
+      return "Running";
     }
 
-    abstract default String correrRapido() { // NÃO COMPILA - método default não pode ser declarado abstract
-      return "Correndo Rápido";
+    abstract default String runFast() { // NOT COMPILING - default method cannot be declared abstract
+      return "Running fast";
     }
 
-    String correrDevagar(); // COMPILA - método comum, é abstract por padrão, mesmo que de forma implícita
+    String runSlow(); // COMPILES - common method, is abstract by default, even if implicitly
 
-    abstract String correrExtremo(); // COMPILA - método comum, declarado abstract de forma explícita
+    abstract String runExtreme(); // COMPILES - common method, explicitly declared abstract
 
-    abstract static double calculeVelocidade(int d, int t) { // NÃO COMPILA - método static não pode ser declarado abstract
+    abstract static double calculateSpeed(int d, int t) { // NOT COMPILING - static method cannot be declared abstract
       return d / t;
     }
   }

src/org/j6toj8/languageenhancements/staticdefaultininterfaces/StaticDefaultInInterfaces_AccessModifiers.java

@@ -5,21 +5,21 @@
 public class StaticDefaultInInterfaces_AccessModifiers {
 
   // tag::code[]
-  interface Corredor {
-    default String correr() { // COMPILA - não há modificador de acesso declarado, é automaticamente público
-      return "Correndo";
+  interface Runner {
+    default String run() { // COMPILES - there is no declared access modifier, it is automatically public
+      return "Running";
     }
-    public default String correrRapido() { // COMPILA - modificador de acesso público explícito
-      return "Correndo Rápido";
+    public default String runFast() { // COMPILES - explicit public access modifier
+      return "Running fast";
     }
-    protected default String correrDevagar() { // NÃO COMPILA - o método deve ser obrigatoriamente público
-      return "Correndo Devagar";
+    protected default String runSlow() { // NOT COMPILING - the method must be public
+      return "Running slow";
     }
-    private default String correrExtremo() { // NÃO COMPILA - o método deve ser obrigatoriamente público
-      return "Correndo ao Extremo";
+    private default String runExtreme() { // NOT COMPILING - the method must be public
+      return "Running to the extreme";
     }
 
-    private static double calculeVelocidade(int d, int t) { // NÃO COMPILA - o método deve ser obrigatoriamente público
+    private static double calculateSpeed(int d, int t) { // NOT COMPILING - the method must be public
       return d / t;
     }
   }

src/org/j6toj8/languageenhancements/staticdefaultininterfaces/StaticDefaultInInterfaces_Complete.java

@@ -5,28 +5,28 @@
 public class StaticDefaultInInterfaces_Complete {
 
   // tag::code[]
-  interface Corredor {
-    static double calculeVelocidade(int distancia, int tempo) {
-      return distancia / tempo;
+  interface Runner {
+    static double calculateSpeed(int distance, int time) {
+      return distance / time;
     }
 
-    default String correr() {
-      return "Correndo";
+    default String run() {
+      return "Running";
     }
 
-    String correrRapido();
+    String runFast();
   }
 
-  static class Pessoa implements Corredor {
+  static class Person implements Runner {
     @Override
-    public String correrRapido() {
-      return "Pessoa Correndo Rápido";
+    public String runFast() {
+      return "Fast Running Person";
     }
 
     public static void main(String[] args) throws IOException {
-      System.out.println(Corredor.calculeVelocidade(100, 10));
-      System.out.println(new Pessoa().correr());
-      System.out.println(new Pessoa().correrRapido());
+      System.out.println(Runner.calculateSpeed(100, 10));
+      System.out.println(new Person().run());
+      System.out.println(new Person().runFast());
     }
   }
   // end::code[]

src/org/j6toj8/languageenhancements/staticdefaultininterfaces/StaticDefaultInInterfaces_Default.java

@@ -5,25 +5,25 @@
 public class StaticDefaultInInterfaces_Default {
 
   // tag::code[]
-  interface Corredor {
-    default String correr() {
-      return "Correndo";
+  interface Runner {
+    default String run() {
+      return "Running";
     }
   }
 
-  static class Pessoa implements Corredor {
+  static class Person implements Runner {
 
   }
 
-  static class Cavalo implements Corredor {
+  static class Horse implements Runner {
     @Override
-    public String correr() {
-      return "Galopando";
+    public String run() {
+      return "Galloping";
     }
 
     public static void main(String[] args) throws IOException {
-      System.out.println(new Pessoa().correr()); 
-      System.out.println(new Cavalo().correr());
+      System.out.println(new Person().run());
+      System.out.println(new Horse().run());
     }
   }
   // end::code[]

src/org/j6toj8/languageenhancements/staticdefaultininterfaces/StaticDefaultInInterfaces_InterfaceInheritance.java

@@ -3,23 +3,23 @@
 public class StaticDefaultInInterfaces_InterfaceInheritance {
 
   // tag::code[]
-  interface Corredor {
-    default String correr() {
-      return "Correndo";
+  interface Runner {
+    default String run() {
+      return "Running";
     }
-    default String correrRapido() {
-      return "Correndo Rápido";
+    default String runFast() {
+      return "Running Fast";
     }
-    default String correrDevagar() {
-      return "Correndo Devagar";
+    default String runSlow() {
+      return "Running Slow";
     }
   }
 
-  interface Piloto extends Corredor {
-    String correrRapido();
+  interface Pilot extends Runner {
+    String runFast();
 
-    default String correrDevagar() {
-      return "Piloto Correndo Devagar";
+    default String runSlow() {
+      return "Pilot Running Slow";
     }
   }
   // end::code[]

src/org/j6toj8/languageenhancements/staticdefaultininterfaces/StaticDefaultInInterfaces_RepeatedDefault.java

@@ -3,26 +3,26 @@
 public class StaticDefaultInInterfaces_RepeatedDefault {
 
   // tag::code[]
-  interface Corredor {
-    default String correr() {
-      return "Correndo";
+  interface Runner {
+    default String run() {
+      return "Running";
     }
   }
 
-  interface Piloto {
-    default String correr() {
-      return "Piloto Correndo";
+  interface Pilot {
+    default String run() {
+      return "Pilot Running";
     }
   }
 
-  static class Pessoa implements Corredor, Piloto { // NÃO COMPILA - implementa duas interfaces com métodos repetidos e não sobrescreve
+  static class Person implements Runner, Pilot { // NOT COMPILING - implements two interfaces with repeated methods and does not overwrite
 
   }
 
-  static class Gigante implements Corredor, Piloto { // COMPILA - implementa duas interfaces com métodos repetidos, mas sobrescreve e cria sua própria implementação
+  static class Giant implements Runner, Pilot { // COMPILES - implements two interfaces with repeated methods, but overwrites and creates its own implementation
     @Override
-    public String correr() {
-      return "Gigante Correndo";
+    public String run() {
+      return "Giant Running";
     }
   }
   // end::code[]