Go: Orientação a Objetos

Minha primeira struct - Introdução

Olá, meu nome é Guilherme Lima e serei o instrutor neste curso de Go.

No curso aprenderemos a trabalhar com os principais tipos da linguagem e ainda com structs, ponteiros, referências e funções.

Veremos funções com um retorno só e outras com múltiplos retornos e saberemos como utilizá-las e trabalhar com métodos.

Também aprenderemos a trabalhar com composição, encapsulamento e interface.

O foco principal do curso será a linguagem Go.

Então, se quiser aperfeiçoar o conhecimento nessa linguagem incrível, convido a participar das aulas.

Ainda não veremos o tema concorrência durante o treinamento, pois nosso alvo são as pessoas que ainda não têm muita familiaridade com o Go e querem se aprofundar.

Minha primeira struct - Variáveis e tipos

Um certo banco está com dificuldade em gerenciar suas contas correntes. Vamos auxiliá-lo criando uma aplicação em Go para a gestão das contas.

Para começar, acessaremos o nome de usuário de nosso computador e a pasta "go", em que foi instalada nossa aplicação Go. Temos três pastas e iremos em "src > github.com" e em seguida o nome do usuário que foi definido. Haverá todos os projetos criados utilizando a linguagem e criaremos um novo clicando com o botão direito e selecionando "New folder". Chamaremos esse projeto de "banco".

Usaremos o Visual Studio Code para editar o código. A utilização deste editor é aconselhável para acompanhar as aulas, apesar de qualquer outro poder ser usado também.

No VS Code clicaremos na opção "Open folder..." para abrir uma pasta. Selecionaremos "banco" e fecharemos a página de boas-vindas do programa. Ainda não há nada em nosso arquivo. Clicaremos na opção "New file", no ícone da folha em branco, e nomearemos como main.go. Todo código Go precisa de um pontapé inicial, um código que seja o ponto de partida de nossa aplicação.

Só de termos nomeado o arquivo, o compilador já sublinhará a tela de vermelho porque precisamos dizer qual é o pacote do nosso código. Então, dentro do nosso folder de "banco" teremos o arquivo main.go, e nele, precisaremos de uma função inicial. Chamaremos a função de main. Então nossa aplicação começa a partir desse código.

Dentro das chaves que abriremos depois da função, vamos inserir o código que será executado na função principal.

package main

func main(){

}

Nossa aplicação, como já foi dito, servirá para gerenciar contas correntes. Antes, precisamos saber quais campos temos nessas contas correntes. Pensando nisso, o banco já nos mandou um arquivo nos mostrando quais são os dados que guardam para manter as informações nessa conta corrente.

Uma conta corrente nesse banco tem o nome do Titular responsável pela conta, o número da Agência, o Número da Conta e o Saldo. Criaremos uma forma de guardar esses valores na memória do computador. Para guardar valores na memória, devemos criar uma variável. Começaremos com a criação da variável para o Titular da conta.

Dentro da função, escreveremos var e o nome da variável titular. Queremos armazenar nela uma palavra, referente ao nome de uma pessoa. Nesse caso, escrevemos uma palavra reservada no código chamada string. Armazenaremos nessa string o código "Guilherme". Então, criamos uma variável chamada titular do tipo string e atribuímos a ela utilizando um sinal de igual (=) a palavra "Guilherme". Colocamos "Guilherme" entre aspas porque as utilizamos no Go para a linguagem saber que dentro das aspas há uma palavra.

Tendo criado o Titular, criaremos também a Agência com var numeroAgencia. Porém, o Número da Agência não será uma palavra. Serão os números "589" que armazenaremos na variável e precisamos identificar o tipo. Para números, utilizaremos o tipo int. e não será necessário o uso de aspas no código. var numeroAgencia int = 589.

Agora, vamos gerar o Número da Conta com var numeroConta. É importante observar que estamos digitando a primeira letra minúscula, mas escrevemos as primeiras letras das próximas palavras em maiúsculas. O nome técnico desta convenção é camelCase. Como numeroConta armazenará números também, usaremos igualmente o tipo int, e teremos var numeroConta int = 123456.

O saldo, porém, será um número diferente. Não queremos que essa variável receba um número inteiro e sim um decimal fracionário, para que ele possa ter centavos. Para isso utilizamos a palavra float. O autocomplete do VS Code mostrará que temos dois tipos de float, float32 e float64. Ainda não vamos nos preocupar em diferenciá-los, mas escolheremos o tipo float64. Para testar, colocaremos um número fracionário na conta, var saldo float64 = 125,50. No entanto, não costumamos usar vírgulas, e sim o ponto.

package main

func main(){
    var titular string = "Guilherme"
    var numeroAgencia int = 589
    var numeroConta int = 123456
    var saldo float64 = 125.50

}

Salvaremos o código e veremos que vários erros terão sido sublinhados de vermelho. Os alertas serão que as variáveis foram declaradas e não foram usadas. Isso porque em Go não podemos criar uma variável e não utilizá-la para nada.

Vamos exibir esses campos na tela, ou seja, o que há nas variáveis titular, numeroConta e saldo. Digitaremos fmt, um outro pacote capaz de escrever na tela para nós, e usaremos uma propriedade .Println(). Nos parênteses passaremos as variáveis.

fmt.Println(titular, numeroAgencia, numeroConta, saldo)

Assim que salvamos, o sublinhado vermelho ficará verde e logo após o package main aparece um import "fmt", pois a biblioteca foi importada para nós. A primeira letra de Println() precisa sempre ser maiúscula.

Sendo assim, foi feita a impressão. Ainda é necesário visualizá-la. Clicaremos com o botão direito em "main.go" e selecionaremos a opção "Open in Terminal", ou abrir no terminal. Será aberto um pequeno terminal na parte inferior da tela.

Se digitarmos nesse terminal o comando ls e pressionarmos "Enter", será mostrado no terminal que temos um arquivo main.go conforme o esperado. Solicitamos a execução desse arquivo por meio de um go run e do nome do arquivo que queremos executar, ou seja, go run main.go. Agora leremos todas as informações que estão armazenadas dentro das variáveis. "Guilherme 589 123456 125.5", omitindo o "0" do valor do saldo.

Essas são as informações referentes as variáveis titular, numeroAgencia, numeroConta, saldo.

Criaremos um outro titularvar titular string "Luciene". Antes de criar os outros campos, vamos visualizar no console com fmt.Println(titular) e salvar. No entanto, quando salvarmos, aparecerá uma mensagem de erro. Ela nos avisará que titular já foi declarada no bloco anterior. Sendo assim, não podemos declarar outra variável de mesmo nome e tentarmos atribuir um valor diferente.

Por isso chamaremos a nova variável de titular2

var titular2 string = "Luciene"

fmt.Println(titular2)

Limparemos o terminal pressionando "Ctrl + L" e digitaremos go run main.go. Será exibido o nome "Luciene" além de todos os valores das variáveis declaradas anteriormente,

Então sempre precisaremos criar outra variável com outro nome para adicionar outra informação. Faremos o mesmo para as demais

var numeroAgencia2 int = 555
var numeroConta2 int= 111333
var saldo2 float64 = 200

fmt.Println(titular2, numeroagencia2, numeroConta2, saldo2)

Vamos executar e rodar e tudo dará certo, mas a manutenção do código está se tornando cada vez mais difícil. Temos dois titulares, Guilherme e Luciene. A medida que o código cresce, teremos mais variáveis e a organização se tornará mais complexa. Pensando nisso, no próximo vídeo veremos uma forma de organizar melhor as contas correntes.

Minha primeira struct - Structs

Vimos que uma conta corrente possui um Titular, uma Agência, um Número da Conta e um Saldo.

Quando criarmos outras contas correntes, elas terão esses mesmos campos e precisaremos declarar diversas variáveis. Podemos evitar esse trabalho, já que em Go temos uma forma de estruturar esses campos.

Criaremos uma estrutura de conta corrente com todos os campos necessários e quando criarmos a conta tanto do Guilherme quanto da Luciene conseguiremos utilizar a mesma estrutura com os mesmos campos.

Para criar a estrutura no Go vamos ao código e removeremos a segunda conta criada, deixando apenas a primeira para fins de comparação. Pressionaremos "Command + J" para remover nosso terminal.

Queremos criar uma estrutura chamada ContaCorrente e ela terá as variáveis titular, numeroAgencia, numeroConta e saldo. Mas se só declararmos as variáveis, o código não entenderá que essa é uma estrutura. Precisamos identificá-la e especificar os tipos de variáveis. uma string, um int, outro int e um float64.

Para dizermos para a linguagem de fato que ContaCorrente é uma estrutura, utilizamos um prefixo antes do nome dela, e depois um sufixo. O prefixo indicará que isso é um novo tipo, por isso usaremos a palavra type. Após ContaCorrente escreveremos struct, ou seja, "estrutura" em Inglês.

Devemos identificar que todos esses campos se tratam da struct, por isso vamos envolvê-los entre chaves.

type ContaCorrente struct {
    var titular       string
     var numeroAgencia int
    var numeroConta   int
    var saldo         float64
}

Pressionaremos "Command + S" para salvar, mas veremos uma marcação de erro em todos os nossos campos. O alerta será de que a palavra var não será necessária nesse contexto, pois não precisamos identificar que os campos são variáveis. Removeremos var de todos os campos antes de salvar novamente.

type ContaCorrente struct {
    titular       string
    numeroAgencia int
    numeroConta   int
    saldo         float64
}

Agora não teremos mais nenhuma indicação de erro. Criamos nossa primeira struct, um tipo que conterá vários outros tipos dentro dele. As contas dos clientes, tanto Guilherme quanto Luciene, deverão utilizar a estrutura.

Não precisaremos mais exibir todos os campos no print. Vamos passar para fmt.Println() que a partir de agora queremos trabalhar com ContaCorrente. Para deixar claro que se trata de uma estrutura, vamos abrir e fechar chaves na sequência. Se passarmos o mouse sobre ContaCorrente{} será mostrada a estrutura que criamos desse tipo.

func main() {
    fmt.Println(ContaCorrente{})
}

Vamos salvar e teclaremos "Command + J" para abrir o terminal mais uma vez. Limparemos o terminal com "Ctrl + L" e digitaremos go run main.go para rodar. Ele exibirá uns números estranhos: { 0 0 0}. Não passamos nenhuma informação e mesmo assim foram impressos esses valores.

Apesar de não termos inserido nenhum valor, os elementos ganham automaticamente um valor inicial. Esse valor é chamado de zero value ou inicialização zero. Então, pro que for string, será adicionado um vazio. Para o que for um inteiro ou do tipo float, será atribuído um "0".

Porém, não é o que queríamos. A primeira conta corrente não deve ser uma string vazia e três zeros. Ela deve ter exatamente as informações referentes ao Guilherme.

Faremos essas atribuições no próximo vídeo.

Sobre o curso Go: Orientação a Objetos

O curso Go: Orientação a Objetos possui 117 minutos de vídeos, em um total de 36 atividades. Gostou? Conheça nossos outros cursos de GoLang em Programação, ou leia nossos artigos de Programação.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Minha primeira struct
• Referência, ponteiro e métodos
• Retornos, pacotes e visibilidade
• Composição e encapsulamento
• Interface e novas structs