Nie rozumiem, gdzie finalsłowo kluczowe jest naprawdę przydatne, gdy jest używane w parametrach metody.

Jeśli wykluczymy korzystanie z anonimowych klas, czytelność i zamierzone deklaracje, wydaje mi się to prawie bezwartościowe.

Wymuszanie, że niektóre dane pozostają stałe, nie jest tak silne, jak się wydaje.

• Jeśli parametr jest prymitywny, nie będzie miał wpływu, ponieważ parametr jest przekazywany do metody jako wartość, a zmiana go nie będzie miała wpływu poza zakres.

• Jeśli przekazujemy parametr przez referencję, wówczas sama referencja jest zmienną lokalną, a jeśli referencja zostanie zmieniona w ramach metody, nie miałoby to żadnego efektu spoza zakresu metody.

Rozważ prosty przykładowy test poniżej. Ten test jest pozytywny, chociaż metoda zmieniła wartość podanego mu odniesienia, nie ma to jednak żadnego efektu.

public void testNullify() {
    Collection<Integer> c  = new ArrayList<Integer>();      
    nullify(c);
    assertNotNull(c);       
    final Collection<Integer> c1 = c;
    assertTrue(c1.equals(c));
    change(c);
    assertTrue(c1.equals(c));
}

private void change(Collection<Integer> c) {
    c = new ArrayList<Integer>();
}

public void nullify(Collection<?> t) {
    t = null;
}

Zatrzymaj zmianę przypisania zmiennej

Chociaż te odpowiedzi są interesujące intelektualnie, nie przeczytałem krótkiej prostej odpowiedzi:

Użyj słowa kluczowego final, jeśli chcesz, aby kompilator nie mógł zostać ponownie przypisany do innego obiektu.

Niezależnie od tego, czy zmienna jest zmienną statyczną, zmienną składową, zmienną lokalną lub zmienną argument / parametr, efekt jest całkowicie taki sam.

Przykład

Zobaczmy efekt w akcji.

Rozważ tę prostą metodę, w której obydwu zmiennym ( arg i x ) można przypisać różne obiekty.

// Example use of this method: 
//   this.doSomething( "tiger" );
void doSomething( String arg ) {
  String x = arg;   // Both variables now point to the same String object.
  x = "elephant";   // This variable now points to a different String object.
  arg = "giraffe";  // Ditto. Now neither variable points to the original passed String.
}

Oznacz zmienną lokalną jako końcową . Powoduje to błąd kompilatora.

void doSomething( String arg ) {
  final String x = arg;  // Mark variable as 'final'.
  x = "elephant";  // Compiler error: The final local variable x cannot be assigned. 
  arg = "giraffe";  
}

Zamiast tego oznaczmy zmienną parametru jako końcową . To również powoduje błąd kompilatora.

void doSomething( final String arg ) {  // Mark argument as 'final'.
  String x = arg;   
  x = "elephant"; 
  arg = "giraffe";  // Compiler error: The passed argument variable arg cannot be re-assigned to another object.
}

Morał historii:

Jeśli chcesz mieć pewność, że zmienna zawsze wskazuje ten sam obiekt, zaznacz zmienną jako końcową .

Nigdy nie przypisuj ponownie argumentów

Jako dobrą praktykę programowania (w dowolnym języku), nigdy nie należy ponownie przypisywać zmiennej parametr / argument do obiektu innego niż obiekt przekazany przez metodę wywołującą. W powyższych przykładach nigdy nie należy pisać wiersza arg =. Ponieważ ludzie popełniają błędy, a programiści są ludźmi, poprośmy kompilatora o pomoc. Oznacz każdą zmienną parametru / argumentu jako „końcową”, aby kompilator mógł znaleźć i oflagować takie ponowne przypisania.

Z perspektywy czasu

Jak zauważono w innych odpowiedziach… Biorąc pod uwagę pierwotny cel projektowy Javy polegający na pomocy programistom w unikaniu głupich błędów, takich jak czytanie poza końcem tablicy, Java powinna była zostać zaprojektowana w taki sposób, aby automatycznie wymuszała wszystkie zmienne parametrów / argumentów jako „ostateczne”. Innymi słowy, argumenty nie powinny być zmiennymi . Ale z perspektywy czasu to wizja 20/20, a projektanci Java mieli wtedy pełne ręce roboty.

Więc zawsze dodawaj finaldo wszystkich argumentów?

Czy powinniśmy dodawać finaldo każdego deklarowanego parametru metody?

• Teoretycznie tak.
• W praktyce nie.
  ➥ Dodawaj finaltylko wtedy, gdy kod metody jest długi lub skomplikowany, gdzie argument może zostać pomylony ze zmienną lokalną lub zmienną składową i ewentualnie ponownie przypisany.

Jeśli przejdziesz do praktyki, by nigdy nie przypisywać argumentu, będziesz skłonny dodać finaldo każdego z nich. Jest to jednak uciążliwe i sprawia, że ​​deklaracja jest nieco trudniejsza do odczytania.

W przypadku krótkiego prostego kodu, w którym argument jest oczywiście argumentem, a nie zmienną lokalną ani zmienną składową, nie zawracam sobie głowy dodaniem final. Jeśli kod jest dość oczywisty, bez szansy, że ja lub inny programista przeprowadzę konserwację lub refaktoryzację przypadkowo pomylę zmienną argumentu jako coś innego niż argument, nie przejmuj się. W mojej własnej pracy dodaję finaltylko dłuższy lub bardziej zaangażowany kod, w którym argument mógłby pomylić się ze zmienną lokalną lub składową.

Dodano kolejną skrzynkę dla kompletności

public class MyClass {
    private int x;
    //getters and setters
}

void doSomething( final MyClass arg ) {  // Mark argument as 'final'.

   arg =  new MyClass();  // Compiler error: The passed argument variable arg  cannot be re-assigned to another object.

   arg.setX(20); // allowed
  // We can re-assign properties of argument which is marked as final
 }

Czasami miło jest wyrazić (dla czytelności), że zmienna się nie zmienia. Oto prosty przykład, w którym używanie finalmoże zaoszczędzić kilka potencjalnych problemów:

public void setTest(String test) {
    test = test;
}

Jeśli zapomnisz słowo kluczowe „to” na seter, zmienna, którą chcesz ustawić, nie zostanie ustawiona. Jeśli jednak użyjesz finalsłowa kluczowego w parametrze, błąd zostanie przechwycony podczas kompilacji.

Tak, z wyłączeniem anonimowych klas, czytelności i deklaracji zamiaru, jest to prawie bezwartościowe. Czy te trzy rzeczy są jednak bezwartościowe?

Osobiście nie używam finalzmiennych lokalnych i parametrów, chyba że używam zmiennej w anonimowej klasie wewnętrznej, ale z pewnością widzę sens tych, którzy chcą wyjaśnić, że sama wartość parametru się nie zmieni (nawet jeśli obiekt, do którego się odnosi, zmienia zawartość). Uważam, że dla tych, którzy zwiększają czytelność, jest to całkowicie rozsądne.

Punkt byłoby ważniejsze, czy ktoś rzeczywiście twierdząc, że nie utrzymać stałą danych w taki sposób, że nie robi - ale nie mogę sobie przypomnieć widząc żadnych takich roszczeń. Czy sugerujesz, że istnieje znaczna liczba programistów, którzy sugerują, że finalma większy efekt niż w rzeczywistości?

EDYCJA: Naprawdę powinienem to wszystko podsumować odniesieniem do Monty Pythona; pytanie wydaje się nieco podobne do pytania „Co Rzymianie kiedykolwiek dla nas zrobili?”

Pozwól mi wyjaśnić co nieco o jednym przypadku, gdzie trzeba użyć końcowy, który Jon już wspomniano:

Jeśli utworzysz anonimową klasę wewnętrzną w swojej metodzie i użyjesz zmiennej lokalnej (takiej jak parametr metody) w tej klasie, kompilator zmusi cię, aby parametr był ostateczny:

public Iterator<Integer> createIntegerIterator(final int from, final int to)
{
    return new Iterator<Integer>(){
        int index = from;
        public Integer next()
        {
            return index++;
        }
        public boolean hasNext()
        {
            return index <= to;
        }
        // remove method omitted
    };
}

Tutaj fromto parametry i muszą być ostateczne, aby można je było wykorzystać w anonimowej klasie.

Powodem tego wymogu jest to, że zmienne lokalne znajdują się na stosie, dlatego istnieją tylko podczas wykonywania metody. Jednak anonimowa instancja klasy jest zwracana z metody, więc może żyć znacznie dłużej. Nie można zachować stosu, ponieważ jest on potrzebny do kolejnych wywołań metod.

Zatem Java zamiast tego umieszcza kopie tych zmiennych lokalnych jako zmienne instancji ukrytych w anonimowej klasie (możesz je zobaczyć, jeśli zbadasz kod bajtowy). Ale gdyby nie były ostateczne, można by oczekiwać, że klasa anonimowa i metoda widząca zmiany wprowadzą drugą zmienną do zmiennej. Aby zachować złudzenie, że jest tylko jedna zmienna zamiast dwóch kopii, musi być ostateczna.

Cały czas używam ostatecznego parametru.

Czy to tyle dodaje? Nie całkiem.

Czy mógłbym to wyłączyć? Nie.

Powód: Znalazłem 3 błędy, w których ludzie napisali niechlujny kod i nie ustawili zmiennej członka w akcesoriach. Wszystkie błędy okazały się trudne do znalezienia.

Chciałbym, aby stało się domyślnym w przyszłej wersji Javy. Przekazywanie według wartości / referencji potyka się o wiele młodszych programistów.

Jeszcze jedno ... moje metody mają zwykle małą liczbę parametrów, więc dodatkowy tekst w deklaracji metody nie stanowi problemu.

Zastosowanie parametru final w metodzie metody nie ma nic wspólnego z tym, co dzieje się z argumentem po stronie wywołującej. Ma to jedynie oznaczać, że nie zmienia się w tej metodzie. Kiedy próbuję przyjąć bardziej funkcjonalny styl programowania, dostrzegam w tym wartość.

Osobiście nie używam parametru końcowego dla parametrów metody, ponieważ powoduje to zbyt dużo bałaganu na listach parametrów. Wolę wymusić, aby parametry metody nie były zmieniane przez coś w rodzaju Checkstyle.

W przypadku zmiennych lokalnych używam finału, gdy tylko jest to możliwe, pozwalam nawet Eclipse robić to automatycznie w mojej konfiguracji dla osobistych projektów.

Z pewnością chciałbym czegoś mocniejszego, jak const C / C ++.

Ponieważ Java przekazuje kopie argumentów, uważam, że ich znaczenie finaljest raczej ograniczone. Myślę, że nawyk pochodzi z ery C ++, w której można zabronić zmiany treści referencyjnych przez wykonanie const char const *. Uważam, że tego rodzaju rzeczy sprawiają, że uważasz, że deweloper jest z natury głupi jak cholera i musi być chroniony przed naprawdę każdą postacią, którą pisze. Z całą pokorą mogę powiedzieć, że piszę bardzo niewiele błędów, chociaż pomijam final(chyba że nie chcę, aby ktoś zastąpił moje metody i klasy). Może jestem tylko oldschoolowym deweloperem.

Nigdy nie używam finału na liście parametrów, po prostu dodaje bałaganu, jak powiedzieli poprzedni respondenci. Również w Eclipse możesz ustawić przypisanie parametrów w celu generowania błędu, więc użycie parametru final na liście parametrów wydaje mi się dość zbędne. Co ciekawe, gdy włączyłem ustawienie Eclipse dla przypisania parametrów generujących błąd, ten kod przechwycił ten kod (właśnie tak pamiętam przepływ, a nie rzeczywisty kod.): -

private String getString(String A, int i, String B, String C)
{
    if (i > 0)
        A += B;

    if (i > 100)
        A += C;

    return A;
}

Grając adwokata diabła, co dokładnie jest złego w robieniu tego?

Krótka odpowiedź: finalpomaga trochę, ale ... zamiast tego użyj defensywnego programowania po stronie klienta.

Rzeczywiście problem finalpolega na tym, że wymusza tylko to, że odwołanie pozostaje niezmienione, co z radością pozwala mutować elementy obiektu, do którego istnieje odwołanie, bez wiedzy osoby wywołującej. Dlatego najlepszą praktyką w tym zakresie jest programowanie defensywne po stronie wywołującej, tworzenie głęboko niezmiennych instancji lub głębokich kopii obiektów, które mogą zostać zmasowane przez pozbawione skrupułów interfejsy API.

Dodatkowym powodem dodania ostatecznego do deklaracji parametrów jest to, że pomaga zidentyfikować zmienne, których nazwy należy zmienić w ramach refaktoryzacji „Metoda ekstrakcji”. Przekonałem się, że dodanie wartości końcowej do każdego parametru przed rozpoczęciem refaktoryzacji dużej metody szybko mówi mi, czy są jakieś problemy, które muszę rozwiązać przed kontynuowaniem.

Na ogół jednak usuwam je jako zbędne na końcu refaktoryzacji.

Kontynuuj według posta Michela. Ja sam stworzyłem sobie inny przykład, aby to wyjaśnić. Mam nadzieję, że to może pomóc.

public static void main(String[] args){
    MyParam myParam = thisIsWhy(new MyObj());
    myParam.setArgNewName();

    System.out.println(myParam.showObjName());
}

public static MyParam thisIsWhy(final MyObj obj){
    MyParam myParam = new MyParam() {
        @Override
        public void setArgNewName() {
            obj.name = "afterSet";
        }

        @Override
        public String showObjName(){
            return obj.name;
        }
    };

    return myParam;
}

public static class MyObj{
    String name = "beforeSet";
    public MyObj() {
    }
}

public abstract static class MyParam{
    public abstract void setArgNewName();
    public abstract String showObjName();
}

Z powyższego kodu w sposobie thisIsWhy () , faktycznie nie przypisać do [argumentu myObj obj] do realnego odniesienia w myparam. Zamiast tego używamy po prostu [argument MyObj obj] w metodzie wewnątrz MyParam.

Ale po zakończeniu metody thisIsWhy () , czy argument (obiekt) MyObj nadal istnieje?

Wydaje się, że tak powinno być, ponieważ możemy zobaczyć, że w dalszym ciągu wywołujemy metodę showObjName () i musi ona dotrzeć do obj . MyParam nadal używa / dociera do argumentu metody, nawet metoda już zwróciła!

To, jak Java naprawdę to osiąga, to generowanie kopii, jest także ukrytym odwołaniem do argumentu MyObj obj wewnątrz obiektu MyParam (ale nie jest to formalne pole w MyParam, więc nie możemy go zobaczyć)

Kiedy nazywamy „showObjName”, użyje tego odwołania, aby uzyskać odpowiednią wartość.

Ale jeśli nie umieścimy argumentu na końcu, co prowadzi do sytuacji, możemy ponownie przypisać nową pamięć (obiekt) do argumentu MyObj obj .

Technicznie w ogóle nie ma konfliktu! Jeśli możemy to zrobić, poniżej będzie sytuacja:

1. Mamy teraz ukryty punkt [MyObj obj], aby [Memory A in heap] teraz znajdował się w obiekcie MyParam.
2. Mamy też inny [MyObj obj], który jest argumentem wskazującym, że [Memory B in heap] jest teraz dostępna w metodzie thisIsWhy.

Bez konfliktu, ale „KONFUSUJĄCE !!” Ponieważ wszyscy używają tej samej „nazwy odwołania”, którą jest „obj” .

Aby tego uniknąć, ustaw go jako „końcowy”, aby programista nie wykonał kodu „podatnego na błędy”.