Странное ваще поведение?

Это потому, что вы вернули значение, которое было вычислено из q до того, как вы изменили значение q в блоке finally. Вы вернули q, что оценило его значение; затем вы изменили q в блоке finally, что не повлияло на загруженное значение; затем завершение возврата с использованием оцененного значения.

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

return возвращает значение, а не ссылку. Когда return q; выполняется в catch, текущее значение ссылки q кэшируется методом как его результат. Таким образом, даже если в блоке finally вы переназначите q с новым значением, это не повлияет на значение, уже кэшированное методом.

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

} finally {
    q = "hello";
    System.out.println("finally value of q is " + q);

    return q;//here you set other value in return
}

Другой способ повлиять на возвращаемое значение — изменить состояние кэшированного объекта. Например, если бы q было List, мы могли бы добавить к нему новый элемент (но обратите внимание, что изменение состояния — это не то же самое, что переназначение нового экземпляра, точно так же, как мы можем изменить состояние переменной final, но не можем переназначить ее).

} finally {
    q.add(new Element); //this will place new element (update) in List 
    //object stored by return because it is same object from q reference
    System.out.println("finally value of q is " + q);
}

Наконец выполняется после возврата, но до того, как метод фактически вернется к вызывающей стороне. Это аналог броска. Это происходит после броска и перед выходом из блока. Возвращаемое значение уже установлено в каком-то регистре чтением переменной q. Если бы q был изменяемым, вы могли бы изменить его в finally и увидеть это изменение в вызывающем объекте. Почему это работает именно так? Во-первых, это, вероятно, наименее сложно реализовать. Во-вторых, это дает вам максимальную гибкость. Вы можете переопределить возвращаемое значение в finally с помощью явного возврата. Сохранение его по умолчанию позволяет выбрать любое поведение.

[Отредактировано после комментария от EJP, мой первый ответ не отвечал на вопрос, а также был неправильным.]
Теперь мой ответ должен быть правильным, объясняя это, поскольку блок try и блок finally завершаются нормально q возвращается. И причина, по которой возвращается значение hii, объясняется в ответе EJP. Я все еще ищу объяснение в JLS.

Взгляните на JLS 14.20.2. Выполнение try-catch-finally

Оператор try с блоком finally выполняется, сначала выполняя блок try. Тогда есть выбор:

Если выполнение блока try завершается нормально, то выполняется блок finally, и тогда есть выбор:
Если блок finally завершается нормально, то оператор try завершается нормально.
[...]

и JLS 14.17 Оператор return

Оператор return с выражением пытается передать управление вызывающему методу, который его содержит; значение выражения становится значением вызова метода. Точнее, выполнение такого оператора возврата сначала оценивает выражение. Если по какой-то причине вычисление Expression завершается внезапно, то оператор return завершается внезапно по этой же причине. Если вычисление Выражения завершается нормально, давая значение V, то оператор return завершается внезапно, причиной является возврат со значением V.

А также:

В предыдущих описаниях говорится о попытках передачи управления, а не просто о передаче управления, потому что, если в методе или конструкторе есть какие-либо операторы try (§14.20), блоки try которых содержат оператор return, тогда будут выполнены все предложения finally этих операторов try в порядок, от внутреннего к внешнему, прежде чем управление будет передано вызывающему методу или конструктору. Внезапное завершение предложения finally может нарушить передачу управления, инициированную оператором return.

Попробуйте использовать StringBuffer вместо String, и вы увидите изменение... кажется, что инструкция return блокирует возвращаемый объект, а не ссылку. Вы также можете попробовать проверить это, напечатав хэш-код:

• объект, возвращаемый из go()
• объект, наконец

• объект печатается из main()

  public static void main(String[] args){

      Test obj=new Test();
          StringBuffer a=obj.go();
          System.out.print(a);
      }
    public StringBuffer go() {
          StringBuffer q=new StringBuffer("hii");
          try {
              return q;
          }
          finally {
              q=q.append("hello");
              System.out.println("finally value of q is "+q);
          }
      }
  

Что такое блок finally?

- Согласно определению из Java "Блок finally всегда выполняется, когда блок try завершает работу. Это гарантирует, что блок finally будет выполнен, даже если возникнет непредвиденное исключение».

Таким образом, он печатает «наконец-то значение q — привет», как только он существует в блоке try и переходит к строке System.out.print(a); и печатает значение, возвращаемое методом go().

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

Ну, я нашел следующее,

Return на самом деле возвращает значение, и оно копируется в String a=obj.go();, прежде чем выполнение переходит в наконец.

Давайте проверим это, проведя следующие эксперименты.

public class Test2 {

   public static void main(String[] args) {
     Test2 obj=new Test2();
     String a=obj.go();

     System.out.print(a);
   } 


   public String go() {
     String q="hii";
     try {
        return q;
     }
     finally {
        q="hello";
        System.out.println("finally value of q is "+q);
     }
}

вывод программы

наконец-то значение q — привет

привет

и если мы возьмем StringBuffer вместо String следующим образом,

public class Test2 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Test2 obj=new Test2();
        StringBuffer a=obj.go();

        System.out.print(a);
    }


    public  StringBuffer go(){
        StringBuffer q=new StringBuffer("hii");
        try{

            return q;
        }
        finally{

            q.replace(0, q.length(), "hello");
            System.out.println("finally value of q is "+q);
            /*return q1;*/

        }

    }
}

В результате получается

наконец-то значение q — привет

привет

и, наконец, если мы возьмем int вместо String следующим образом,

public class Test2 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Test2 obj=new Test2();
        int a=obj.go();

        System.out.print(a);
    }


    public  int go(){
        int q=1;
        try{

            return q;
        }
        finally{

            q=2;
            System.out.println("finally value of q is "+q);
            /*return q1;*/

        }

    }
}

вывод

наконец значение q равно 2

1

                              **Ananlysis**

1. В первом случае верните скопированный адрес строки в переменную a, затем выполнение переходит к окончательному изменению строки. Но поскольку в случае строк мы не можем манипулировать какой-либо строкой, создается новая строка. Таким образом, в переменной a сохраняется адрес исходной строки, которая выводится на печать.

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

3. В третьем случае значение int копируется в переменную a, прежде чем выполнение перейдет к finally. и, таким образом, a получает значение 1. а затем, наконец, мы изменили значение q, которое в любом случае не меняет значение a.