package polymorphism

import (
    "fmt"
    "testing"
)

type Code string
type Programmer interface {
    WriteHelloWorld() Code
}

type GoProgrammer struct {
}

func (g GoProgrammer) WriteHelloWorld() Code {
    return "fmt.Println(\"Hello World!\")"
}

type JavaProgrammer struct {
}

func (j JavaProgrammer) WriteHelloWorld() Code {
    return "System.out.Println(\"Hello World!\")"
}

func WriteFirstProgrammer(p Programmer) {
    fmt.Printf("%T %v\n", p, p.WriteHelloWorld())
}

func TestPolymorphism(t *testing.T) {
    goProg := GoProgrammer{}
    // goProg := new(GoProgrammer)
    javaProg := new(JavaProgrammer)
    WriteFirstProgrammer(goProg)
    WriteFirstProgrammer(javaProg)
}
老师，为什么我这样写的输出结果没有报错？
输出如下：
=== RUN TestPolymorphism
polymorphism.GoProgrammer fmt.Println("Hello World!")
*polymorphism.JavaProgrammer System.out.Println("Hello World!")
--- PASS: TestPolymorphism (0.00s)
PASS
coverage: 0.0% of statements
ok     _/E_/go_learning/src/ch12/polymorphic    0.233s

Done

goPro := new(GoProgrammer)
javaPro := new(JavaProgrammer)
WriteFirstProgram(goPro)
WriteFirstProgram(javaPro)

func WriteFirstProgram(p Programmer) {
    fmt.Printf("%T %v\n", p, p.WriteHelloWord())
}

调用 WriteFirstProgram 传值的时候 会不会涉及到子类向父类的类型转换？

go语言不支持继承，但支持多态。

下叙代码片段暑促结果怎么理解比较恰当，两次"%T"输出的类型不一致。

type FileAttrs interface {
    getPath() string
}

type File struct {
    Name string
}
type BlobFile struct {
    File
}

type TextFile struct {
    File
}

func (file *File) getPath() string {

    return fmt.Sprintf("%s/%T", file.Name, file)
}

func printFileAttrs(file FileAttrs) {
    fmt.Printf("file name: %s ? %T\n", file.getPath(), file)
}

func TestFile(t *testing.T) {

    file := &File{Name: "0"}
    bf := &BlobFile{File{Name: "1"}}
    tf := &TextFile{File{Name: "2"}}
    printFileAttrs(file)
    printFileAttrs(bf)
    printFileAttrs(tf)
}

老师您好，请问为何我写两段式的switch语句会报错呢？
switch v := p.(type) ; v {
  // code
}

会报：use of .(type) outside type switch
.(type)是只可以用在switch语句中吗？

还有就是，这里面的v的返回结果是什么呢？可以用case判断类型，但打印出的是value值