Понимание 'наконец' блок

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

public void deleteRows(Connection conn) throws SQLException {
    Statement statement = conn.createStatement();
    try {
        statement.execute("DELETE * FROM foo");
    } finally {
        statement.close();
    }
}

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

try { ... } finally { ... Блоки finally { ... } предназначены для обеспечения того, что что-то всегда будет выполняться при завершении метода. Они наиболее полезны для случаев исключений. Если вы обнаружили, что делаете что-то подобное:

public String thisShouldBeRefactored(List<String> foo) {
    try { 
        if(foo == null) {
            return null;
        } else if(foo.length == 1) {
            return foo.get(0);
        } else {
            return foo.get(1);
        }
    } finally {
        System.out.println("Exiting function!");
    }
}

Вы не совсем правильно используете finally. Это приводит к снижению производительности. Придерживайтесь его использования, когда у вас есть случаи исключений, которые необходимо устранить. Попробуйте рефакторить вышеприведенное следующим образом:

public String thisShouldBeRefactored(List<String> foo) {
    final String result;

    if(foo == null) {
        result = null;
    } else if(foo.length == 1) {
        result = foo.get(0);
    } else {
        result = foo.get(1);
    }

    System.out.println("Exiting function!");

    return result;
}

Блок finally выполняется, когда вы покидаете блок try. Оператор "return" выполняет две функции: во-первых, устанавливает возвращаемое значение функции, а во-вторых, выходит из функции. Обычно это выглядело бы как атомарная операция, но внутри блока try это вызовет выполнение блока finally после установки возвращаемого значения и до выхода из функции.

Возврат выполнения:

1. Назначить возвращаемое значение
2. выполнить окончательные блоки
3. функция выхода

Пример первый (примитивный):

int count = 1;//Assign local primitive count to 1
try{
  return count; //Assign primitive return value to count (1)
}finally{
  count++ //Updates count but not return value
}

Пример второй (ссылка):

StringBuilder sb = new StringBuilder();//Assign sb a new StringBuilder
try{
    return sb;//return a reference to StringBuilder
}finally{
    sb.append("hello");//modifies the returned StringBuilder
}

Пример третий (ссылка):

   StringBuilder sb = new StringBuilder();//Assign sb a new StringBuilder
   try{
      return sb;//return a reference to StringBuilder
   }finally{
      sb = null;//Update local reference sb not return value
   }

Пример четвертый (возврат):

   int count = 1;   //assign count
   try{
      return count; //return current value of count (1)
   }finally{
      count++;      //update count to two but not return value
      return count; //return current value of count (2) 
                    //replaces old return value and exits the finally block
   }

Подумайте, что компилятор фактически делает для оператора return, например, в tryOne (): он копирует ссылку на builder обратно в среду вызывающей функции. После этого, но до того, как управление вернется к вызывающей функции, выполняется блок finally. Итак, на практике у вас есть что-то более похожее на это:

protected StringBuilder tryOne() {
    StringBuilder builder = new StringBuilder();
    try {
        builder.append("Cool");
        builder.append("Return");
        StringBuilder temp = builder;
        return temp;
    } finally {
        builder = null;
    }
}

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

protected StringBuilder tryOne() {
    StringBuilder builder = new StringBuilder();
    builder.append("Cool");
    builder.append("Return");
    StringBuilder temp = builder;
    builder = null;
    return temp;
}

Итак, установка builder = null работает, но ничего полезного не делает. Однако выполнение builder.append ("something") будет иметь видимый эффект , поскольку и temp, и builder относятся к одному и тому же (изменяемому) объекту.

Аналогично, то, что на самом деле происходит в trySeven (), выглядит примерно так:

protected int trySeven() {
    int count = 0;
    count = 99;
    int temp = count;
    count++;
    return temp;
}

В этом случае, поскольку мы имеем дело с int, копии независимы, поэтому увеличение одного не влияет на другое.

Тем не менее, факт остается фактом: размещение операторов return в блоке try-finally явно сбивает с толку, поэтому, если у вас есть какой-либо выбор в этом вопросе, вам лучше переписать все так, чтобы все ваши операторы возврата находятся за пределами блоков try-finally.

Почему builder = null не работает?
Потому что вы устанавливаете для локальной ссылки значение null, которое не изменит содержимое памяти. Итак, он работает, если вы попытаетесь получить доступ к построителю после блока finally, вы получите null.
Почему работает builder.append ("+ 1")?
Поскольку вы изменяете содержимое памяти, используя ссылку, это должно работать.
Почему count ++ не работает в testFive ()?
У меня он работает нормально. Как и ожидалось, он выводит 100.

builder = null и builder.append("+1") работают. Просто они не влияют на то, что вы возвращаете. Функция возвращает то, что имеет оператор return, независимо от того, что происходит потом.

Причина разницы в том, что builder передается по ссылке. builder=null изменяет локальную копию builder. builder.append("+1") влияет на копию, хранящуюся у родителя.