几种编程语言里的结构体

• 写在前面
• 内容
• • 结构体/类
  • • Java
    • Dart
    • Rust
    • Go
  • 给结构体/类添加成员方法
  • • Java
    • Dart
    • Rust
    • Go
  • 继承
  • • Java
    • Dart
    • Rust
    • Go
  • 接口
  • • Java
    • Dart
    • Rust
    • Go
• 参考

前段时间了解了一些 Rust 的东西，看到它给结构体（也就是 Java 或一些语言里所说的类）添加方法的时候，跟 Java 或者 Dart 里的不太一样。最近在看 Go，发现它也是如此。这一篇主要是对几种语言里结构体的一些东西进行简单的比较。

class Person {
    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

class Person {
  late String name;
  late int age;

  Person(this.name, this.age);
}

struct Person {
    name: String,
    age: i16,
}

Go 里的结构体需要 type和 struct两个关键字

type Person struct {
	name string
	age  int
}

public class Person {
    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void sayHello() {
        
    }
}

class Person {
  late String name;
  late int age;

  Person(this.name, this.age);

  void sayHello() {}
}

Rust 里结构体的成员方法是在外面声明，通过 impl关键字加类名表示。成员方法里还需要 &self参数来表示是属于该类实例化后里的方法。

struct Person {
    name: String,
    age: i16,
}

impl Person {
    fn say_hello(&self) {}
}

Go 和 Rust 有些相似，只是 Go 只需要声明方法，并在 func后带上类名，即可表示是类里的一个方法。

type Person struct {
	name string
	age  int
}

func (Person) sayHello() {

}

public class Student extends Person{
    public Student(String name, int age) {
        super(name, age);
    }
}

class Student extends Person {
  Student(String name, int age) : super(name, age);
}

Go 和 Rust 的所谓的面向对象不像 Java 和 Dart，所以它们在实现我们所说的“继承”上，会有些不一样。

struct Student {
    person: Person,
}

Is Go an object-oriented language?
Yes and no. Although Go has types and methods and allows an object-oriented style of programming, there is no type hierarchy. The concept of “interface” in Go provides a different approach that we believe is easy to use and in some ways more general. There are also ways to embed types in other types to provide something analogous—but not identical—to subclassing. Moreover, methods in Go are more general than in C++ or Java: they can be defined for any sort of data, even built-in types such as plain, “unboxed” integers. They are not restricted to structs (classes).
Also, the lack of a type hierarchy makes “objects” in Go feel much more lightweight than in languages such as C++ or Java.

type Student struct {
	Person
}

public interface IAction {
    void doSomething();
}

class Person implements IAction{
    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public void doSomething() {

    }
}

abstract class IAction{
  void doSomething();
}

class Person implements IAction {
  late String name;
  late int age;

  Person(this.name, this.age);

  @override
  void doSomething() {

  }
}

// 定义接口
trait IAction {
    fn do_something(&self);
}
// 类实现接口
impl IAction for Person {
    fn do_something(&self) {}
}

struct Person {
    name: String,
    age: i16,
}

// 定义接口
type IAction interface {
	doSomething()
}
// 实现接口，写法同样是声明方法的写法，只要方法名跟接口里的方法名一致，就认为实现了该接口
func (p Person) doSomething() {

}

type Person struct {
	name string
	age  int
}

Is Go an object-oriented language?