Java和go的多态的区别

Go 语言方法多态和java 多态的区别

首先我们来看go 语言的多态：

package main

import "fmt"

//定义接口的类型 , 首先不难看出接受者的类型是取地址类型
// 其次更简单了。
type Human interface {
	//方法，只有声明，没有实现，由别的类型（自定义类型）实现
	sayHi()
}

type Student struct {
	name string
	id   int
}

type Teacher struct {
	name string
	id   int
}

type MyStr string

func (temp *MyStr) sayHi() {
	fmt.Println("string", *temp)
}

func (temp *Student) sayHi() {
	fmt.Println("Student=", temp.name, "id=", temp.id)
}

func (temp *Teacher) sayHi() {
	fmt.Println("Teacher=", temp.name, "id=", temp.id)
}

// 定义了一个普通函数， 但是函数的参数为接口类型
func WhoSayHi(i Human) {
	i.sayHi()
}
func main() {
	s := &Student{"mike", 12}
	t := &Teacher{"luxi", 32}
	var str MyStr = "hello mike"
	// 首先在java 中， 多态的表现是，返回值不一样，参数类型不一样， 或者是参数数量不一样，我们吧这个称之为方法的重载。
	// 那么方法的重写是java 目前看来独有的 ， 我们称之为继承的子类去重写父类的表现
	// 多态包含了方法的重写和重载。在go 目前看过来， 首先多态包含了方法的重载， 至于方法的重写， 目前未接触到这种写法。
	WhoSayHi(s)
	WhoSayHi(t)
	WhoSayHi(&str)
}

func main02() {
	// 定义接口类型的变量
	var i Human
	// 如果要进行实现这个接口，在go 的实现方式就是将类型变量，赋值给i 即可
	s := &Student{"mike", 12}
	i = s
	i.sayHi()

	t := &Teacher{"luxi", 32}
	i = t
	i.sayHi()

	var str MyStr = "hello mike"
	i = &str
	i.sayHi()
}

Java 的多态包含了，方法的重写和方法的重载。 具体代码如何：1 重载

public class Father {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Father s = new Father();
        s.sayHello();
        s.sayHello("wintershii");

    }

    public void sayHello() {
        System.out.println("Hello");
    }

    public void sayHello(String name) {
        System.out.println("Hello" + " " + name);
    }
}

2 重写：
public class Father {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Son s = new Son();
        s.sayHello();
    }

    public void sayHello() {
        System.out.println("Hello");
    }
}

class Son extends Father{

    @Override
    public void sayHello() {
        // TODO Auto-generated method stub
        System.out.println("hello by ");
    }

}