Kotlin全局变量声明问题：如何让Class A的fpath可在Class B及全项目访问？

Hey there! Since you're new to Kotlin and need a global fpath variable that's accessible across Class A, Class B, and your entire project, let's walk through the most common and clean approaches to make this happen.

1. Top-Level Variables (Most Recommended) #

Kotlin lets you declare variables directly at the top of a file (no need to nest them inside a class). These variables are public by default and can be accessed anywhere in your project as long as you can reach the file's package.

Here's how to set it up:

1. Create a new file (e.g., GlobalValues.kt)
2. Add your variable at the top:

// Default value can be set here; use val if you don't need to modify it later
var fpath: String = "/default/file/path"

Then in Class A, you can update it like this:

class ClassA {
    fun configurePath() {
        fpath = "/user/customized/path"
    }
}

And in Class B, just use it directly:

class ClassB {
    fun printPath() {
        println("Current file path: $fpath")
    }
}

Pro tip: If fpath doesn't need to change after initialization, use val instead of var—it's safer and avoids accidental modifications.

2. Companion Object (For Class-Bound Globals) #

If fpath logically belongs to Class A and you don't want to put it in a separate file, use a companion object. This is Kotlin's equivalent of Java's static variables.

Example in Class A:

class ClassA {
    companion object {
        // This acts like a static variable tied to Class A
        var fpath: String = "/default/path"
    }

    fun setPath(newPath: String) {
        // You can access it directly inside the class
        fpath = newPath
    }
}

To access it in Class B, reference it via the class name:

class ClassB {
    fun usePath() {
        println("Path from Class A: ${ClassA.fpath}")
    }
}

This keeps your variable associated with Class A, making your code structure more intentional.

3. Singleton Object (For Complex Global Configs) #

If fpath needs complex initialization (like loading from a config file) or you want to wrap related logic with it, use a singleton object class. This is perfect for global configuration management.

Create a singleton class:

object GlobalConfig {
    var fpath: String = run {
        // Add any complex init logic here, e.g., read from assets
        "/initial/config/path"
    }

    // Optional: Encapsulate updates with a method for better control
    fun updateFilepath(newPath: String) {
        fpath = newPath
    }
}

In Class A, update it like this:

class ClassA {
    fun setupPath() {
        GlobalConfig.updateFilepath("/user/new/path")
        // Or directly assign: GlobalConfig.fpath = "/user/new/path"
    }
}

In Class B, access it via the singleton:

class ClassB {
    fun logPath() {
        println("Global path: ${GlobalConfig.fpath}")
    }
}

This approach keeps your global state organized and makes it easier to add related functionality later.

A Quick Note on Best Practices #

• Try not to overuse global variables—they can make code harder to debug (since any part of the app can modify them). If your project is larger, consider using dependency injection to pass variables where needed instead.
• For immutable constants, always use val to ensure thread safety and prevent unintended changes.
• If your global variable is in a different package, don't forget to import it in the classes that need it (e.g., import com.yourpackage.GlobalConfig).

内容的提问来源于stack exchange，提问作者Delin Mathew