Differences between object-oriented in different languages ​​and object-oriented in Go language

Object-oriented programming in Go language has the following differences from other languages: Class declaration: Structure is used instead of class in Go. Inheritance: There is no explicit inheritance in Go, instead anonymous fields are used. Polymorphism: implemented through interfaces and method values. Data encapsulation: Control data access through the accessibility keywords of structures and methods.

Differences in object-oriented programming: Go language and other languages

Object-oriented programming is an important programming paradigm, which is also reflected in the Go language, but There are some differences compared to other languages. Understanding these differences is crucial for Go developers.

Declaration of class

In most object-oriented languages, classes are declared with the keyword class, while in Go language, Structures act as classes. The structure is declared using the type keyword:

type Person struct {
    name string
    age  int
}

Inheritance

Traditional object-oriented languages ​​usually support inheritance, allowing subclasses to inherit from parent classes methods and properties. However, the Go language does not have an explicit inheritance mechanism. Instead, it uses anonymous fields to achieve a similar effect:

type Employee struct {
    Person
    salary int
}

Polymorphism

Polymorphism is a basic principle of object-oriented programming that allows different objects to Respond to the same messages in a consistent manner. In traditional languages, polymorphism is implemented through function overrides and virtual methods. The Go language implements similar functions through interfaces:

type Employee interface {
    GetSalary() int
}

func GetTotalSalary(employees []Employee) int {
    total := 0
    for _, e := range employees {
        total += e.GetSalary()
    }
    return total
}

Data encapsulation

Data encapsulation is the ability of an object to hide its data and communicate with the outside only through interfaces or setter/getter methods Interaction. Structures and methods in the Go language implement data encapsulation through uppercase letters for accessibility:

• Unexported Fields and methods start with lowercase letters and are only included in the same package Visible inside.
• Exported Fields and methods start with an uppercase letter and are accessible outside the package.

Practical Case

The following is a simple Go code example that shows these differences in action:

package main

import "fmt"

type Person struct {
    name string
    age  int
}

func (p Person) GetName() string {
    return p.name
}

func main() {
    p1 := Person{name: "John", age: 30}
    fmt.Println(p1.GetName()) // 会输出 "John"
}

This code shows The following object-oriented features of the Go language are introduced:

• Structures are used as classes.
• Achieve combination through anonymous fields.
• Polymorphism is achieved through interfaces.
• Achieve data encapsulation through accessibility keywords.

The above is the detailed content of Differences between object-oriented in different languages ​​and object-oriented in Go language. For more information, please follow other related articles on the PHP Chinese website!