Ne peut pas se référer à un non-finale de la variable à l'intérieur d'un intérieur classe définie dans une méthode différente

Java ne supporte pas vrai fermetures, même si l'utilisation d'une classe anonyme comme vous utilisez ici (new TimerTask() { ... }) ressemble à une sorte de fermeture.

modifier - Voir les commentaires ci-dessous - ci-dessous n'est pas une bonne explication, comme KeeperOfTheSoul points.

C'est pourquoi il ne fonctionne pas:

Les variables lastPrice et les prix sont variables locales de la méthode main (). L'objet que vous créez avec la classe anonyme pourrait durer jusqu'à ce que après la main() méthode retourne.

Lorsque le main() méthode retourne, les variables locales (comme lastPrice et price) sera nettoyé de la pile, de sorte qu'ils n'existent plus après main() retourne.

Mais la classe anonyme références de l'objet de ces variables. Les choses tournent mal si la classe anonyme objet tente d'accéder à des variables après qu'ils ont été nettoyés.

En faisant lastPrice et price final, ils ne sont pas vraiment des variables, mais des constantes. Le compilateur peut alors il suffit de remplacer l'utilisation de lastPrice et price dans la classe anonyme avec les valeurs des constantes (au moment de la compilation, bien sûr), et vous n'aurez pas le problème à l'accès inexistantes des variables plus.

D'autres langages de programmation qui ne soutien de fermetures de le faire par le traitement de ces variables spécialement en rendant sûr de ne pas être détruit lorsque la méthode se termine, ainsi que la fermeture peut toujours accéder aux variables.

@Maumau: Vous pourriez faire ceci:

public static void main(String args[]) {
    int period = 2000;
    int delay = 2000;

    Timer timer = new Timer();

    timer.scheduleAtFixedRate(new TimerTask() {
        //Variables as member variables instead of local variables in main()
        private double lastPrice = 0;
        private Price priceObject = new Price();
        private double price = 0;

        public void run() {
            price = priceObject.getNextPrice(lastPrice);
            System.out.println();
            lastPrice = price;
        }
    }, delay, period);      
}

OriginalL'auteur Jesper

Vous ne pouvez accéder finale des variables à partir de la classe conteneur lors de l'utilisation d'une classe anonyme. Par conséquent, vous avez besoin de déclarer les variables utilisées final (qui n'est pas une option pour vous, puisque vous êtes l'évolution lastPrice et prix), ou de ne pas utiliser une classe anonyme.

Afin que vos options sont à créer une réelle intérieur de la classe, dans laquelle vous pouvez passer dans les variables et les utiliser dans un mode normal

ou:

Il est rapide (et à mon avis laid) hack pour votre lastPrice et prix variable qui est de la déclarer comme

final double lastPrice[1];
final double price[1];

et dans votre classe anonyme, vous pouvez définir la valeur comme cela

price[0] = priceObject.getNextPrice(lastPrice[0]);
System.out.println();
lastPrice[0] = price[0];

OriginalL'auteur Robin

Avec anonyme classes, vous êtes en fait la déclaration d'une "nameless" classe imbriquée. Pour les classes imbriquées, le compilateur génère un nouveau public autonome de la classe avec un constructeur qui prendra toutes les variables qu'il utilise comme arguments (pour le "nommé" classes imbriquées, c'est toujours une instance de l'original/classe englobante). Ceci est fait parce que l'environnement d'exécution n'a aucune notion de classes imbriquées, donc il doit y avoir un (automatique), la conversion d'une imbriquées à une classe autonome.

Prendre ce code par exemple:

public class EnclosingClass {
    public void someMethod() {
        String shared = "hello"; 
        new Thread() {
            public void run() {
                //this is not valid, won't compile
                System.out.println(shared); //this instance expects shared to point to the reference where the String object "hello" lives in heap
            }
        }.start();

        //change the reference 'shared' points to, with a new value
        shared = "other hello"; 
        System.out.println(shared);
    }
}

Qui ne fonctionnent pas, parce que c'est ce que le compilateur n'sous le capot:

public void someMethod() {
    String shared = "hello"; 
    new EnclosingClass$1(shared).start();

    //change the reference 'shared' points to, with a new value
    shared = "other hello"; 
    System.out.println(shared);
}

L'original de la classe anonyme est remplacée par la classe autonome que le compilateur génère (code n'est pas exact, mais devrait vous donner une bonne idée):

public class EnclosingClass$1 extends Thread {
    String shared;
    public EnclosingClass$1(String shared) {
        this.shared = shared;
    }

    public void run() {
        System.out.println(shared);
    }
}

Comme vous pouvez le voir, la classe autonome contient une référence à l'objet partagé, rappelez-vous que tout dans java est passé par valeur, de sorte que même si la variable de référence "partagée" dans EnclosingClass est changé, l'instance, il est pas modifié, et toutes les autres variables de référence vers celui-ci (comme celui de la classe anonyme: en Joignant$1), ne seront pas conscients de cela. C'est la principale raison pour que le compilateur vous oblige à déclarer ce "partagée" de variables, comme la finale, de sorte que ce type de comportement ne va pas dans votre déjà en cours d'exécution de code.

Maintenant, c'est ce qui arrive lorsque vous utilisez une variable d'instance, à l'intérieur d'une classe anonyme (c'est ce que vous devez faire pour résoudre votre problème, déplacez votre logique pour un "exemple" méthode ou d'un constructeur d'une classe):

public class EnclosingClass {
    String shared = "hello";
    public void someMethod() {
        new Thread() {
            public void run() {
                System.out.println(shared); //this is perfectly valid
            }
        }.start();

        //change the reference 'shared' points to, with a new value
        shared = "other hello"; 
        System.out.println(shared);
    }
}

Cette compile bien, parce que le compilateur va modifier le code, de sorte que la nouvelle classe générée en Joignant$1 contiendra une référence à l'instance de EnclosingClass où il a été instancié (ce n'est qu'une représentation, mais devrait vous aller à):

public void someMethod() {
    new EnclosingClass$1(this).start();

    //change the reference 'shared' points to, with a new value
    shared = "other hello"; 
    System.out.println(shared);
}

public class EnclosingClass$1 extends Thread {
    EnclosingClass enclosing;
    public EnclosingClass$1(EnclosingClass enclosing) {
        this.enclosing = enclosing;
    }

    public void run() {
        System.out.println(enclosing.shared);
    }
}

Comme ça, quand la variable de référence "partagée" dans EnclosingClass obtient réaffectés, et ce qui se passe avant l'appel à la Thread#run(), vous verrez des "autres bonjour" imprimé deux fois, parce que maintenant EnclosingClass$1#joignant la variable de conserver une référence à l'objet de la classe où elle est déclarée, de sorte que des modifications à n'importe quel attribut sur cet objet sera visible par les instances de EnclosingClass$1.

Pour plus d'informations sur le sujet, vous pouvez voir cet excellent blog (pas écrit par moi): http://kevinboone.net/java_inner.html

OriginalL'auteur emerino

Vous ne peut pas se référer à des non-final des variables Java Language Specification dit. De 8.1.3:

"Toute variable locale de la méthode officiel paramètre ou gestionnaire d'exception paramètre utilisé, mais non déclarée dans un intérieur de classe doit être déclarée final." Paragraphe entier.

Je ne peux voir qu'une partie de votre code - selon moi, la planification de la modification des variables locales est une idée étrange. Les variables locales cessent d'exister lorsque vous quittez la fonction. Peut-être que les champs statiques d'une classe serait mieux?

OriginalL'auteur Tadeusz Kopec

Si vous voulez modifier une valeur dans un appel de méthode dans une classe anonyme, que la "valeur" est en fait un Future. Donc, si vous utilisez la Goyave, vous pouvez écrire

...
final SettableFuture<Integer> myvalue = SettableFuture<Integer>.create();
...
someclass.run(new Runnable(){

    public void run(){
        ...
        myvalue.set(value);
        ...
    }
 }

 return myvalue.get();

OriginalL'auteur Earth Engine

Si la variable doivent être définitif, ne peut être alors que vous pouvez affecter la valeur de la variable à une autre variable, et QUE le final de sorte que vous pouvez l'utiliser à la place.

OriginalL'auteur Thorbjørn Ravn Andersen

vous pouvez simplement déclarer la variable en dehors de l'extérieur de la classe. Après cela, vous serez en mesure de modifier la variable à partir à l'intérieur de la classe. J'ai parfois confrontés à des problèmes similaires lors de l'encodage dans android, donc je déclare la variable comme globale et cela fonctionne pour moi.

OriginalL'auteur Abhijay Ghildyal

La principale préoccupation est de savoir si une variable à l'intérieur de la classe anonyme instance peut être résolu au moment de l'exécution. Ce n'est pas une nécessité pour rendre une variable final aussi longtemps que il est garanti que la variable est à l'intérieur de la portée. Par exemple, voir les deux variables _statusMessage et _statusTextView à l'intérieur de updateStatus() la méthode.

public class WorkerService extends Service {
Worker _worker;
ExecutorService _executorService;
ScheduledExecutorService _scheduledStopService;
TextView _statusTextView;
@Override
public void onCreate() {
_worker = new Worker(this);
_worker.monitorGpsInBackground();
//To get a thread pool service containing merely one thread
_executorService = Executors.newSingleThreadExecutor();
//schedule something to run in the future
_scheduledStopService = Executors.newSingleThreadScheduledExecutor();
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
ServiceRunnable runnable = new ServiceRunnable(this, startId);
_executorService.execute(runnable);
//the return value tells what the OS should
//do if this service is killed for resource reasons
//1. START_STICKY: the OS restarts the service when resources become
//available by passing a null intent to onStartCommand
//2. START_REDELIVER_INTENT: the OS restarts the service when resources
//become available by passing the last intent that was passed to the
//service before it was killed to onStartCommand
//3. START_NOT_STICKY: just wait for next call to startService, no
//auto-restart
return Service.START_NOT_STICKY;
}
@Override
public void onDestroy() {
_worker.stopGpsMonitoring();
}
@Override
public IBinder onBind(Intent intent) {
return null;
}
class ServiceRunnable implements Runnable {
WorkerService _theService;
int _startId;
String _statusMessage;
public ServiceRunnable(WorkerService theService, int startId) {
_theService = theService;
_startId = startId;
}
@Override
public void run() {
_statusTextView = MyActivity.getActivityStatusView();
//get most recently available location as a latitude /
//longtitude
Location location = _worker.getLocation();
updateStatus("Starting");
//convert lat/lng to a human-readable address
String address = _worker.reverseGeocode(location);
updateStatus("Reverse geocoding");
//Write the location and address out to a file
_worker.save(location, address, "ResponsiveUx.out");
updateStatus("Done");
DelayedStopRequest stopRequest = new DelayedStopRequest(_theService, _startId);
//schedule a stopRequest after 10 seconds
_theService._scheduledStopService.schedule(stopRequest, 10, TimeUnit.SECONDS);
}
void updateStatus(String message) {
_statusMessage = message;
if (_statusTextView != null) {
_statusTextView.post(new Runnable() {
@Override
public void run() {
_statusTextView.setText(_statusMessage);
}
});
}
}
}

OriginalL'auteur WaiKit Kung

Déclarer la variable comme statique et la référence dans la méthode requise à l'aide d'un nom de classe.variable

OriginalL'auteur shweta

Pour résoudre le problème ci-dessus, les différentes langues des décisions différentes.

pour Java, la solution est aussi ce que nous verrons dans cet article.

pour C#, la solution est de permettre à des effets secondaires et la capture par référence est la seule option.

pour le C++11, la solution est de permettre au programmeur de prendre la décision. Ils peuvent choisir de capturer par valeur ou par référence. Si la capture de la valeur, pas d'effets secondaires pourraient se produire parce que la variable référencée est en fait différent. Si la capture par référence, les effets secondaires peuvent se produire, mais le programmeur doit s'en rendre compte.

OriginalL'auteur Earth Engine