Translation of section 2.5 to Portuguese (PT-BR)

Author: hugos94

pt-br/02.5.md

@@ -1,10 +1,10 @@
-# Object-oriented
+# Orientação a Objetos
 
-We talked about functions and structs in the last two sections, but did you ever consider using functions as fields of a struct? In this section, I will introduce you to another form of function that has a receiver, which is called `method`.
+Falamos sobre funções e estruturas nas duas últimas seções, mas você já considerou usar funções como campos de uma estrutura? Nesta seção, vou apresentá-lo a outra forma de função que possui um receptor, que é chamado `method` (método).
 
 ## method
 
-Suppose you define a "rectangle" struct and you want to calculate its area. We'd typically use the following code to achieve this goal.
+Suponha que você definiu uma estrutura "rectangle" (retângulo) e quer calcular a sua área. Geralmente, usamos o seguinte código para atingir esse objetivo.
 
 	package main
 	import "fmt"
@@ -23,30 +23,30 @@ Suppose you define a "rectangle" struct and you want to calculate its area. We'd
     	fmt.Println("Area of r1 is: ", area(r1))
     	fmt.Println("Area of r2 is: ", area(r2))
 	}
-	
-The above example can calculate a rectangle's area. We use the function called `area`, but it's not a method of the rectangle struct (like class methods in classic object-oriented languages). The function and struct are two independent things as you may notice.
 
-It's not a problem so far. However, if you also have to calculate the area of a circle, square, pentagon, or any other kind of shape, you are going to need to add additional functions with very similar names.
+O exemplo acima pode calcular a área de um retângulo. Usamos a função chamada `area`, mas ela não é um método da estrutura rectangle (como métodos de classe em linguagens orientadas a objetos clássicas). A função e a estrutura são duas coisas independentes, como você pode notar.
+
+Isto não é um problema. Entretanto, se você também tem que calcular a área de um circulo, quadrado, pentágono ou qualquer outro tipo de forma, você vai precisar adicionar funções adicionais com nomes muito semelhantes.
 
 ![](images/2.5.rect_func_without_receiver.png?raw=true)
 
-Figure 2.8 Relationship between function and struct
+Figure 2.8 Relacionamento entre funções e estruturas
+
+Evidentemente, isso não é legal. Além disso, a área deve realmente ser a propriedade de um círculo ou retângulo.
 
-Obviously that's not cool. Also, the area should really be the property of a circle or rectangle.
+Por estas razões, temos o conceito de `method`. `method` é afiliado ao tipo. Ele possui a mesma sintaxe que as funções, exceto por um parâmetro adicional após a palavra-chave `func` chamada `receiver` (receptor), que é o corpo principal desse método.
 
-For those reasons, we have the `method` concept. `method` is affiliated with type. It has the same syntax as functions do except for an additional parameter after the `func` keyword called the `receiver`, which is the main body of that method.
+Usando o mesmo exemplo, `Rectangle.area()` pertence diretamente ao rectangle, em vez de ser uma função periférica. Mais especificamente, `length`, `width` e `area()` pertencem ao rectangle.
 
-Using the same example, `Rectangle.area()` belongs directly to rectangle, instead of as a peripheral function. More specifically, `length`, `width` and `area()` all belong to rectangle.
+Como Rob Pike disse.
 
-As Rob Pike said.
+	"Um método é um função com um primeiro argumento implícito, chamado receptor."
 
-	"A method is a function with an implicit first argument, called a receiver."
-	
-Syntax of method.
+Sintaxe do método.
 
 	func (r ReceiverType) funcName(parameters) (results)
-	
-Let's change our example using `method` instead.
+
+Vamos mudar nosso exemplo usando `method` em vez disso.
 
 	package main
 	import (
@@ -81,28 +81,28 @@ Let's change our example using `method` instead.
     	fmt.Println("Area of c1 is: ", c1.area())
     	fmt.Println("Area of c2 is: ", c2.area())
 	}
-	
-Notes for using methods.
 
-- If the name of methods are the same but they don't share the same receivers, they are not the same.
-- Methods are able to access fields within receivers.
-- Use `.` to call a method in the struct, the same way fields are called. 
+Notas para o uso de métodos.
+
+- Se os nomes dos métodos são os mesmos, mas eles não compartilham os mesmos receptores, eles não são os mesmos método.
+- Métodos são capazes de acessar campos dentro de receptores.
+- Use `.` para chamar um método na estrutura, da mesma forma que os campos são chamados.
 
 ![](images/2.5.shapes_func_with_receiver_cp.png?raw=true)
 
-Figure 2.9 Methods are different in different structs
+Figure 2.9 Métodos são diferentes em diferentes estruturas
 
-In the example above, the area() methods belong to both Rectangle and Circle respectively, so the receivers are Rectangle and Circle.
+No exemplo acima, os métodos area() pertencem ao Rectangle e ao Circle respectivamente, então os receptores são Rectangle e Circle.
 
-One thing that's worth noting is that the method with a dotted line means the receiver is passed by value, not by reference. The difference between them is that a method can change its receiver's values when the receiver is passed by reference, and it gets a copy of the receiver when the receiver is passed by value.
+Um ponto que vale notar é que o método com a linha pontilhada significa que o receptor é passado por valor, não por referência. A diferença entre eles é que um método pode mudar os valores do seu receptor quando o receptor é passado por referência, e outro recebe uma cópia do receptor quando o receptor é passado por valor.
 
-Can the receiver only be a struct? Of course not. Any type can be the receiver of a method. You may be confused about customized types. Struct is a special kind of customized type -there are more customized types.
+O receptor só pode ser uma estrutura? Claro que não. Qualquer tipo pode ser o receptor de um método. Você pode estar confuso sobre tipos customizados. Estrutura é um tipo especial de tipo customizado -há mais tipos customizado.
 
-Use the following format to define a customized type.
+Use o seguinte formato para definir um tipo customizado.
 
 	type typeName typeLiteral
-	
-Examples of customized types:
+
+Exemplos de tipos customizados:
 
 	type ages int
 
@@ -116,12 +116,12 @@ Examples of customized types:
     	...
     	"December":31,
 	}
-	
-I hope that you know how to use customized types now. Similar to `typedef` in C, we use `ages` to substitute `int` in the above example.
 
-Let's get back to talking about `method`.
+Espero que você saiba usar tipos customizados agora. Semelhante ao `typedef` em C, usamos `ages` para substituir `int` no exemplo acima.
+
+Vamos voltar a falar sobre `method`.
 
-You can use as many methods in custom types as you want.
+Você pode usar quantos métodos quiser em tipos customizados.
 
 	package main
 	import "fmt"
@@ -141,7 +141,7 @@ You can use as many methods in custom types as you want.
     	color Color
 	}
 
-	type BoxList []Box //a slice of boxes
+	type BoxList []Box //uma slice de caixas
 
 	func (b Box) Volume() float64 {
     	return b.width * b.height * b.depth
@@ -195,36 +195,36 @@ You can use as many methods in custom types as you want.
 
     	fmt.Println("Obviously, now, the biggest one is", boxes.BiggestsColor().String())
 	}
-	
-We define some constants and customized types.
 
-- Use `Color` as alias of `byte`.
-- Define a struct `Box` which has fields height, width, length and color.
-- Define a struct `BoxList` which has `Box` as its field.
+Definimos algumas constantes e tipos customizados.
 
-Then we defined some methods for our customized types.
+- Usamos `Color` como apelido para `byte`.
+- Definimos uma estrutura `Box` que tem os campos height (altura), width (largura), length (comprimento) e color (cor).
+- Definimos uma estrutura `BoxList` que tem `Box` como seu campo.
 
-- Volume() uses Box as its receiver and returns volume of Box.
-- SetColor(c Color) changes Box's color.
-- BiggestsColor() returns the color which has the biggest volume.
-- PaintItBlack() sets color for all Box in BoxList to black.
-- String() use Color as its receiver, returns the string format of color name.
+Então, definimos alguns métodos para os nossos tipos customizados.
 
-Is it much clearer when we use words to describe our requirements? We often write our requirements before we start coding.
+- Volume() usa Box como seu receptor e retorna o volume de Box.
+- SetColor(c Color) muda a cor de Box.
+- BiggestsColor() retorna a cor que possui o maior volume.
+- PaintItBlack() define as cores das Box em BoxList para preto.
+- String() usa Color como seu receptor e retorna a palavra formatada do nome da cor.
 
-### Use pointer as receiver
+É muito mais claro quando usamos palavras para descrever nosso requisitos? Frequentemente escrevemos nossos requisitos antes de começar a programar.
 
-Let's take a look at `SetColor` method. Its receiver is a pointer of Box. Yes, you can use `*Box` as a receiver. Why do we use a pointer here? Because we want to change Box's color in this method. Thus, if we don't use a pointer, it will only change the value inside a copy of Box.
+### Usando ponteiro como receptor
 
-If we see that a receiver is the first argument of a method, it's not hard to understand how it works.
+Vamos dar uma olhada no método `SetColor`. Seu receptor é um ponteiro de Box. Sim, você pode usar `*Box` como um receptor. Por que usamos um ponteiro aqui? Porque queremos mudar as cores de Box neste método. Assim, se não usarmos um ponteiro, ele só mudará o valor dentro de um cópia de Box.
 
-You might be asking why we aren't using `(*b).Color=c` instead of `b.Color=c` in the SetColor() method. Either one is OK here because Go knows how to interpret the assignment. Do you think Go is more fascinating now?
+Se vemos que um receptor é o primeiro argumento de um método, não é difícil entender como ele funciona.
 
-You may also be asking whether we should use `(&bl[i]).SetColor(BLACK)` in `PaintItBlack` because we pass a pointer to `SetColor`. Again, either one is OK because Go knows how to interpret it!
+Você deve estar perguntando por que não estamos usando `(*b).Color=c` em vez de `b.Color=c` no método SetColor(). Qualquer um está OK aqui porque GO sabe como interpretar a atribuição. Você acha que Go é mais fascinante agora?
 
-### Inheritance of method
+Você também deve estar se perguntando se devemos usar `(&bl[i]).SetColor(BLACK)` em `PaintItBlack` porque passamos um ponteiro para `SetColor`. Novamente, qualquer um está OK porque Go sabe como interpretá-lo!
 
-We learned about inheritance of fields in the last section. Similarly, we also have method inheritance in Go. If an anonymous field has methods, then the struct that contains the field will have all the methods from it as well. 
+### Herança do Método
+
+Aprendemos sobre herança de campos na última seção. Similarmente, também temos herança de método em Go. Se um campo anônimo tiver métodos, então a estrutura que contém o campo terá todos os métodos dele também.
 
 	package main
 	import "fmt"
@@ -236,16 +236,16 @@ We learned about inheritance of fields in the last section. Similarly, we also h
 	}
 
 	type Student struct {
-    	Human // anonymous field
+    	Human // campo anônimo
     	school string
 	}
 
 	type Employee struct {
-    	Human 
+    	Human
     	company string
 	}
 
-	// define a method in Human
+	// define um método em Human
 	func (h *Human) SayHi() {
     	fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)
 	}
@@ -258,9 +258,9 @@ We learned about inheritance of fields in the last section. Similarly, we also h
     	sam.SayHi()
 	}
 
-### Method overload
+### Sobrecarga de Método
 
-If we want Employee to have its own method `SayHi`, we can define a method that has the same name in Employee, and it will hide `SayHi` in Human when we call it.
+Se quisermos que Employee tenha seu próprio método `SayHi`, podemos definir um método com o mesmo nome em Employee, e ele irá sobrescrever `SayHi` em Human quando nós o chamarmos.
 
 	package main
 	import "fmt"
@@ -272,12 +272,12 @@ If we want Employee to have its own method `SayHi`, we can define a method that
 	}
 
 	type Student struct {
-    	Human 
+    	Human
     	school string
 	}
 
 	type Employee struct {
-    	Human 
+    	Human
     	company string
 	}
 
@@ -287,7 +287,7 @@ If we want Employee to have its own method `SayHi`, we can define a method that
 
 	func (e *Employee) SayHi() {
     	fmt.Printf("Hi, I am %s, I work at %s. Call me on %s\n", e.name,
-        	e.company, e.phone) //Yes you can split into 2 lines here.
+        	e.company, e.phone) //Sim, você pode dividir em 2 linhas aqui.
 	}
 
 	func main() {
@@ -297,11 +297,11 @@ If we want Employee to have its own method `SayHi`, we can define a method that
     	mark.SayHi()
     	sam.SayHi()
 	}
-	
-You are able to write an Object-oriented program now, and methods use rule of capital letter to decide whether public or private as well.
+
+Você é capaz de escrever um programa Orientado a Objetos agora, e os métodos usam a regra de capital letter (letra maiúscula) para decidir se é público ou privado também.
 
 ## Links
 
-- [Directory](preface.md)
-- Previous section: [struct](02.4.md)
-- Next section: [interface](02.6.md)
+- [Sumário](preface.md)
+- Seção Anterior: [Estrutura](02.4.md)
+- Próxima Seção: [Interface](02.6.md)