contente
Primeiro, a definição da estrutura
2. Visibilidade dos campos da estrutura
3. Campos anônimos de estruturas
Em segundo lugar, a instanciação da estrutura
2, instanciação do tipo agulha
3. Faça a instanciação do endereço
Três, inicialização da estrutura
1. Dois métodos de inicialização
2. Use "pares de valores-chave", duas inicializações de listas de valores
Quarto, use a estrutura para implementar o construtor
Quinto, a "herança" da estrutura
Primeiro, a definição da estrutura
Os tipos de dados básicos na linguagem Go podem representar as propriedades básicas de algumas coisas, mas quando queremos expressar todas ou parte das propriedades de uma coisa, obviamente não é suficiente usar um único tipo de dados básico neste momento. language fornece um tipo de dados personalizado que pode encapsular vários tipos de dados básicos.Esse tipo de dados é chamado de estrutura e o nome em inglês é struct. Ou seja, podemos definir nosso próprio tipo por meio de struct.
A orientação a objetos é implementada na linguagem Go por meio de struct.
1. Definição de estrutura
type 类型名 struct {
字段名 字段类型
字段名 字段类型
…
}1. Nome do tipo: O nome que identifica a estrutura personalizada, que não pode ser repetida no mesmo pacote.
2. Nome do campo: Indica o nome do campo da estrutura. Os nomes de campo em uma estrutura devem ser exclusivos.
3. Tipo de campo: Indica o tipo específico do campo de estrutura.
Por exemplo, vamos definir uma estrutura Person com o seguinte código:
type person struct {
name string
city string
age int8
}Campos do mesmo tipo também podem ser escritos em uma linha,
type person1 struct {
name, city string
age int8
}Dessa forma, temos um tipo personalizado de pessoa, que possui três campos: nome, cidade e idade, que representam nome, cidade e idade respectivamente. Dessa forma, podemos usar essa estrutura de pessoa para representar e armazenar facilmente as informações da pessoa no programa.
2. Visibilidade dos campos da estrutura
Campos em uma estrutura que começam com maiúsculas indicam acesso público e minúsculas indicam privado (acessível apenas no pacote que define a estrutura atual).
3. Campos anônimos de estruturas
Uma estrutura permite que seus campos membros sejam declarados apenas com o tipo e sem nome de campo.Esse tipo de campo sem nome é chamado de campo anônimo.
//Person 结构体Person类型
type Person struct {
string
int
}
func main() {
p1 := Person{
"pprof.cn",
18,
}
fmt.Printf("%#v\n", p1) //main.Person{string:"pprof.cn", int:18}
fmt.Println(p1.string, p1.int) //pprof.cn 18
}Os campos anônimos usam o nome do tipo como o nome do campo por padrão. Como a estrutura exige que o nome do campo seja exclusivo, só pode haver um campo anônimo do mesmo tipo em uma estrutura.
Em segundo lugar, a instanciação da estrutura
notas: Se declarado primeiro, então instanciado. struct só pode ser usado após a instanciação
A definição de uma estrutura é apenas uma descrição do layout da memória, e somente quando a estrutura é instanciada, a memória é realmente alocada. Portanto, os campos do struct devem ser definidos e instanciados antes que os campos do struct possam ser usados.
A instanciação consiste em criar uma área de memória consistente com o formato de acordo com o formato definido pela estrutura.A memória entre a instância da estrutura e a instância é completamente independente.
1. Instanciação básica
A estrutura em si é um tipo, que pode ser instanciado declarando a estrutura na forma de var, assim como tipos como inteiros e strings.
var ins Ttype person struct {
name string
city string
age int8
}
func main() {
var p1 person
p1.name = "pprof.cn"
p1.city = "北京"
p1.age = 18
fmt.Printf("p1=%v\n", p1) //p1={pprof.cn 北京 18}
fmt.Printf("p1=%#v\n", p1) //p1=main.person{name:"pprof.cn", city:"北京", age:18}
}2, instanciação do tipo agulha
Na linguagem Go, você também pode usar a palavra-chave new para instanciar tipos (incluindo estruturas, inteiros, números de ponto flutuante, strings, etc.), e a estrutura formará uma estrutura do tipo ponteiro após a instanciação.
O formato para usar new é o seguinte:
ins := new(T)A linguagem Go nos permite acessar os membros de um ponteiro de estrutura como uma estrutura normal .
type Player struct{
Name string
HealthPoint int
MagicPoint int
}
//指针类型
tank := new(Player)
tank.Name = "Canon"
tank.HealthPoint = 300A instância de estrutura instanciada por new é a mesma que a instanciação básica em termos de atribuição de membro.
3. Faça a instanciação do endereço
Na linguagem Go, ao realizar e pegar a operação de endereço em uma estrutura, ela é considerada uma nova operação de instanciação para o tipo. O formato do endereço é o seguinte:
ins := &T{}O seguinte usa uma estrutura para definir um comando de linha de comando (Command), que contém nomes, associações de variáveis e comentários. Instancie o endereço do ponteiro do Comando e conclua o processo de atribuição. O código é o seguinte:
type Command struct {
Name string // 指令名称
Var *int // 指令绑定的变量
Comment string // 指令的注释
}
var version int = 1
cmd := &Command{}
cmd.Name = "version"
cmd.Var = &version
cmd.Comment = "show version"Importante: A instanciação de endereço é a maneira mais extensa de instanciar uma estrutura.
func newCommand(name string, varref *int, comment string) *Command {
return &Command{
Name: name,
Var: varref,
Comment: comment,
}
}
cmd = newCommand(
"version",
&version,
"show version",
)Três, inicialização da estrutura
Quando uma estrutura é instanciada, as variáveis de membro podem ser inicializadas diretamente. Equivalente à atribuição direta ao instanciar
1. Dois métodos de inicialização
Há também duas maneiras de inicializar, inicialização direta e inicialização de endereço.
//1、直接实例化
p5 := person{
name: "pprof.cn",
city: "北京",
age: 18, //最后一个逗号必须存在，否则会报错
}
//2、取地址实例化
p6 := &person{
name: "pprof.cn",
city: "北京",
age: 18, //最后一个逗号必须存在，否则会报错
}
//备注：没有指针类型的初始化2. Use "pares de valores-chave", duas inicializações de listas de valores
Um está na forma de um campo "par chave-valor" e uma lista de vários valores. A inicialização na forma de pares chave-valor é adequada para o preenchimento seletivo de estruturas com muitos campos;
Listas de vários valores são adequadas para structs com menos campos para preencher. (Para ser franco, não escreva a chave, apenas escreva o valor diretamente)
(1) Inicialize a estrutura com um "par chave-valor"
O preenchimento de pares chave-valor é opcional e os campos que não precisam ser inicializados podem não ser preenchidos na lista de inicialização.
O valor padrão do campo após a estrutura ser instanciada é o valor padrão do tipo de campo, por exemplo: o valor é 0, a string é uma string vazia, o booleano é falso, o ponteiro é nil, etc.
O formato de inicialização do par chave-valor é o seguinte:
ins := 结构体类型名{
字段1: 字段1的值,
字段2: 字段2的值,
…
}
//示例一：
p5 := person{
name: "pprof.cn",
city: "北京",
age: 18, //最后一个逗号必须存在，否则会报错
}
fmt.Printf("p5=%#v\n", p5) //p5=main.person{name:"pprof.cn", city:"北京", age:18}
//示例二：也可以对结构体指针进行键值对初始化
p6 := &person{
name: "pprof.cn",
city: "北京",
age: 18, //最后一个逗号必须存在，否则会报错
}
fmt.Printf("p6=%#v\n", p6) //p6=&main.person{name:"pprof.cn", city:"北京", age:18}(2) Use a inicialização da lista de valores
Ao inicializar a estrutura, ela pode ser abreviada, ou seja, a chave não é escrita ao inicializar, mas o valor é escrito diretamente:
p8 := &person{
"pprof.cn",
"北京",
18,
}
fmt.Printf("p8=%#v\n", p8) //p8=&main.person{name:"pprof.cn", city:"北京", age:18}Ao inicializar com este formato, você precisa prestar atenção:
- Todos os campos da estrutura devem ser inicializados.
- A ordem em que os valores iniciais são preenchidos deve corresponder à ordem em que os campos são declarados na estrutura.
- Este método não pode ser misturado com o método de inicialização de valor-chave. (Ou seja, você não pode escrever a chave de uma vez e não escrever a chave de uma vez)
Quarto, use a estrutura para implementar o construtor
Um tipo ou struct em go não tem função construtora. O processo de inicialização de uma estrutura pode ser implementado usando o encapsulamento de funções.
Como struct é um tipo de valor, se a estrutura for complexa, a sobrecarga de desempenho da cópia de valor será relativamente grande, portanto, o construtor retornará um tipo de ponteiro de estrutura.
func newPerson(name, city string, age int8) *person {
return &person{
name: name,
city: city,
age: age,
}
}chame o construtor
p9 := newPerson("pprof.cn", "测试", 90)
fmt.Printf("%#v\n", p9)Quinto, a "herança" da estrutura
O uso de structs em Go também pode implementar herança orientada a objetos em outras linguagens de programação.
Descrição: Isso apenas simula "herança"
//Animal 动物
type Animal struct {
name string
}
func (a *Animal) move() {
fmt.Printf("%s会动！\n", a.name)
}
//Dog 狗
type Dog struct {
Feet int8
*Animal //通过嵌套匿名结构体实现继承
}
func (d *Dog) wang() {
fmt.Printf("%s会汪汪汪~\n", d.name)
}
func main() {
d1 := &Dog{
Feet: 4,
Animal: &Animal{ //注意嵌套的是结构体指针
name: "乐乐",
},
}
d1.wang() //乐乐会汪汪汪~
d1.move() //乐乐会动！
}