Как лучше всего объявить константу в Котлине?

НО Если у меня 100 и более контактов в одном классе все статические, когда они освобождаются?

Вы собираетесь записать информацию о 100 контактах в исходный файл? Это... как правило, не туда, куда должны поступать такие данные, но ладно. 100.

Знаешь что? Это кустарная лига. Давайте сделаем 10 000 контактов, записанных в один гигантский kotlin или java файл.

Это все еще арахис, мудрый памятью. Какова доля копейки по сравнению с мировым ВВП? Что-то в этом духе. Всякий раз, когда вы загружаете файл класса, он находится в памяти. И никогда не освобождается. И это не имеет значения ни на йоту.

Все эти постоянные значения являются частью определения класса и загружаются хотя бы один раз в этом смысле, независимо от того, что вы делаете.

Правильный способ, очевидно, заключается в том, чтобы статические данные (т. е. вещи, присущие классу и никогда не меняющиеся), загружались точно один раз, а не «х раз, где х — количество экземпляров». Это семантически корректно (по своей природе неизменный, глобальный для класса материал — это static, вот что означает статика) и увеличивает «нагрузку» того факта, что этот класс был затронут на несколько процентных пунктов (вы просто добавляете ссылки ; все эти строки загружаются только один раз и загружаются независимо от того, сделаете ли вы этот материал статическим или нет, это часть определения класса. Как вы думаете, куда идут эти строки, если есть 0 экземпляров? JVM не собирается перезагружать этот файл класса из disk каждый раз, когда вы вызываете new Foo()!) - тогда как, если это один раз за экземпляр, вы можете просматривать миллионы ссылок без всякой причины.

Возможность переопределения делает разницу между ними. Взгляните на следующий пример. speed может быть свойством, постоянным для класса, но вам может понадобиться другое постоянное значение для разных подклассов.

import kotlin.reflect.KClass


open class Animal{
    
    companion object{
        val speed : Int = 1
    }
    
    var x: Int = 0
    
    fun move(){
        x += speed
        print("${this} moved to ${x}\n")
    }
}

class Dog : Animal(){
    companion object{
        val speed : Int = 3
    }
}

class Cat : Animal(){
    companion object{
        val speed : Int = 2
    }
}

fun main()
{
    val a = Animal()
    a.move()
    val c = Cat()
    c.move()
    val d = Dog()
    d.move()
}

Выход:

Animal@49c2faae moved to 1
Cat@17f052a3 moved to 1
Dog@685f4c2e moved to 1

Это не работает, потому что speed в move() всегда относится к Animal.speed. Итак, в этом случае вы хотите speed быть членом экземпляра вместо статического (или компаньона).

open class Animal{
    
    open val speed : Int = 1
    
    var x: Int = 0
    
    fun move(){
        x += speed
        print("${this} moved to ${x}\n")
    }
}

class Dog : Animal(){
    override val speed : Int = 3
}

class Cat : Animal(){
    override val speed : Int = 2
}

Выход:

Animal@37f8bb67 moved to 1
Cat@1d56ce6a moved to 2
Dog@17f052a3 moved to 3

Как правило, если значение является чем-то абсолютно независимым от отдельных экземпляров, сделайте его статическим. Напротив, если свойство звучит так, как будто свойство принадлежит отдельному экземпляру, а не принадлежит типу, даже если оно постоянно для всех экземпляров (на данный момент), я бы поместил его в качестве члена экземпляра, поскольку оно, вероятно, подлежит изменение будущего развития. Хотя совершенно нормально сделать его статичным, пока вы не обнаружите, что вам действительно нужно измениться в будущем. В приведенном выше примере вы даже можете в конечном итоге изменить speed на var вместо val, когда позже обнаружите, что каждая отдельная собака имеет разную скорость. Просто делайте то, что вам нужно в данный момент :)

В Kotlin существует множество способов определения констант. Они различаются объемом и использованием пространств имен, использованием памяти и способностью наследовать и переопределять.

Не существует единого «лучшего» подхода; это зависит от того, что представляют ваши константы и как вы их используете.

Вот несколько (упрощенных) примеров:

1. На верхнем (файловом) уровне:

const val a = "A"

Объявление «свободно» в файле, не содержится ни в одном классе. Обычно это самый простой и лаконичный способ, но он может не прийти в голову людям, привыкшим к Java, поскольку прямого эквивалента в Java у него нет.

Константа доступна в любом месте файла (в виде голого a); и если он не частный, его также можно использовать где угодно (либо как полностью квалифицированный list.of.packages.a, либо, если он импортирован, просто как a). Он не может быть унаследован или переопределен.

2. В сопутствующем объекте:

class A {
    companion object {
        const val a = "A"
    }
}

Если вы знаете Java, это примерно эквивалентно статическому полю (как показывает вопрос). Как и в случае объявления верхнего уровня, в памяти находится только один экземпляр свойства.

Основное отличие состоит в том, что теперь он является частью A, что влияет на его масштаб и доступность: он доступен в любом месте в A и его companion object, и (если вы не ограничите его) он также может использоваться в другом месте (как list.of.packages.A.a, и A.a, если A находится в объем и просто a, если все это импортировано). (Вы не можете наследовать от синглтона, такого как сопутствующий объект, поэтому его нельзя наследовать или переопределить.)

3. В классе:

class A {
    val a = "A"
}

Это отличается как в концепции, так и на практике, потому что каждый экземпляр A имеет свое собственное свойство. Это означает, что каждый экземпляр A будет занимать дополнительные 4 или 8 байтов (или что-то еще, что нужно платформе для хранения ссылки) — даже если все они содержат одну и ту же ссылку. (Сам объект String интернирован.)

Если A или a закрыты (как здесь), это вряд ли имеет смысл ни с точки зрения смысла кода, ни с точки зрения использования памяти. (Если у вас всего несколько экземпляров, это не будет иметь большого значения — но что, если у вас в памяти сотни тысяч экземпляров?) быть под рукой. (Однако см. ниже.)

Еще раз, свойство доступно в любом месте в пределах A и (если не ограничено) в любом месте, которое может видеть a. (Обратите внимание, что в этом случае свойство не может быть open, что означает, что компилятор не может использовать его встраивание.)

4. В классе с явным геттером:

class A {
    val a get() = "A"
}

Концептуально это очень похоже на предыдущий случай: каждый экземпляр A имеет собственное свойство, которое можно переопределить в подклассах. И доступ к нему осуществляется точно таким же образом.

Однако реализация более эффективна. Эта версия предоставляет функцию-получатель — и, поскольку она не ссылается на резервное поле, компилятор его не создает. Таким образом, вы получаете все преимущества свойства класса, но без накладных расходов на память.

5. В качестве значений перечисления:

enum class A {
    A
}

Это имеет смысл только в том случае, если у вас есть ряд этих значений, которые являются примерами некоторой общей категории; но если вы это сделаете, то обычно это гораздо лучший способ сгруппировать их вместе и сделать их доступными как именованные константы.

6. Как значения в структуре, такой как массив или карта:

val letterConstants = mapOf('a' to "A")

Этот подход имеет смысл, если вы хотите искать значения программно, но если у вас много значений и вы хотите избежать загрязнения пространств имен, он все равно может иметь смысл, даже если вы когда-либо обращаетесь к нему только с помощью констант.

Его также можно загрузить (или расширить) во время выполнения (например, из файла или базы данных).

(Я уверен, что есть и другие подходы, о которых я не думал.)

Как я уже сказал, трудно рекомендовать конкретную реализацию, потому что это будет зависеть от проблемы, которую вы пытаетесь решить: что означают константы, с чем они связаны и как и где они будут использоваться.