Question

为什么Kotlin不允许类内的main（）函数像Java一样？为什么在课堂外允许这样做？它不是违反OOP原则吗？我很困惑！

    select {
    case client := <-h.register:
        room := h.rooms[client.roomID]
        if room == nil {
           // First client in the room, create a new one
           room = make(map[*Client]bool)
           h.rooms[client.roomID] = room
        }
        room[client] = true
    case client := <-h.unregister:
        room := h.rooms[client.roomID]
        if room != nil {
            if _, ok := room[client]; ok {
                delete(room, client)
                close(client.send)
                if len(room) == 0 {
                   // This was last client in the room, delete the room
                   delete(h.rooms, client.roomID)
                }
            }
         }
    case message := <-h.broadcast:
        room := h.rooms[message.roomID]
        if room != nil {
            for client := range room {
                select {
                case client.send <- message.data:
                default:
                    close(client.send)
                    delete(room, client)
                }
            }
            if len(room) == 0 {
                // The room was emptied while broadcasting to the room.  Delete the room.
                delete(h.rooms, message.roomID)
            }
        }
    }

试图在一个类中包含main（），但出现以下错误。

class Person ( var name : String, var age : Int) {
    // putting main here
    fun main(args : Array<String>) {
        val person = Person("Neek", 34)
        println("my name is ${person.name}")
        println("my name is ${person.age}")
    }
}

Answer 1

科特林（Kotlin）作为一种语言并不能强制您进行OOP操作。 Java是实际上使您将所做的所有操作包装到类中的仅有的一种。

您实际上可以在Kotlin的多个不同文件中的文件级别上编写所有代码。不需要课程。

如果您反编译代码并查看代码，那么声明的文件中会发生什么

fun main(args: Array<String>) {..}

是因为它被包装在一个与其所在文件同名的类中。

如果在名为Foo.kt的文件中包含上述代码，则实际上是在生成该文件

class FooKt {

     public static void main(String[] args) { }
}

类名是文件名+“ Kt”

Answer 2

您可以在Kotlin类上编写main方法，它必须在companion object内

class SuperCoolProgram {

    companion object {
        @JvmStatic
        fun main(args: Array<String>) {
            println("Hello Super Cool Program")
        }
    }

}

静态方法只能在companion object内编写，因为它是唯一的静态

Answer 3

main 方法和其他方法需要在 companion 对象块内

class TestMainMethod {

伴随对象{

  @JvmStatic
  fun main(args: Array<String>) {
     testFunc()
  }

  fun testFunc() {
  }
}
}

为什么我们不在Kotlin的类内编写main（）？

3 个答案: