Używanie modyfikatora „końcowego”, jeśli dotyczy Java [zamknięte]

W Javie istnieje praktyka deklarowania każdej zmiennej (lokalnej lub klasy), parametru końcowego, jeśli tak naprawdę jest.

Chociaż czyni to kod bardziej szczegółowym, pomaga to w łatwym czytaniu / uchwyceniu kodu, a także zapobiega błędom, ponieważ intencja jest wyraźnie zaznaczona.

Co o tym myślisz i co podążasz?

Myślę, że to wszystko ma związek z dobrym stylem kodowania. Oczywiście możesz pisać dobre, solidne programy bez użycia wielu finalmodyfikatorów w dowolnym miejscu, ale kiedy o tym pomyślisz ...

Dodanie finaldo wszystkich rzeczy, które nie powinny się zmienić, po prostu zawęża możliwości, że ty (lub następny programista pracujący nad twoim kodem) źle zinterpretujesz lub niewłaściwie wykorzystasz proces myślowy, który spowodował twój kod. Przynajmniej powinien zadzwonić kilkoma dzwonkami, kiedy będą chcieli zmienić twoją wcześniej niezmienną rzecz.

Na początku trochę dziwnie jest widzieć wiele finalsłów kluczowych w kodzie, ale wkrótce przestaniesz zauważać samo słowo i po prostu pomyślisz, że to, co nigdy nie zmieni się od tego punktu na (możesz mi to zabrać ;-)

Myślę, że to dobra praktyka. Nie używam tego przez cały czas, ale kiedy mogę i sensowne jest oznaczenie czegoś final, zrobię to.

Obsesja na punkcie:

• Pola końcowe - Oznaczenie pól jako końcowe zmusza je do ustawienia do końca budowy, dzięki czemu to pole odniesienia pozostaje niezmienne. Umożliwia to bezpieczną publikację pól i pozwala uniknąć konieczności synchronizacji przy późniejszych odczytach. (Należy zauważyć, że w przypadku odwołania do obiektu tylko odwołanie do pola jest niezmienne - rzeczy, do których odwołuje się odwołanie do obiektu, mogą się nadal zmieniać, co wpływa na niezmienność).
• Końcowe pola statyczne - chociaż teraz używam wyliczeń w wielu przypadkach, w których używałem statycznych pól końcowych.

Zastanów się, ale używaj rozsądnie:

• Klasy końcowe - Projekt / Framework to jedyny przypadek, w którym go rozważam.
• Metody końcowe - Zasadniczo takie same jak klasy końcowe. Jeśli używasz wzorców metod szablonów, takich jak szalone i oznaczanie rzeczy jako ostatecznych, prawdopodobnie zbytnio polegasz na dziedziczeniu, a za mało na delegowaniu.

Ignoruj, chyba że czujesz się analny:

• Parametry metody i zmienne lokalne - RZADKO robię to głównie dlatego, że jestem leniwy i uważam, że zaśmieca kod. Przyznaję w pełni, że oznaczanie parametrów i zmiennych lokalnych, których nie zamierzam modyfikować, jest „jaśniejsze”. Chciałbym, żeby to była wartość domyślna. Ale tak nie jest i trudno mi zrozumieć kod w finałach. Jeśli jestem w czyimś kodzie, nie zamierzam go wyciągać, ale jeśli piszę nowy kod, nie wstawię go. Jednym wyjątkiem jest sytuacja, w której musisz zaznaczyć coś ostatecznego, abyś mógł uzyskać do niego dostęp z anonimowej klasy wewnętrznej.

Naprawdę musisz zrozumieć pełne wykorzystanie końcowego słowa kluczowego przed jego użyciem. Może mieć zastosowanie i ma różny wpływ na zmienne, pola, metody i klasy

Polecam sprawdzenie artykułu, do którego link znajduje się poniżej, aby uzyskać więcej informacji.

Ostatnie słowo Na ostatnie słowo kluczowe

finalModyfikator, zwłaszcza dla zmiennych, jest środkiem mieć kompilator egzekwowania konwencji, która jest ogólnie sensowne: upewnij się, że zmienna a (lokalny lub instancja) jest przypisany dokładnie jeden raz (nie więcej nie mniej). Upewniając się, że zmienna jest zdecydowanie przypisana przed użyciem, można uniknąć typowych przypadków NullPointerException:

final FileInputStream in;
if(test)
  in = new FileInputStream("foo.txt");
else
  System.out.println("test failed");
in.read(); // Compiler error because variable 'in' might be unassigned

Zapobiegając przypisywaniu zmiennej więcej niż raz, odradzasz określanie zasięgu za granicą. Zamiast tego:

 String msg = null;
 for(int i = 0; i < 10; i++) {
     msg = "We are at position " + i;
     System.out.println(msg);
 }
 msg = null;

Zachęcamy do korzystania z tego:

 for(int i = 0; i < 10; i++) {
     final String msg = "We are at position " + i;
     System.out.println(msg);
 }

Niektóre linki:

• Ostatnia historia (darmowy rozdział książki „Hardcore Java”)
• Kilka ostatecznych wzorów
• Określone zadanie

Jestem dość dogmatyczny w kwestii deklarowania każdej możliwej zmiennej final. Obejmuje to parametry metody, zmienne lokalne i rzadko pola wartości. Mam trzy główne powody, dla których wszędzie deklaruję zmienne końcowe:

1. Deklarowanie intencji: Deklarując zmienną końcową, stwierdzam, że zmienna ta ma być zapisana tylko raz. Jest to subtelna wskazówka dla innych programistów i duża wskazówka dla kompilatora.
2. Egzekwowanie zmiennych jednorazowego użytku: Wierzę w ideę, że każda zmienna powinna mieć tylko jeden cel w życiu. Dając każdej zmiennej tylko jeden cel, zmniejszasz czas potrzebny na sprawdzenie celu tej konkretnej zmiennej podczas debugowania.
3. Zezwala na optymalizację: wiem, że kompilator miał kiedyś sztuczki zwiększające wydajność, które polegały w szczególności na niezmienności zmiennej odniesienia. Lubię myśleć, że niektóre z tych starych sztuczek związanych z wydajnością (lub nowe) zostaną wykorzystane przez kompilator.

Myślę jednak, że końcowe klasy i metody nie są tak przydatne, jak odwołania do zmiennych końcowych. Słowo finalkluczowe użyte w tych deklaracjach po prostu zapewnia przeszkody w automatycznym testowaniu i wykorzystaniu kodu w sposób, którego nigdy nie można było się spodziewać.

Skuteczna Java zawiera element z napisem „Preferuj niezmienne obiekty”. Uznanie pól za ostateczne pomaga zrobić kilka małych kroków w tym kierunku, ale w przypadku obiektów naprawdę niezmiennych jest znacznie więcej.

Jeśli wiesz, że obiekty są niezmienne, można je udostępnić do odczytu wielu wątkom / klientom bez obaw o synchronizację, i łatwiej jest zrozumieć, jak działa program.

Nigdy nie byłem w sytuacji, w której ostatnie słowo kluczowe na zmiennej powstrzymywało mnie od popełnienia błędu, więc na chwilę obecną myślę, że to wielka strata czasu.

Chyba że istnieje prawdziwy powód, aby to zrobić (jak w przypadku, gdy chcesz podkreślić konkretną zmienność będącą ostateczną), wolałbym tego nie robić, ponieważ uważam, że kod jest mniej czytelny.

Jeśli jednak nie okaże się, że kod ten jest trudniejszy do odczytania lub dłuższy do napisania, to na pewno idź.

Edycja: Jako wyjaśnienie (i próba odzyskania głosów niższych), nie mówię, nie oznaczaj stałych jako ostatecznych, mówię, nie rób rzeczy takich jak:

public String doSomething() {
  final String first = someReallyComplicatedExpressionToGetTheString();
  final String second = anotherReallyComplicatedExpressionToGetAnother();

  return first+second;
}

To sprawia, że ​​kod (moim zdaniem) jest trudniejszy do odczytania.

Warto również pamiętać, że wszystko, co robi, uniemożliwia zmianę przypisania zmiennej, nie czyni jej niezmiennym ani nic podobnego.

Ostateczny należy zawsze stosować dla stałych. Przydaje się nawet w przypadku zmiennych krótkotrwałych (w ramach jednej metody), gdy zasady definiowania zmiennej są skomplikowane.

Na przykład:

final int foo;
if (a)
    foo = 1;
else if (b)
    foo = 2;
else if (c)
    foo = 3;
if (d)        // Compile error:  forgot the 'else'
    foo = 4;
else
    foo = -1;

Wydaje się, że jednym z największych argumentów przeciwko używaniu końcowego słowa kluczowego jest to, że „jest to niepotrzebne” i „marnuje miejsce”.

Jeśli uznamy wiele zalet „końcowego”, jak wskazano w wielu świetnych postach tutaj, przyznając, że wymaga to więcej pisania i spacji, argumentowałbym, że Java powinna była domyślnie ustawić zmienne „końcowe” i wymagać, aby rzeczy były oznaczone „ mutable ”, jeśli programista tego chce.

finalCały czas używam atrybutów obiektów.

Słowo finalkluczowe ma semantykę widoczności, gdy jest używane w przypadku atrybutów obiektu. Zasadniczo ustawienie wartości ostatecznego atrybutu obiektu ma miejsce przed powrotem konstruktora. Oznacza to, że dopóki nie pozwolisz, by thisreferencja uciekła od konstruktora i używasz finaldo wszystkich swoich atrybutów, twój obiekt (zgodnie z semantyką Java 5) jest prawidłowo skonstruowany, a ponieważ jest niezmienny, może być bezpiecznie opublikowany do innych wątków.

Niezmienne przedmioty to nie tylko bezpieczeństwo nitek. Ułatwiają także rozumowanie zmian stanu w twoim programie, ponieważ przestrzeń tego, co można zmienić, jest celowo i, jeśli jest konsekwentnie używana, całkowicie ograniczona do rzeczy, które powinny się zmienić.

Czasami też uznaję metody za ostateczne, ale nie tak często. Rzadko kończę zajęcia. Zazwyczaj robię to, ponieważ nie mam takiej potrzeby. Zazwyczaj nie używam dziedziczenia zbyt często. Wolę zamiast tego używać interfejsów i kompozycji obiektów - nadaje się to również do projektu, który moim zdaniem jest często łatwiejszy do przetestowania. Kiedy kodujesz interfejsy zamiast konkretnych klas, nie musisz używać dziedziczenia podczas testowania, w takiej formie, w ramach takich jak jMock, znacznie łatwiej jest tworzyć obiekty próbne z interfejsami niż w przypadku klas konkretnych.

Wydaje mi się, że większość zajęć powinienem zakończyć, ale po prostu jeszcze nie przyzwyczaiłem się.

Muszę przeczytać dużo kodu do mojej pracy. Brak końcowych zmiennych instancji jest jedną z najważniejszych rzeczy, które mnie denerwują i sprawiają, że zrozumienie kodu jest niepotrzebnie trudne. Za moje pieniądze, końcowe zmienne lokalne powodują więcej bałaganu niż przejrzystości. Język powinien zostać zaprojektowany tak, aby był domyślny, ale musimy żyć z pomyłką. Czasami przydaje się to szczególnie w przypadku pętli i określonego przypisania z drzewem if-else, ale przeważnie wskazuje, że twoja metoda jest zbyt skomplikowana.

Ostatecznie należy oczywiście stosować na stałe i aby wymusić niezmienność, ale jest też inne ważne zastosowanie metod.

Skuteczna Java zawiera w tym cały przedmiot (punkt 15), wskazujący pułapki niezamierzonego dziedziczenia. Skutecznie, jeśli nie zaprojektowałeś i nie udokumentowałeś swojej klasy do dziedziczenia, dziedziczenie po niej może dać nieoczekiwane problemy (przedmiot daje dobry przykład). Dlatego zaleca się, abyś używał finału na dowolnej klasie i / lub metodzie, z której nie zamierzano dziedziczyć.

To może wydawać się drakońskie, ale ma sens. Jeśli piszesz bibliotekę klas do użytku przez innych, nie chcesz, aby dziedziczyły po rzeczach, które nie zostały do ​​niej zaprojektowane - zablokujesz się w konkretnej implementacji klasy dla kompatybilności wstecznej. Jeśli kodujesz w zespole, nic nie stoi na przeszkodzie, aby inny członek zespołu usunął finał, jeśli naprawdę musi. Ale słowo kluczowe zmusza ich do zastanowienia się nad tym, co robią i ostrzega ich, że klasa, od której dziedziczą, nie została do tego zaprojektowana, dlatego powinni być bardzo ostrożni.

Kolejnym zastrzeżeniem jest to, że wiele osób myli zdanie końcowe, co oznacza, że ​​zawartość zmiennej instancji nie może się zmienić, a nie, że odwołanie nie może się zmienić.

Nawet w przypadku zmiennych lokalnych wiedza, że ​​jest ona deklarowana jako ostateczna, oznacza, że ​​nie muszę się martwić, że odwołanie zostanie zmienione później. Oznacza to, że podczas debugowania i później widzę tę zmienną, jestem pewien, że odnosi się do tego samego obiektu. To jedna rzecz, o którą muszę się martwić, szukając błędu. Dodatkową korzyścią jest to, że jeśli 99% zmiennych zostanie uznanych za ostateczne, to kilka zmiennych, które naprawdę są zmiennymi, lepiej się wyróżnia. Ponadto finał pozwala kompilatorowi znaleźć jeszcze więcej głupich błędów, które w przeciwnym razie mogłyby pozostać niezauważone.

Wybór typu finaldla każdego parametru w każdej metodzie spowoduje tak duże podrażnienie zarówno dla programistów, jak i czytników kodów.

Kiedy podrażnienie wykracza poza rozsądne przejście na Scalę, gdzie argumenty są domyślnie ostateczne.

Lub zawsze możesz użyć narzędzi do stylizacji kodu, które zrobią to automatycznie. Wszystkie IDE mają je zaimplementowane lub jako wtyczki.

Końcowy, gdy jest używany ze zmiennymi w Javie, zastępuje stałą w C ++. Kiedy więc zmienna końcowa i statyczna zostanie użyta dla zmiennej, staje się ona niezmienna. Jednocześnie sprawia, że ​​migrowani programiści C ++ są bardzo szczęśliwi ;-)

W przypadku użycia ze zmiennymi odniesienia nie pozwala na ponowne odniesienie do obiektu, chociaż obiektem można manipulować.

W przypadku użycia metody końcowej metoda nie pozwala na przesłonięcie metody przez podklasy.

Gdy użycie jest bardzo jasne, należy z niego korzystać ostrożnie. Zależy to głównie od projektu, ponieważ użycie metody końcowej w metodzie nie pomogłoby polimorfizmowi.

Należy go używać tylko w przypadku zmiennych, gdy masz cholerną pewność, że wartość zmiennej nigdy nie powinna zostać zmieniona. Upewnij się także, że przestrzegasz konwencji kodowania zalecanej przez SUN. Na przykład: final int COLOR_RED = 1; (Wielkie litery oddzielone znakiem podkreślenia)

Ze zmienną referencyjną używaj jej tylko wtedy, gdy potrzebujemy niezmiennego odwołania do konkretnego obiektu.

Jeśli chodzi o część dotyczącą czytelności, upewnij się, że komentarze odgrywają bardzo ważną rolę podczas używania końcowego modyfikatora.

Nigdy nie używam ich w zmiennych lokalnych, dodanie gadatliwości nie ma sensu. Nawet jeśli nie uważasz, że zmienna powinna zostać ponownie przypisana, nie będzie to miało większego znaczenia dla następnej osoby zmieniającej kod, który myśli inaczej, a ponieważ kod jest zmieniany, każdy pierwotny cel, aby był ostateczny, może już nie być prawidłowy. Jeśli chodzi tylko o jasność, uważam, że zawodzi z powodu negatywnych skutków gadatliwości.

Prawie to samo dotyczy również zmiennych składowych, ponieważ zapewniają one niewielką korzyść, z wyjątkiem przypadku stałych.

Nie ma również wpływu na niezmienność, ponieważ najlepszym wskaźnikiem niezmienności jest to, że jest udokumentowane jako takie i / lub nie ma metod, które mogłyby zmienić obiekt (to, wraz z uczynieniem klasy ostateczną, jest jedynym sposobem na zagwarantowanie, że jest niezmienny).

Ale hej, to tylko moja opinia :-)

Skonfigurowałem Eclipse, aby dodać finał do wszystkich pól i atrybutów, które nie są modyfikowane. Działa to doskonale przy użyciu „akcji zapisywania” Eclipse, która dodaje te ostatnie modyfikatory (między innymi) podczas zapisywania pliku.

Wysoce rekomendowane.

Sprawdź mój wpis na blogu dotyczący akcji zapisywania Eclipse.

W przypadku argumentów uważam, że nie są potrzebne. Mostley po prostu zranili gotowość. Ponowne przypisanie zmiennej argumentu jest tak szalenie głupie, że powinienem być całkiem pewny, że i tak można je traktować jako stałe.

Fakt, że Eclipse barwi końcową czerwień, ułatwia dostrzeżenie zmiennych deklaracji w kodzie, co moim zdaniem poprawia zdolność odczytu w większości przypadków.

Staram się egzekwować zasadę, że wszystkie zmienne powinny być ostateczne, ponieważ nie ma wyjątkowo ważnego powodu, aby tego nie robić. O wiele łatwiej jest odpowiedzieć na pytanie „co to za zmienna?” pytaj, czy po prostu musisz znaleźć inicjalizację i mieć pewność, że to jest to.

Właściwie denerwuję się wokół zmiennych niekończących już teraz. To jak różnica między tym, że nóż wisi nad nitką nad głową, a szufladą kuchenną ...

Ostatnia zmienna jest po prostu dobrym sposobem na wartości etykiety.

Nieokreślona zmienna jest związana z częścią algorytmu podatnego na błędy.

Jedną z fajnych cech jest to, że gdy opcja nie wymaga odpowiedzi dla algorytmu przez większość czasu, rozwiązaniem jest napisanie metody, co zwykle znacznie poprawia kod.

Od jakiegoś czasu programuję i używam finału, kiedy tylko mogę. Po zrobieniu tego przez chwilę (dla zmiennych, parametrów metody i atrybutów klasy) mogę powiedzieć, że 90% (lub więcej) moich zmiennych jest w rzeczywistości ostatecznych. Myślę, że korzyścią z faktu, że NIE zmieniono zmiennych, gdy nie chcesz (widziałem to wcześniej i czasami jest to ból), płaci się za dodatkowe pisanie i dodatkowe „końcowe” słowa kluczowe w kodzie.

Biorąc to pod uwagę, gdybym zaprojektował język, ustawiłbym każdą zmienną na końcową, chyba że zostałby zmodyfikowany przez inne słowo kluczowe.

Pomyślałem, że nie używam finału do zajęć i metod. Jest to mniej lub bardziej skomplikowany wybór projektu, chyba że twoja klasa jest klasą użyteczności (w takim przypadku powinieneś mieć tylko jednego prywatnego konstruktora).

Korzystam również z Collections.unmodifiable ... do tworzenia list niemodyfikowalnych, kiedy jest to konieczne.

Używanie anonimowych klas lokalnych dla detektorów zdarzeń i taki jest powszechny wzorzec w Javie. Najczęstszym zastosowaniem końcowego słowa kluczowego jest upewnienie się, że zmienne w zakresie są dostępne dla parzystego słuchacza.

Jeśli jednak będziesz musiał umieścić w swoim kodzie wiele końcowych instrukcji. To może być dobra wskazówka, że ​​robisz coś źle.

Artykuł opublikowany powyżej podaje ten przykład:

public void doSomething(int i, int j) {
    final int n = i + j; // must be declared final

    Comparator comp = new Comparator() {
        public int compare(Object left, Object right) {
            return n; // return copy of a local variable
        }
    };
}

Używam go do stałych wewnątrz i na zewnątrz metod.

Czasami używam go do metod, ponieważ nie wiem, czy podklasa NIE chciałaby zastąpić danej metody (z jakichkolwiek powodów).

Jeśli chodzi o klasy, tylko dla niektórych klas infrastruktury użyłem klasy ostatecznej.

IntelliJ IDEA ostrzega, jeśli parametr funkcji jest zapisany w funkcji. Przestałem więc używać argumentu funkcji końcowej. Nie widzę ich również w bibliotece Java Runtime.

Prawie nie używam finału na metodach lub zajęciach, ponieważ lubię pozwalać ludziom je przesłonić.

W przeciwnym razie używam tylko, jeśli jest to public/private static final type SOME_CONSTANT;

Oznaczenie klasy końcowej może również powodować, że niektóre wiązania metod będą się pojawiać w czasie kompilacji zamiast w środowisku wykonawczym. Rozważmy „v2.foo ()” poniżej - kompilator wie, że B nie może mieć podklasy, więc nie można zastąpić foo (), więc implementacja do wywołania jest znana w czasie kompilacji. Jeśli klasa B NIE jest oznaczona jako ostateczna, możliwe jest, że faktycznym typem v2 jest klasa, która rozszerza B i zastępuje foo ().

class A {
    void foo() {
        //do something
    }
}
final class B extends A {
    void foo() {
    }
}
class Test {
    public void t(A v1, B v2) {
        v1.foo();
        v2.foo();
    }
}

Zdecydowanie zachęca się do używania ostatecznego dla stałych . Nie użyłbym go jednak do metod lub klas (a przynajmniej przez chwilę o tym myślał), ponieważ utrudnia to testowanie , jeśli nie jest niemożliwe. Jeśli absolutnie musisz uczynić klasę lub metodę ostateczną, upewnij się, że ta klasa implementuje jakiś interfejs, abyś mógł mieć próbną implementację tego samego interfejsu.