Преимущество Java локальных классов
String(reflecting:) работает прямо сейчас, но может измениться в будущем. Поэтому, если вам требуется только полное имя, вы должны быть в порядке. Однако, если имя - это то, на что вы будете полагаться в течение более длительного периода времени (охватывая несколько выпусков Swift), вы не должны его использовать.
Сообщество Swift пытается прийти к консенсус относительно долгосрочного метода получения информации от типа.
From Joe Groff:
В 4.2 строка String (отражающая :) по-прежнему показывает полное имя для локальных типов, но контекст локального типа анонимен и печатается таким образом, который должен быть ясным, является нестабильным, так как независимо от того, какую поддержку отражения мы добавим в будущем, было бы неплохой идеей, чтобы случайно полагаться на наличие или идентичность локальных типов в динамическом коде.
blockquote>https://forums.swift.org/t/getting-the-more-fully-qualified-name-of-of- а-типа / 14375/9
3 ответа
Они позволяют Вам вынимать логику из родительского класса и воплощать его. Это удаляет функциональность из того, где она не принадлежит и помещает его в свой собственный класс. Но что, если этот новый объект только необходим в течение короткого времени, только на время единственного блока кода? Ну, это - то, где локальный класс вписывается.
Существует много вещей, которые можно сделать с локальными классами, которые Вы не получаете с анонимными внутренними классами.
- , потому что тип имеет имя, можно более полезно добавить участников не в супертипе
- , имя может сделать отслеживания стека легче следовать (особенно для объектов блокирования)
- подтип больше чем один базовый тип
- конструкция больше чем в одном месте и нескольких конструкторах
, С другой стороны, они делают некоторый ужасно подробный синтаксис еще более грязным.
Вот пример того, как анонимный внутренний класс, локальный внутренний класс и регулярный внутренний класс могли бы присутствовать в программе. Пример смотрит myMethod метод и InnerClass класс, существующий в MyClass класс. Ради обсуждения те классы будут все реализовывать эти Runnable интерфейс:
public class MyClass
{
public void myMethod()
{
// Anonymous inner class
Runnable r = new Runnable() {
public void run() {}
};
// Local inner class
class LocalClass implements Runnable
{
public void run() {}
}
}
// ... //
// Inner class
class InnerClass implements Runnable
{
public void run() {}
}
}
анонимный внутренний класс может привыкнуть только к для создания класса, который реализует Runnable, на самом деле не имея необходимость выписать класс и называя его, и как [1 120], krosenvold упомянул в его сообщении, он используется в качестве закрытия "бедного человека" в Java.
, Например, очень очень простой способ запуститься Thread использование анонимного внутреннего класса было бы:
new Thread(new Runnable() {
public void run()
{
// do stuff
}
}).start();
локальный внутренний класс может использоваться для создания класса, который является в локальном объеме - он не сможет быть полученным доступ из других методов за пределами [1 111].
, Если был другой метод и мы пытались сделать экземпляр LocalClass, который расположен в myMethod метод, мы не сможем сделать так:
public void anotherMethod()
{
// LocalClass is out of scope, so it won't be found,
// therefore can't instantiate.
new Thread(new LocalClass()).start();
}
внутренний класс является частью класса, в котором расположен внутренний класс. Так, например, к внутреннему классу InnerClass можно получить доступ от других классов [1 115]. Конечно, это также означает, что другой метод в [1 116] может инстанцировать внутреннего класса также.
public void anotherMethod()
{
// InnerClass is part of this MyClass. Perfectly instantiable.
new Thread(new InnerClass()).start();
}
Другая вещь об анонимном внутреннем классе и локальном внутреннем классе состоит в том, что он сможет получить доступ final переменные, которые объявляются в myMethod:
public void myMethod()
{
// Variable to access from anonymous and local inner classes.
final int myNumber = 42;
// Anonymous inner class
Runnable r = new Runnable() {
public void run()
{
System.out.println(myNumber); // Works
}
};
// Local inner class
class LocalClass implements Runnable
{
public void run()
{
System.out.println(myNumber); // Works
}
}
// ... //
Так, каковы преимущества? Используя анонимные внутренние классы и локальные внутренние классы вместо того, чтобы иметь отдельный полноценный внутренний класс или класс позволит первому иметь доступ к [1 119] переменные в методе, в котором они объявляются, и в то же время, классы локальны для самого метода, таким образом, к нему нельзя получить доступ от внешних классов и других методов в том же классе.