переменная местоположения, доступная из внутреннего класса, должна быть объявлена ​​окончательной [дубликат]

Чтобы избежать странных побочных эффектов с закрытием в java-переменных, на которые ссылается анонимный делегат, необходимо пометить как окончательный, поэтому, чтобы ссылаться на lastPrice и цену в задаче таймера, они должны быть отмечены как окончательные.

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

public class Foo {
    private PriceObject priceObject;
    private double lastPrice;
    private double price;

    public Foo(PriceObject priceObject) {
        this.priceObject = priceObject;
    }

    public void tick() {
        price = priceObject.getNextPrice(lastPrice);
        lastPrice = price;
    }
}

теперь просто создать новый Foo как final и вызовите .tick из таймера.

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

    Price priceObject = new Price();
    final Foo foo = new Foo(priceObject);

    Timer timer = new Timer();
    timer.scheduleAtFixedRate(new TimerTask() {
        public void run() {
            foo.tick();
        }
    }, delay, period);
}

вы можете просто объявить переменную вне внешнего класса. После этого вы сможете редактировать переменную из внутреннего класса. Иногда я сталкиваюсь с аналогичными проблемами при кодировании в android, поэтому объявляю переменную глобальной, и она работает для меня.

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

Изменить: На самом деле я вообще не использую анонимный класс, но соответствующий подкласс:

public class PriceData {
        private double lastPrice = 0;
        private double price = 0;

        public void setlastPrice(double lastPrice) {
            this.lastPrice = lastPrice;
        }

        public double getLastPrice() {
            return lastPrice;
        }

        public void setPrice(double price) {
            this.price = price;
        }

        public double getPrice() {
            return price;
        }
    }

    public class PriceTimerTask extends TimerTask {
        private PriceData priceData;
        private Price priceObject;

        public PriceTimerTask(PriceData priceData, Price priceObject) {
            this.priceData = priceData;
            this.priceObject = priceObject;
        }

        public void run() {
            priceData.setPrice(priceObject.getNextPrice(lastPrice));
            System.out.println();
            priceData.setLastPrice(priceData.getPrice());

        }
    }

    public static void main(String args[]) {

        int period = 2000;
        int delay = 2000;

        PriceData priceData = new PriceData();
        Price priceObject = new Price();

        Timer timer = new Timer();

        timer.scheduleAtFixedRate(new PriceTimerTask(priceData, priceObject), delay, period);
    }

Чтобы решить проблему выше, разные языки принимают разные решения.

для Java, решение является тем, что мы видим в этой статье.

для C #, решение разрешает побочные эффекты и захват по ссылке - единственный вариант.

для C ++ 11, решение должно позволить программисту принять решение. Они могут выбрать захват по значению или по ссылке. Если захват по значению, никаких побочных эффектов не произойдет, потому что ссылка на переменную действительно отличается. Если захват по ссылке, могут возникнуть побочные эффекты, но программист должен это осознать.

С анонимными классами вы фактически объявляете «безымянный» вложенный класс. Для вложенных классов компилятор создает новый автономный публичный класс с конструктором, который будет принимать все переменные, которые он использует в качестве аргументов (для «названных» вложенных классов это всегда является экземпляром исходного / охватывающего класса). Это делается потому, что среда выполнения не имеет понятия вложенных классов, поэтому должно быть (автоматическое) преобразование из вложенного в автономный класс.

Возьмите этот код, например:

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);
    }
}

Это не сработает, потому что это то, что делает компилятор под капотом:

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);
}

Исходный анонимный класс заменяется некоторым автономным классом, который генерирует компилятор (код не является точным, но должен дать вам хорошую идею):

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

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

Как вы можете видеть, автономный класс содержит ссылку к общему объекту, помните, что все в java имеет значение pass-by-value, поэтому, даже если ссылочная переменная «shared» в EnclosingClass изменяется, экземпляр, на который он указывает, не изменяется, и все остальные ссылочные переменные, указывающие на него (например, один в анонимном классе: Enclosing $ 1), не будет знать об этом. Это основная причина, по которой компилятор заставляет вас объявлять эти «общие» переменные окончательными, чтобы этот тип поведения не попадал в ваш уже запущенный код.

Теперь это происходит, когда вы используете переменную экземпляра внутри анонимного класса (это то, что вы должны сделать, чтобы решить вашу проблему, переместить логику в метод «экземпляр» или конструктор класса ):

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);
    }
}

Это компилируется отлично, потому что компилятор изменит код, так что новый сгенерированный класс Enclosing $ 1 будет содержать ссылку на экземпляр EnclosingClass, где он был создан (это только представление, но вам нужно идти):

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);
    }
}

Подобно этому, когда ссылочная переменная 'shared' в EnclosingClass переназначается, и это происходит до вызова Thread # run (), вы будете см. «другое привет», напечатанное дважды, потому что теперь EnclosingClass $ 1 # вмещающая переменная будет содержать ссылку на объект класса, где она была объявлена, поэтому изменения любого атрибута на этом объекте будут видны экземплярам EnclosingClass $ 1.

Для получения дополнительной информации по этому вопросу вы можете увидеть это замечательное сообщение в блоге (не написано мной): http: // kevinbo one.net/java_inner.html

Можете ли вы сделать поля lastPrice, priceObject и price анонимного внутреннего класса?

Я только что написал что-то, чтобы что-то описать по намерениям авторов. Я нашел, что лучше всего было бы позволить конструктору взять все объекты, а затем в реализованном методе использовать объекты-конструкторы.

Однако, если вы пишете общий класс интерфейса, вам необходимо передать объект или лучше список объектов. Это может быть сделано Object [] или даже лучше, Object ... потому что его легче вызвать.

См. Мою часть примера чуть ниже.

List<String> lst = new ArrayList<String>();
lst.add("1");
lst.add("2");        

SomeAbstractClass p = new SomeAbstractClass (lst, "another parameter", 20, true) {            

    public void perform( ) {                           
        ArrayList<String> lst = (ArrayList<String>)getArgs()[0];                        
    }

};

public abstract class SomeAbstractClass{    
    private Object[] args;

    public SomeAbstractClass(Object ... args) {
        this.args = args;           
    }      

    public abstract void perform();        

    public Object[] getArgs() {
        return args;
    }

}

Пожалуйста, смотрите это сообщение о закрытии Java, которое поддерживает это из коробки: http://mseifed.blogspot.se/2012/09/closure-implementation-for-java-5-6-and.html

Версия 1 поддерживает передачу нефинальных замыканий с автозапуском: https://github.com/MSeifeddo/Closure-implementation-for-Java-5-6-and-7/blob/master/ org / mo / close / v1 / Closure.java

    SortedSet<String> sortedNames = new TreeSet<String>();
    // NOTE! Instead of enforcing final, we pass it through the constructor
    eachLine(randomFile0, new V1<String>(sortedNames) {
        public void call(String line) {
            SortedSet<String> sortedNames = castFirst();  // Read contructor arg zero, and auto cast it
            sortedNames.add(extractName(line));
        }
    });

Потому что это запутывает, если переменная не является окончательной, так как изменения в ней не будут отобраны в анонимном классе.

Просто сделайте окончательные значения переменных «price» и «lastPrice».

- Изменить

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

Хорошие объяснения, почему вы не можете делать то, что вы пытаетесь сделать уже предоставленным. В качестве решения можно подумать:

public class foo
{
    static class priceInfo
    {
        public double lastPrice = 0;
        public double price = 0;
        public Price priceObject = new Price ();
    }

    public static void main ( String args[] )
    {

        int period = 2000;
        int delay = 2000;

        final priceInfo pi = new priceInfo ();
        Timer timer = new Timer ();

        timer.scheduleAtFixedRate ( new TimerTask ()
        {
            public void run ()
            {
                pi.price = pi.priceObject.getNextPrice ( pi.lastPrice );
                System.out.println ();
                pi.lastPrice = pi.price;

            }
        }, delay, period );
    }
}

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

то, что сработало для меня, просто определяет переменную вне этой функции вашего.

Перед тем, как основная функция объявит i.e.

Double price;
public static void main(String []args(){
--------
--------
}

При использовании анонимного класса вы можете получить доступ только к конечным переменным из содержащего класса. Поэтому вам нужно объявить, что переменные используются final (что не является для вас вариантом, поскольку вы меняете lastPrice и price ) или не используете анонимный класс.

Итак, ваши возможности - создать реальный внутренний класс, в котором вы можете перейти в переменные и использовать их обычным способом

или:

Там (и, на мой взгляд, уродливый) взломать вашу переменную lastPrice и price , которая должна объявить ее так

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

и в ваш анонимный класс вы можете установить значение, подобное этому

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

Объявить переменную как статическую и ссылаться на нее в требуемом методе с помощью className.variable

Одно из решений, о которых я заметил, не упоминается (если я не пропустил его, если бы я исправил меня), это использование переменной класса. В этой проблеме возникла попытка запустить новый поток внутри метода: new Thread(){ Do Something }.

Вызов doSomething() из следующего будет работать. Вам необязательно объявлять его final, просто нужно изменить область действия переменной, чтобы она не была собрана перед внутренним классом. Это, если, конечно, ваш процесс не огромен, и изменение сферы может создать какой-то конфликт. Я не хотел, чтобы моя переменная была окончательной, поскольку она не была окончательной / константой.

public class Test
{

    protected String var1;
    protected String var2;

    public void doSomething()
    {
        new Thread()
        {
            public void run()
            {
                System.out.println("In Thread variable 1: " + var1);
                System.out.println("In Thread variable 2: " + var2);
            }
        }.start();
    }

}

Вы не можете ссылаться на не конечные переменные, потому что Java Language Specification так говорит. Из раздела 8.1.3: «Любая локальная переменная, параметр формального метода или параметр обработчика исключений, используемые, но не объявленные во внутреннем классе, должны быть объявлены окончательными». Полный абзац. Я вижу только часть вашего кода - по моему мнению, изменение локальных переменных - это странная идея. Локальные переменные перестают существовать, когда вы покидаете функцию. Может быть, статические поля класса будут лучше?

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

использовать ClassName.this.variableName для ссылки на не конечную переменную

Основная проблема заключается в том, можно ли разрешить переменную внутри экземпляра анонимного класса во время выполнения. Не обязательно делать переменную final, если она гарантирована, что переменная находится внутри области выполнения. Например, просмотрите две переменные _statusMessage и _statusTextView внутри метода updateStatus ().

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);

                }

            });
        }
    }

}

Просто другое объяснение. Рассмотрим этот пример ниже

public class Outer{
     public static void main(String[] args){
         Outer o = new Outer();
         o.m1();        
         o=null;
     }
     public void m1(){
         //int x = 10;
         class Inner{
             Thread t = new Thread(new Runnable(){
                 public void run(){
                     for(int i=0;i<10;i++){
                         try{
                             Thread.sleep(2000);                            
                         }catch(InterruptedException e){
                             //handle InterruptedException e
                         }
                         System.out.println("Thread t running");                             
                     }
                 }
             });
         }
         new Inner().t.start();
         System.out.println("m1 Completes");
    }
}

Здесь Выход будет

m1 Завершено

Резьба t работает

Работа потока t

Thread t running

................

Теперь метод m1 () завершается, и мы присваиваем ссылочную переменную o null, теперь объект Outer Class имеет право на GC, но объект Inner Class Object все еще существует, у которого есть (Has-A) связь с потоковым объектом, который запущен. Без существующего объекта Outer class нет возможности для существующего метода m1 (), и без существующего метода m1 () нет возможности создать свою локальную переменную, но если Inner Class Object использует локальную переменную метода m1 (), тогда все будет понятно .

Чтобы решить эту проблему, мы должны создать копию локальной переменной, а затем скопировать ее в кучу с помощью объекта класса Inner, что java делает только для конечной переменной, потому что они фактически не являются переменными, они похожи константы (все происходит во время компиляции не только во время выполнения).

Если вы хотите изменить значение в вызове метода в анонимном классе, это «значение» на самом деле является URL. Итак, если вы используете Guava, вы можете написать