Programación orientada a objetos
Los pasos básicos pitón comparativo
- Declaración de la estructura, la estructura se determina para confirmar el nombre de un nombre de clase //: xxx Clase ():
- // Determinar la estructura del campo de la confirmación atributo de clase: DEF init
- El método de preparación de la estructura confirmó // métodos de clase: xx def ():
El ejemplo más simple: escribir una estructura de jugador, que contiene cadena de nombre, cadena de género, edad int, int num, campo float64 capacidad; escribir un método que devuelve el jugador toda la información después de la llamada
package main
import "fmt"
type player struct {
name string
gender string
age int
rolenum int
ability int
}
func (p *player) callback() string {
res := fmt.Sprintf("定义球员信息如下：\n姓名：%v\n性别：%v\n年龄：%d\n球衣号码：%d\n能力值：%d\n",p.name,p.gender,p.age,p.rolenum,p.ability) //定义字符串打印的可以传递变量
return res
}
func main() {
var p1 *player = &player{"durant","male",30,35,94} //后续工程中优秀做法是把结构体指针返还给变量，因为指针传递值很小，效率高
res := p1.callback()
fmt.Println(*p1) //由于var是一个指针，所以当查看实例的时候前面会加一个&符，去掉只需要打印*p1取值即可
fmt.Println(res)
}
Golang ningún constructor, utilizando el patrón de la fábrica para resolver el problema
Un paquete no principal define una estructura, pero el, campo struct primera letra minúscula con una letra minúscula, quiere llamar a las estructuras y los campos en main (), en general, no se puede completar, seleccione el patrón de la fábrica de resolver.
Una forma convencional de escribir el paquete no puede ser importado:
package utils //创建一个utils包
type students struct { //这个结构体是小写，无法用于其他包导入
Name string
Age int
score float64 //这个结构体的字段是小写，无法用于其他包导入
}
func Student(n string,a int) *students { //写一个方法，装饰一下，方法本身首字母大写，所以可以被其他包导入，解决结构体小写问题
return &students{ //传递参数和结构体字段一模一样，返回值是结构体指针变量，存放在堆中，共享的，大家都可以使用
Name : n,
Age : a ,
}
func (s *students) Getscore() { //写一个方法，装饰一下，方法本身首字母大写，所以可以被其他包导入，解决结构体字段小写问题
return (*s).score //直接将utils函数中的score返回给一个首字母大写函数，在main包中再调用这个函数获得值
}
Utils introducido en la función principal:
package main
import (
"fmt"
"utils"
)
func main() {
var stu = utils.Student("zhaolu",20) //使用函数传递两个参数，stu接收函数的返回值也是一个指针
fmt.Println(*stu) //为了查看字段值，需要用取值符取得变量。
fmt.Println(stu.Getscore()) //这样就可以访问私有字段了
}
ideas de programación orientados a objetos - Resumen
- En primer lugar es que su punto de vista, si K8S aprendido debe encontrar la esencia de todo el K8S es abstracta (abstracción), fondo de recursos diversos tipos abstractos de recursos -> Por Tipo, Google familia de productos, que se refleja naturalmente en el Golang.
- Las propiedades y métodos de una clase de cosas comunes se extrae forman un modelo físico, esta pregunta de investigación enfoque llamado abstracto.
- Crear un modelo: el desarrollo de un sistema de cuentas bancarias, propiedades: nombre, número de cuenta, el equilibrio, el método: la retirada, la transferencia, consulta de saldo y así sucesivamente.
- orientados a objetos tres características: encapsulación, herencia, polimorfismo, diferente aplicación Golang, el debilitamiento de la forma, y no a otros lenguajes de POO se vieron obligados comparar.
Paquete de encapsulación:
- La operación de los campos de embalaje abstractos y campo juntos, dentro de los datos que hay que proteger, solamente otros paquetes de programas, para el campo puede ser operado por el operador autorizado.
- Embalaje puede ocultar los detalles de implementación, validación de datos, garantizar la seguridad de la racionalidad.
- paquete Golang es la forma de realización descrita anteriormente, el campo de estructura de paquete en la caja inferior, mediante el control de otro importación minúsculas el paquete para mejorar la seguridad de la operación del campo del modo de control de fábrica.
pasos de implementación del paquete
- La primera estructura letra minúscula, campo (no a la exportación y la importación de otros paquetes no se puede usar, similar a la del privado java).
- Cuando el paquete proporciona un patrón de fábrica para la función de estructura de la primera letra en mayúscula, similar a un constructor (juego de permiso para llamar a otra estructura de paquetes).
- Un método Set capitalizado (similar al público de Java), se utiliza para determinar las propiedades y las asignaciones (estructura de campo se establece por el permiso para llamar a otros paquetes).
Los terceros puntos destacados, aumento en el método establecido, y la lógica de negocio pueden existir restricciones en el rango de valores que se denomina una estructura de campo, debe seguir las restricciones sobre otras condiciones del proceso revocatorio Conjunto de campo estructura de paquetes.
O aumentar el método GET, o un valor de retorno del campo deseado, requerido en main () que recibe la variable correspondiente.
Por ejemplo: la desensibilización de datos se puede hacer para establecer una estructura de persona, no puede garantizar el acceso directo a la edad, crear primero un paquete de demostración
package demo
import "fmt"
type person struct {
Name string
age int
}
func Person(n string) *person { //因为Name字段为大写，所以只需要通过工厂模式提供的Person函数就直接访问
return &person{
Name : n,
}
}
func (p *person) SetAge(age int) { //因为age字段为小写，所以需要构造方法，提供设置和访问方法，不可以直接使用<引入包结构体变量>.<结构体字段>的方式使用
if age > 0 || age < 150 {
p.age = age
} else {
fmt.Println("输入的年龄不符合要求，默认为18岁")
p.age = 18
}
}
func (p *person) GetAge() int {
return p.age
}
Uso en main () métodos y establecer y obtener las llamadas establecidas, no se pueden utilizar directamente <introduce en el paquete de variables de estructura> <estructura de campo> manera usando
package main
import (
"demo"
"fmt"
)
func main() {
var p = demo.Person("马云")
p.SetAge(50)
fmt.Println(p.GetAge())
fmt.Println(*p)
fmt.Println(p.Name)
}
herencia:
-
La extracción de atributos y métodos de diferentes estructuras, escritos en una nueva estructura de los mismos atributos y métodos definidos comunes, clase padre no existe Golang en la subclase.
-
Mediante la incorporación de una estructura anónima, completa débilmente acoplados.
-
ventajas heredados: mejora de la reutilización de código; escalabilidad y mantenibilidad del código mejora.
Hay ejemplos de referencias y atributos:
type Students struct { //定义一个共有结构体属性：学生，学生一定都有姓名，年龄和学号 Name string Age int SerialNo int } type Xiaoxuesheng struct { Students //定义一个结构体是小学生，引入共有结构体属性，也就拥有了姓名，年龄和学号 angery string //小学生有一个独有属性：小学生之怒，如果需要引入其他结构体，除了共有属性之外，自由定义独有属性 }
Existen métodos y referencias ejemplificados:
FUNC (STU * Estudiantes) <nombre del método> () {..., stu.Name , tales stu.Age} // Este método también puede utilizarse en otras estructuras incrustadas en la estructura de Estudiantes.
Hay una asignación de la estructura campo de atributos:
<nuevo nombre de la estructura> <atributos comunes estructura> <Atributos comunes estructura de campo> // ejemplo, los estudiantes definen el nombre, .. Xiaoxuesheng.Students.Name = "Chun"
uso métodos un total de estructura:
. <nuevo nombre de la estructura> <atributos estructura común> <atributos común nombre de método> () // método como el aumento de un examen totales, examing (), examen de la escuela primaria Xiaoxuesheng.Students.examing ( )
En profundidad discusión de la herencia
-
La nueva estructura se puede utilizar anidado todos los campos y métodos de estructuras anónimas, es decir, la primera letra en mayúscula o minúscula campos, métodos, se pueden utilizar, se limita a un archivo .go, importe el otro no ir a probar.
-
redacción simplificada, por ejemplo, cuando los campos de definición y uso, se pueden omitir directamente estructura jerárquica de atributos comunes:
<nuevo nombre de la estructura> <estructura común atributos> <estructura de campo Atributos comunes> == <nombre de la nueva estructura. >. <atributos comunes estructura de campo> // Xiaoxuesheng.Name = "Chun"
<nuevo nombre de la estructura>. <atributos comunes estructura>. <atributos común nombre de método> () == <nuevo nombre de la estructura>. <método común atributos name> () // Xiaoxuesheng.plusbuff () = " conferido el cuidado del cuerpo" -
Si tiene el mismo nombre que los nombres de campo y el campo de un total de la estructura de la nueva estructura, entonces no va a adoptar <nuevo nombre de la estructura>. <Atributos comunes campo de estructura>, pero <nuevo nombre de la estructura> <nueva estructura campo>, por lo que el juego conforme a las reglas campo especificado una vez encontrado, asegúrese de seleccionar la primera capa externa más calificado de un nombre de campo, es decir, el principio de proximidad, que está en línea con A. <campo> no encontrará AB <field>.
-
estructura anónimo Cuando mismo modo, si una nueva estructura está incrustado en un total de dos estructuras, hay dos estructuras tienen los mismos nombres de campo, la nueva estructura usando C. <campo total>, el compilador se quejará, esta vez se debe especificar nombre para mostrar asignación, NombreCA = "perro" CBName = "gato", directamente c.name = "xx" error inevitable, el método por el mismo motivo.
-
Comprender las estructuras anónimos de relación y combinaciones de estructuras: Si una combinación de la estructura, entonces no es hereditaria, y esta vez no se puede seleccionar para simplificar la escritura, y debe utilizar el BA <field> = "xx"
ejemplificado:
(. 1) Tipo Un struct {...} tipo B struct {...} A: estructura anónima se puede simplificar, BA <A field> == B. <A field> bAName == b.name
(2) tipo A tipo struct {...} B struct {a} a ...: estructura de combinación, no se puede simplificar, BA <A field> = B. <A field>! baName = "XX" -
O una combinación de herencia, la definición de variables se puede utilizar la asignación directa anidada, si es necesario anidado C A, B struct dos estructuras anónimas, se pueden pasar punteros {C tipo A \ n- B}, de modo que la eficacia de transferencia es más alta.
Si el valor, debe escribir * ca <field> es una dirección completa. -
La herencia múltiple: no se recomienda, si es diferente herencia múltiple estructura anónimo tiene el mismo campo, se debe especificar el <nombre de la estructura anónima> <nombre del campo> Esta jerarquía es equivalente a usar un espacio de nombres diferentes que proporcionan el mismo campo.
Multi-Estado
estudio hecho las interfaces decir, el polimorfismo se logra principalmente a través de la interfaz Interfaz
