Kiedy używasz adnotacji @Override w Javie i dlaczego?

Jakie są najlepsze praktyki korzystania z @Overrideadnotacji Java i dlaczego?

Wygląda na to, że oznaczanie każdej zastąpionej metody @Overrideadnotacją byłoby przesadą . Czy istnieją pewne sytuacje programowania, które wymagają użycia @Overridei innych, które nigdy nie powinny używać @Override?

Użyj go za każdym razem, gdy przesłonisz metodę, aby uzyskać dwie korzyści. Zrób to, abyś mógł skorzystać z sprawdzania kompilatora, aby upewnić się, że faktycznie zastępujesz metodę, gdy uważasz, że tak. W ten sposób, jeśli popełnisz częsty błąd polegający na błędnej pisowni nazwy metody lub niepoprawnym dopasowaniu parametrów, zostaniesz ostrzeżony, że metoda nie zastępuje tak, jak myślisz. Po drugie, ułatwia zrozumienie kodu, ponieważ jest bardziej oczywiste, gdy metody są zastępowane.

Ponadto w Javie 1.6 można go używać do oznaczania, kiedy metoda implementuje interfejs dla tych samych korzyści. Myślę, że lepiej byłoby mieć osobną adnotację (jak @Implements), ale lepiej niż nic.

Myślę, że jest to najbardziej przydatne jako przypomnienie w czasie kompilacji, że celem metody jest zastąpienie metody nadrzędnej. Jako przykład:

protected boolean displaySensitiveInformation() {
  return false;
}

Często można zobaczyć coś takiego jak powyższa metoda, która zastępuje metodę w klasie bazowej. Jest to ważny szczegół implementacyjny tej klasy - nie chcemy, aby wrażliwe informacje były wyświetlane.

Załóżmy, że ta metoda została zmieniona w klasie nadrzędnej na

protected boolean displaySensitiveInformation(Context context) {
  return true;
}

Ta zmiana nie spowoduje żadnych błędów lub ostrzeżeń podczas kompilacji - ale całkowicie zmienia zamierzone zachowanie podklasy.

Aby odpowiedzieć na twoje pytanie: powinieneś użyć adnotacji @Override, jeśli brak metody o tej samej sygnaturze w nadklasie wskazuje na błąd.

Jest tu wiele dobrych odpowiedzi, więc pozwólcie, że zaoferuję inny sposób spojrzenia na to ...

Podczas kodowania nie ma nadmiaru. Wpisanie @ override nie kosztuje nic, ale oszczędności mogą być ogromne, jeśli źle wpisałeś nazwę metody lub nieco popełniłeś błąd.

Pomyśl o tym w ten sposób: w czasie, gdy nawigowałeś tutaj i pisałeś ten post, prawie przeznaczyłeś więcej czasu niż na pisanie @override przez resztę życia; ale jeden błąd, który zapobiega, może zaoszczędzić wiele godzin.

Java robi wszystko, aby upewnić się, że nie popełniłeś żadnych błędów w czasie edycji / kompilacji, jest to praktycznie darmowy sposób na rozwiązanie całej klasy błędów, których nie można zapobiec w żaden inny sposób poza kompleksowymi testami.

Czy mógłbyś wymyślić lepszy mechanizm w Javie, aby upewnić się, że kiedy użytkownik zamierzał zastąpić metodę, faktycznie to zrobił?

Kolejnym ciekawym efektem jest to, że jeśli nie dostarczysz adnotacji, w czasie kompilacji ostrzeże Cię, że przypadkowo zastąpiłeś metodę nadrzędną - coś, co może być znaczące, jeśli nie zamierzasz tego robić.

Zawsze używam tagu. Jest to prosta flaga czasu kompilacji do wychwytywania drobnych błędów, które mogę popełnić.

Będzie łapał rzeczy takie jak tostring()zamiasttoString()

Małe rzeczy pomagają w dużych projektach.

Korzystanie z @Overrideadnotacji działa jako zabezpieczenie podczas kompilacji przed powszechnym błędem programistycznym. Zgłasza błąd kompilacji, jeśli masz adnotację do metody, której tak naprawdę nie przesłaniasz metody nadklasy.

Najczęstszym przypadkiem, gdy jest to przydatne, jest zmiana metody w klasie bazowej na inną listę parametrów. Metoda w podklasie, która została użyta do zastąpienia metody nadklasy, nie będzie już tego robić ze względu na zmienioną sygnaturę metody. Może to czasem powodować dziwne i nieoczekiwane zachowanie, szczególnie w przypadku złożonych struktur dziedziczenia. Do @Overridezabezpieczenia adnotacji przed tym.

Aby skorzystać z sprawdzania kompilatora, należy zawsze używać adnotacji Zastąp. Ale nie zapominaj, że Java Compiler 1.5 nie zezwoli na tę adnotację podczas przesłonięcia metod interfejsu. Możesz po prostu użyć go do zastąpienia metod klasowych (abstrakcyjnych lub nie).

Niektóre środowiska IDE, takie jak Eclipse, nawet skonfigurowane ze środowiskiem wykonawczym Java 1.6 lub nowszym, zachowują zgodność z Java 1.5 i nie pozwalają na użycie @override, jak opisano powyżej. Aby tego uniknąć, należy przejść do: Właściwości projektu -> Kompilator Java -> Zaznacz „Włącz ustawienia specyficzne dla projektu” -> Wybierz „Poziom zgodności kompilatora” = 6.0 lub wyższy.

Lubię używać tej adnotacji za każdym razem, gdy nadpisuję metodę niezależnie, jeśli baza jest interfejsem lub klasą.

Pomaga to uniknąć typowych błędów, na przykład gdy myślisz, że przesłoniłeś moduł obsługi zdarzeń, a potem nic się nie dzieje. Wyobraź sobie, że chcesz dodać detektor zdarzeń do niektórych składników interfejsu użytkownika:

someUIComponent.addMouseListener(new MouseAdapter(){
  public void mouseEntered() {
     ...do something...
  }
});

Powyższy kod kompiluje się i uruchamia, ale jeśli poruszysz myszą wewnątrz jakiegoś komponentu UIC, kod „zrób coś” zapisze polecenie uruchomienia, ponieważ tak naprawdę nie zastępujesz metody podstawowej mouseEntered(MouseEvent ev). Właśnie tworzysz nową metodę bez parametrów mouseEntered(). Zamiast tego kodu, jeśli użyłeś @Overrideadnotacji, zobaczyłeś błąd kompilacji i nie marnowałeś czasu na zastanawianie się, dlaczego program obsługi zdarzeń nie działa.

@Override w sprawie implementacji interfejsu jest niespójny, ponieważ nie ma czegoś takiego jak „przesłanianie interfejsu” w java.

@Override w sprawie implementacji interfejsu jest bezużyteczny, ponieważ w praktyce nie wyłapuje błędów, których kompilacja i tak nie wychwyciłaby. Jest tylko jeden, dalekosiężny scenariusz, w którym przesłonięcie implementatorów faktycznie coś robi: Jeśli zaimplementujesz interfejs, a interfejs USUWA metody, zostaniesz powiadomiony w czasie kompilacji, że powinieneś usunąć nieużywane implementacje. Zauważ, że jeśli nowa wersja interfejsu ma NOWE lub ZMIENIONE metody, oczywiście i tak dostaniesz błąd kompilacji, ponieważ nie wdrażasz nowych rzeczy.

@Override na implementatorach interfejsów nigdy nie powinno być dozwolone w wersji 1.6, a ponieważ zaćmienie ze smutkiem decyduje się na automatyczne wstawianie adnotacji jako zachowanie domyślne, otrzymujemy wiele zaśmieconych plików źródłowych. Podczas czytania kodu 1.6 z adnotacji @Override nie można zobaczyć, czy metoda faktycznie przesłania metodę w nadklasie lub po prostu implementuje interfejs.

Użycie @Override podczas faktycznego nadpisywania metody w nadklasie jest w porządku.

Najlepiej jest używać go do każdej metody przewidzianej jako zastąpienie, a Java 6+, każda metoda przeznaczona jako implementacja interfejsu.

Po pierwsze, wychwytuje błędy pisowni, takie jak „ hashcode()” zamiast „ hashCode()” podczas kompilacji. Debugowanie, dlaczego wynik metody wydaje się nie pasować do kodu, może być kłopotliwe, gdy prawdziwą przyczyną jest to, że kod nigdy nie jest wywoływany.

Ponadto, jeśli superklasa zmienia podpis metody, przesłania starszego podpisu można „osierocić”, pozostawiając jako mylący martwy kod. @OverrideAdnotacja pomoże Ci zidentyfikować te sieroty tak, że mogą one być modyfikowane, aby dopasować nowy podpis.

Jeśli często zastępujesz (nieabstrakcyjne) metody, prawdopodobnie zechcesz rzucić okiem na swój projekt. Jest to bardzo przydatne, gdy kompilator nie wychwyciłby błędu. Na przykład próba zastąpienia initValue () w ThreadLocal, co zrobiłem.

Używanie @Override podczas implementowania metod interfejsu (funkcja 1.6+) wydaje mi się nieco przesadne. Jeśli masz mnóstwo metod, z których niektóre zastępują, a niektóre nie, prawdopodobnie ten zły projekt ponownie (a twój edytor prawdopodobnie pokaże, który z nich, jeśli nie wiesz).

@Override na interfejsach faktycznie są pomocne, ponieważ otrzymasz ostrzeżenia, jeśli zmienisz interfejs.

Inną rzeczą, jaką robi, jest to, że podczas czytania kodu staje się bardziej oczywiste, że zmienia zachowanie klasy nadrzędnej. Niż może pomóc w debugowaniu.

Również w książce Joshua Blocka Effective Java (wydanie drugie) pozycja 36 podaje więcej szczegółów na temat korzyści z adnotacji.

Nie ma absolutnie żadnego sensu używanie @Override podczas implementacji metody interfejsu. W takim przypadku nie ma żadnej korzyści - kompilator już złapie twój błąd, więc jest to po prostu niepotrzebny bałagan.

Ilekroć metoda zastępuje inną metodę lub metoda implementuje podpis w interfejsie.

@OverrideAdnotacja zapewni, że rzeczywiście wymuszenia czegoś. Bez adnotacji ryzykujesz błąd ortograficzny lub różnicę w typach i liczbie parametrów.

Używam go za każdym razem. To więcej informacji, których mogę użyć, aby szybko dowiedzieć się, co się dzieje, kiedy ponownie odwiedzam kod za rok i zapomniałem, o czym myślałem za pierwszym razem.

Najlepiej jest zawsze go używać (lub poprosić o wypełnienie go przez IDE)

Przydatnością @Override jest wykrywanie zmian w klasach nadrzędnych, które nie zostały zgłoszone w hierarchii. Bez niego możesz zmienić sygnaturę metody i zapomnieć o zmianie jej nadpisań, dzięki @Override kompilator złapie ją za ciebie.

Tego rodzaju siatkę bezpieczeństwa zawsze warto mieć.

Używam go wszędzie. Jeśli chodzi o wysiłek dotyczący metod oznaczania, pozwalam Eclipse zrobić to za mnie, więc nie jest to dodatkowy wysiłek.

Jestem religijny w kwestii ciągłego refaktoryzacji ... więc wykorzystam każdą drobiazg, aby wszystko poszło gładko.

• Używany tylko w deklaracjach metod.
• Wskazuje, że deklaracja metody z komentarzem zastępuje deklarację w nadtypie.

Przy konsekwentnym stosowaniu chroni przed dużą klasą niecnych błędów.

Użyj adnotacji @Override, aby uniknąć tych błędów: (Znajdź błąd w następującym kodzie :)

public class Bigram {
    private final char first;
    private final char second;
    public Bigram(char first, char second) {
        this.first  = first;
        this.second = second;
    }
    public boolean equals(Bigram b) {
        return b.first == first && b.second == second;
    }
    public int hashCode() {
        return 31 * first + second;
    }

    public static void main(String[] args) {
        Set<Bigram> s = new HashSet<Bigram>();
        for (int i = 0; i < 10; i++)
            for (char ch = 'a'; ch <= 'z'; ch++)
                s.add(new Bigram(ch, ch));
        System.out.println(s.size());
    }
}

źródło: Skuteczna Java

Zachowaj ostrożność podczas korzystania z funkcji Zastąp, ponieważ później nie można wykonać inżynierii wstecznej w starUML; zrób uml pierwszy.

Wydaje się, że mądrość tutaj się zmienia. Dzisiaj zainstalowałem IntelliJ IDEA 9 i zauważyłem, że jego „ brakująca kontrola @Override ” teraz wychwytuje nie tylko zaimplementowane metody abstrakcyjne, ale także zaimplementowane metody interfejsu. W bazie kodu mojego pracodawcy i we własnych projektach od dawna miałem zwyczaj używać @Override tylko dla wcześniejszych metod abstrakcyjnych. Jednakże, przemyślenie nawyku, zalety korzystania z adnotacji w obu przypadkach stają się jasne. Mimo że jest bardziej szczegółowy, chroni przed delikatnym problemem klasy bazowej (nie tak poważnym jak przykłady związane z C ++), w którym zmienia się nazwa metody interfejsu, osierocając potencjalną metodę implementacji w klasie pochodnej.

Oczywiście ten scenariusz to głównie hiperbola; klasa pochodna nie będzie się już kompilować, teraz brakuje jej implementacji metody interfejsu o zmienionej nazwie, a dziś prawdopodobnie można by użyć operacji refaktoryzacji Rename Method w celu masowego rozwiązania całej bazy kodu.

Biorąc pod uwagę, że inspekcji IDEA nie można skonfigurować w celu zignorowania zaimplementowanych metod interfejsu, dzisiaj zmienię zarówno mój nawyk, jak i kryteria przeglądu kodu mojego zespołu.

Adnotacja @Override służy do sprawdzenia, czy programista ma przesłonić poprawną metodę w klasie nadrzędnej lub interfejsie. Gdy zmienia się nazwa metod super, kompilator może powiadomić o tym przypadku, co służy wyłącznie zachowaniu spójności z superklasą i podklasą.

BTW, jeśli nie podamy adnotacji @Override w podklasie, ale zastąpimy niektóre metody super, wtedy funkcja może działać tak jak ta z @Override. Ale ta metoda nie może powiadomić dewelopera o zmianie metody super. Ponieważ nie znał celu programisty - zastąpić metodę super lub zdefiniować nową metodę?

Więc jeśli chcemy zastąpić tę metodę, aby skorzystać z polimorfizmu, lepiej dodać @Override powyżej metody.

Używam go tak często, jak to możliwe, aby zidentyfikować, kiedy metoda jest zastępowana. Jeśli spojrzysz na język programowania Scala, mają również słowo kluczowe zastępujące. Uważam to za przydatne.

Pozwala to (cóż, kompilatorowi) na wychwycenie, gdy użyłeś niewłaściwej pisowni w zastępowanej nazwie metody.

Adnotacja zastępowania służy do korzystania z kompilatora w celu sprawdzenia, czy faktycznie przesłaniasz metodę z klasy nadrzędnej. Służy do powiadamiania, jeśli popełnisz jakiś błąd, np. Błąd w pisowni nazwy metody, błąd niewłaściwego dopasowania parametrów

myślę, że najlepiej zakodować @ override, ilekroć jest to dozwolone. pomaga w kodowaniu. należy jednak zauważyć, że w przypadku ecipse Helios, sdk 5 lub 6, dozwolona jest adnotacja @override dla zaimplementowanych metod interfejsu. podobnie jak w przypadku Galileo, 5 lub 6, adnotacja @ override jest niedozwolona.

Adnotacje dostarczają kompilatorowi metadane dotyczące kodu, a adnotacja @Override jest używana w przypadku dziedziczenia, gdy zastępujemy dowolną metodę klasy podstawowej. Po prostu informuje kompilator, że zastępujesz metodę. Pozwala to uniknąć niektórych typowych błędów, które możemy popełnić, takich jak nieprzestrzeganie poprawnego podpisu metody lub literówka w nazwie metody itp. Dlatego dobrą praktyką jest stosowanie adnotacji @Override.

Dla mnie @Override zapewnia, że ​​mam poprawny podpis metody. Jeśli wstawię adnotację, a metoda nie jest poprawnie napisana, kompilator narzeka, informując mnie, że coś jest nie tak.

Prosty - jeśli chcesz zastąpić metodę obecną w swojej nadklasie, użyj @Overrideadnotacji, aby dokonać prawidłowego zastąpienia. Kompilator ostrzeże Cię, jeśli nie zastąpisz go poprawnie.