Java: Anonyme innere Klasse verwenden eine lokale variable

Wie bekomme ich den Wert von userId übergeben, um diese Methode in meine anonyme innere Unterklasse hier?

public void doStuff(String userID) {
    doOtherStuff(userID, new SuccessDelegate() {
        @Override
        public void onSuccess() {
            Log.e(TAG, "Called delegate!!!! "+ userID);
        }
    });
}

Bekomme ich diesen Fehler:

Kann nicht beziehen sich auf eine nicht-Finale variable userID innerhalb einer inneren Klasse definiert, in eine andere Methode

Ich bin mir ziemlich sicher, ich kann nicht zuordnen, es als final, da es eine variable mit einem unbekannten Wert. Ich hatte gehört, dass diese syntax wird beibehalten, Umfang, so dass ich denke, es muss einen syntax-trick, ich weiß nicht ganz, noch nicht.

schade, java erfordert Finale hier. es ist offensichtlich, compiler, dass die lokalen Variablen nicht geändert, es sollte nicht Fragen, coder, um zu bestätigen, dass. im Falle der anon-Klasse schreibt die lokale variable, die ein kompilieren Warnung genug. bad bad-design-Wahl.
möglich, Duplikat der Warum sind nur final Variablen zugänglich in der anonymen Klasse?

InformationsquelleAutor Alex Wayne | 2010-07-14

7

Sicher zuordnen können Sie es als final - legen Sie einfach das Schlüsselwort in die Deklaration der parameter:
```
public void doStuff(final String userID) {
   ...
```
Ich bin mir nicht sicher, was Sie gemeint es wird eine variable mit einem unbekannten Wert; alles, was final bedeutet, dass sobald ein Wert der Variablen zugewiesen, es kann nicht sein rezugeordnet. Da bist du nicht die änderung der Wert der userID innerhalb Ihrer Methode, es gibt kein problem, so dass es final in diesem Fall.
- Ah ok. Ich denke, dass ich nicht wirklich verstehen, wie der final Erklärung funktioniert. Danke.
InformationsquelleAutor Andrzej Doyle

Als jeder andere hier gesagt hat, lokale Variablen müssen final aufgerufen werden, indem Sie eine innere Klasse.

Hier ist (im Grunde), warum das so ist... wenn Sie den folgenden code schreiben (lange Antwort, aber an der Unterseite, Sie können Holen Sie sich die kurze version :-):

class Main
{
    private static interface Foo
    {
        void bar();
    }

    public static void main(String[] args)
    {
        final int x;
        Foo foo;

        x = 42;
        foo = new Foo()
        {
            public void bar()
            {
                System.out.println(x);
            }
        };

        foo.bar();
    }
}

der compiler übersetzt es in etwa so:

class Main
{
    private static interface Foo
    {
        void bar();
    }

    public static void main(String[] args)
    {
        final int x;
        Foo foo;

        x = 42;

        class $1
            implements Foo
        {
            public void bar()
            {
                System.out.println(x);
            }
        }

        foo = new $1();
        foo.bar();
    }
}

und dann dies:

class Main
{
    private static interface Foo
    {
        void bar();
    }

    public static void main(String[] args)
    {
        final int x;
        Foo foo;

        x = 42;
        foo = new $1(x);
        foo.bar();
    }

    private static class $1
        implements Foo
    {
        private final int x;

        $1(int val)
        {
           x = val;
        }

        public void bar()
        {
            System.out.println(x);
        }
    }
}

und schließlich zu diesem:

class Main
{
    public static void main(String[] args) 
    {
        final int x;
        Main$Foo foo;

        x = 42;
        foo = new Main$1(x);
        foo.bar();
    }
}

interface Main$Foo
{
    void bar();
}

class Main$1
    implements Main$Foo
{
    private final int x;

    Main$1(int val)
    {
       x = val;
    }

    public void bar()
    {
        System.out.println(x);
    }
}

Wichtig ist, wo es fügt der Konstruktor $1. Stellen Sie, wenn Sie dies tun könnte:

class Main
{
    private static interface Foo
    {
        void bar();
    }

    public static void main(String[] args)
    {
        int x;
        Foo foo;

        x = 42;
        foo = new Foo()
        {
            public void bar()
            {
                System.out.println(x);
            }
        };

        x = 1;

        foo.bar();
    }
}

Würden Sie erwarten, dass foo.bar() Drucke 1, aber es würde tatsächlich drucken 42. Indem die lokalen Variablen für die Letzte dieser verwirrenden situation kann nicht entstehen.

Frage: Die annon innere Klasse macht nur die automatische Kopien von final lokalen Variablen, die Sie verwendet, richtig? Keine Kopien von anderen lokalen (Finale oder nicht) - Variablen, dass es nicht direkt verwenden? Ich Frage, weil ich bin besorgt über Speicher-Lecks.

InformationsquelleAutor TofuBeer

1

Was ist das problem mit so dass es final wie in
```
public void doStuff (final String userID)
```
InformationsquelleAutor doublep
1

erklären die Methode
```
public void doStuff(final String userID)
```
Muss der Wert endgültig sein, so dass der compiler sicher sein kann das nicht ändern. Dies bedeutet, dass der compiler binden können, die Wert auf die innere Klasse, jederzeit, ohne sich Gedanken über updates.

Der Wert ändert sich nicht in Ihrem code, so ist dies ein Sicheres ändern.

InformationsquelleAutor mdma
1

In Java 8, das hat sich ein wenig etwas geändert. Sie können jetzt auf Variablen zuzugreifen, sind effektiv final. Relevante snippets und Beispiel aus der Oracle-Dokumentation (Hervorhebung von mir):
Allerdings ab Java SE 8, eine lokale Klasse kann Zugriff auf lokale
Variablen und Parameter der umschließenden Blocks, die endgültig sind, oder
effektiv final. Eine variable oder ein parameter, dessen Wert nie
geändert, nachdem es initialisiert ist, ist effektiv final. Zum Beispiel,
angenommen, die variable numberLength ist nicht final deklariert, und Sie
fügen Sie die markierte Zuordnung Anweisung in der PhoneNumber
Konstruktor:
```
PhoneNumber(String phoneNumber) {
    numberLength = 7; //From Kobit: this would be the highlighted line
    String currentNumber = phoneNumber.replaceAll(
        regularExpression, "");
    if (currentNumber.length() == numberLength)
        formattedPhoneNumber = currentNumber;
    else
        formattedPhoneNumber = null;
}
```
Weil dieser Zuweisungsanweisung die variable numberLength ist nicht
effektiv final nicht mehr. Als ein Ergebnis erzeugt der Java-compiler eine
Fehlermeldung so ähnlich wie "lokale Variablen verwiesen wird, von einer inneren
Klasse muss rechtskräftig sein oder effektiv final", wo die innere Klasse
PhoneNumber versucht, auf die numberLength variable:
```
if (currentNumber.length() == numberLength)
```
Ab Java SE 8, wenn Sie deklarieren Sie die lokale Klasse in einer Methode, es
zugreifen können der Methode Parameter. Zum Beispiel, können Sie definieren
folgende Methode, in der die Telefonnummer der lokalen Klasse:
```
public void printOriginalNumbers() {
    System.out.println("Original numbers are " + phoneNumber1 +
        " and " + phoneNumber2);
}
```
Die Methode printOriginalNumbers greift auf die Parameter
phoneNumber1 und phoneNumber2 von der Methode validatePhoneNumber
InformationsquelleAutor mkobit

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.