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

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

protected boolean displaySensitiveInformation() {
  return false;
}

Często zobaczysz coś takiego jak powyższa metoda, która nadpisuje metodę w klasie bazowej. Jest to ważny szczegół implementacji tej klasy - nie chcemy, aby wyświetlane były poufne informacje.

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

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

Ta zmiana nie spowoduje kompilacji błędy lub ostrzeżenia-ale to całkowicie zmienia zamierzone zachowanie podklasy.

Aby odpowiedzieć na twoje pytanie: powinieneś użyć adnotacji @ Override, jeśli brak metody z tym samym podpisem w superklasie wskazuje na błąd.

Istnieje wiele dobrych odpowiedzi tutaj, więc pozwól mi zaoferować inny sposób, aby spojrzeć na to...

Nie ma przesady podczas kodowania. Wpisanie @override nic cię nie kosztuje, ale oszczędności mogą być ogromne, jeśli pomylisz nazwę metody lub pomylisz podpis.

Pomyśl o tym w ten sposób: w czasie, gdy poruszałeś się tutaj i wpisywałeś ten post, prawie wykorzystałeś więcej czasu niż spędzisz na pisaniu @ override do końca życia; ale jeden błąd zapobiega możesz zaoszczędzić godziny.

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órym nie można zapobiec w żaden inny sposób poza kompleksowym testowaniem.

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

Kolejnym fajnym efektem jest to, że jeśli nie podasz adnotacji, ostrzeże cię przy kompilacji czas, w którym przypadkowo przekroczyłeś metodę rodzica. coś, co może być znaczące, jeśli nie zamierzałeś tego zrobić.

Zawsze używam znacznika. Jest to prosta flaga w czasie kompilacji, aby złapać małe błędy, które mogę popełnić.

Będzie łapać takie rzeczy jak tostring() zamiast toString()

Używanie adnotacji @Override działa jako zabezpieczenie w czasie kompilacji przed częstym błędem programistycznym. Spowoduje to błąd kompilacji, jeśli masz adnotację na metodzie, której w rzeczywistości nie nadpisujesz metody superclass.

Najczęstszym przypadkiem, w którym jest to przydatne, jest zmiana metody w klasie bazowej na inną listę parametrów. Metoda w podklasie, która została użyta do nadpisania metody klasy nadrzędnej, nie będzie już tego robić ze względu na zmienioną sygnaturę metody. Może to czasami powodować dziwne i nieoczekiwane zachowanie, zwłaszcza w przypadku złożonych struktur dziedziczenia. @Override adnotacja zabezpiecza przed tym.

Aby skorzystać z sprawdzania kompilatora, należy zawsze używać adnotacji zastępczej. Ale nie zapominaj, że Java Compiler 1.5 nie pozwoli na tę adnotację, gdy nadpisuje metody interfejsu. Możesz go użyć do nadpisania metod klas (abstrakcyjnych lub nie).

Niektóre IDE, jako Eclipse, nawet skonfigurowane z Java 1.6 runtime lub nowszą, zachowują zgodność Z Java 1.5 i nie zezwalają na użycie @ override, jak opisano powyżej. Aby tego uniknąć należy przejść do: Właściwości projektu - >Java Compiler - > zaznacz "Enable Project Specific Settings" - > Wybierz "Compiler Compliance Level" = 6.0 lub wyższy.

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

Pomaga to uniknąć typowych błędów, gdy myślisz, że nadpisujesz obsługę zdarzeń i wtedy nic się nie dzieje. Wyobraź sobie, że chcesz dodać detektor zdarzeń do jakiegoś komponentu interfejsu użytkownika:

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

Powyżej kod kompiluje i uruchamia się, ale jeśli przesuniesz mysz w środku jakiegoś komponentu, kod" zrób coś " zwróci uwagę na run, ponieważ w rzeczywistości nie nadpisujesz metody bazowej mouseEntered(MouseEvent ev). Po prostu tworzysz nową metodę bez parametrów mouseEntered(). Zamiast tego kodu, jeśli użyłeś adnotacji @Override, zauważyłeś błąd kompilacji i nie traciłeś czasu na zastanawianie się, dlaczego twój handler zdarzeń nie działa.

@Override na implementacja interfejsu jest niespójna, ponieważ w Javie nie ma czegoś takiego jak "nadpisywanie interfejsu".

@Override na implementacja interfejsu jest bezużyteczna, ponieważ w praktyce nie łapie żadnych błędów, których kompilacja i tak by nie złapała. Istnieje tylko jeden, naciągany scenariusz, w którym override na implementatorach rzeczywiście coś robi: jeśli zaimplementujesz interfejs, a interfejs usunie metody, zostaniesz powiadomiony w czasie kompilacji, że powinien 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 implementujesz nowych rzeczy.

@Override na implementerach interfejsu nigdy nie powinno być dozwolone w 1.6, A Z eclipse niestety wybierając automatyczne wstawianie adnotacji jako domyślne zachowanie, dostajemy dużo zaśmieconych plików źródłowych. Podczas odczytywania kodu 1.6 nie można zobaczyć adnotacji @Override, jeśli metoda w rzeczywistości nadpisuje metodę w klasie nadrzędnej lub po prostu implementuje interfejs.

Użycie @ Override, gdy faktycznie nadpisuje metodę w klasie superclass jest w porządku.

Najlepiej używać go dla każdej metody przeznaczonej jako nadpisanie, a Java 6+, dla każdej metody przeznaczonej jako implementacja interfejsu.

Po pierwsze, wyłapuje błędy pisowni, takie jak "hashcode() "zamiast" hashCode()" podczas kompilacji. Debugowanie może być zdumiewające, dlaczego wynik Twojej metody wydaje się nie pasować do Twojego kodu, gdy prawdziwa przyczyna jest taka, że Twój kod nigdy nie jest wywoływany.

Ponadto, jeśli Klasa nadrzędna zmieni podpis metody, nadpisania starszego podpisu mogą być "osierocone", pozostawione za mylącym martwym kodem. Adnotacja @Override pomoże Ci zidentyfikować te sieroty, dzięki czemu można je zmodyfikować, aby pasowały do nowego podpisu.

Jeśli często nadpisujesz (nieabstraktowe) metody, prawdopodobnie chcesz rzucić okiem na swój projekt. Jest to bardzo przydatne, gdy kompilator nie wychwyciłby błędu. Na przykład próba nadpisania initvalue() w threadlocal, co zrobiłem.

Używanie @ Override podczas implementacji metod interfejsu (1.6+ feature) wydaje mi się trochę przesadą. Jeśli masz mnóstwo metod, z których niektóre nadpisują, a niektóre nie, to prawdopodobnie znowu zły projekt (i twój edytor prawdopodobnie pokaże, który jest który, jeśli nie wiesz).

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

Inną rzeczą 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 Joshuy Block Effective Java (2nd edition) pozycja 36 zawiera więcej szczegółów na temat korzyści płynących z adnotacji.

Używanie @Override przy implementacji metody interfejsu nie ma absolutnie żadnego sensu. Nie ma w tym przypadku żadnej korzyści-kompilator już złapie twój błąd, więc jest to po prostu zbędny bałagan.

Gdy metoda nadpisuje inną metodę lub metoda implementuje podpis w interfejsie.

Adnotacja @Override zapewnia, że faktycznie coś nadpisałeś. Bez adnotacji ryzykujesz błędną pisownię lub różnicę w typach parametrów i liczbie.

Używam go za każdym razem. To więcej informacji, które mogę wykorzystać, aby szybko zorientować się, co się dzieje, gdy wracam do kodu w ciągu roku i zapomniałem, co myślałem za pierwszym razem.

Najlepszą praktyką jest zawsze używać go (lub mieć IDE wypełnić je dla Ciebie)

@Override użyteczność polega na wykrywaniu zmian w klasach nadrzędnych, które nie zostały zgłoszone w dół hierarchii. Bez niego, możesz zmienić podpis metody i zapomnieć zmienić jej przesłonięcia, za pomocą @Override, kompilator złapie ją za Ciebie.

Taka siatka bezpieczeństwa jest zawsze dobra.

Używam go wszędzie. W temacie wysiłku na Metody znakowania, pozwoliłem Eclipse zrobić to za mnie, więc nie jest to dodatkowy wysiłek.

Jestem religijny o ciągłej refaktoryzacji.... wykorzystam każdy drobiazg, żeby poszło gładko.

• używane tylko w deklaracjach metod.
• wskazuje, że metoda adnotacji deklaracja zastępuje deklarację w supertypie.

jeśli jest używany konsekwentnie, chroni Cię przed dużą klasą nikczemnych błędów.

Użyj adnotacji @ Override, aby uniknąć tych błędów: (Wykryj błąd w poniższym 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());
    }
}

Source: Effective Java

Bądź ostrożny, gdy używasz Override, ponieważ nie możesz później wykonać inżynierii wstecznej w starUML; najpierw zrób uml.

Wydaje się, że mądrość tutaj się zmienia. Dzisiaj zainstalowałem IntelliJ IDEA 9 i zauważyłem, że jego "missing @Override inspection " łapie teraz nie tylko zaimplementowane abstrakcyjne metody, ale także zaimplementowane metody interfejsu. W kodzie mojego pracodawcy i w moich własnych projektach, od dawna mam zwyczaj używać tylko @Override dla pierwszych -- zaimplementowanych abstrakcyjnych metod. Jednak, przemyślając nawyk, zasadność korzystania z adnotacji w obu przypadkach staje się jasna. Pomimo jest bardziej gadatliwy, chroni przed problemem fragile base class (nie tak poważnym jak przykłady związane z C++), w którym zmienia się nazwa metody interfejsu, zastępując przyszłą metodę implementującą w klasie pochodnej.

Oczywiście, ten scenariusz jest głównie hiperbolą; Klasa pochodna nie kompilowałaby się, obecnie brakuje implementacji metody zmienionej nazwy interfejsu, a dzisiaj prawdopodobnie użylibyśmy refaktoryzacji Rename Method w celu zaadresowania całego kodu baza masowo.

Biorąc pod uwagę, że Inspekcja pomysłu nie jest konfigurowalna, aby ignorować zaimplementowane metody interfejsu, dziś zmienię zarówno mój nawyk, jak i kryteria oceny kodu mojego zespołu.

Adnotacja @Override służy do sprawdzenia, czy programista, co ma zastąpić poprawną metodę w klasie nadrzędnej lub interfejsie. Gdy zmieni się nazwa metod super, kompilator może powiadomić o tym przypadek, co jest tylko dla zachowania spójności z super i podklasą.

BTW, jeśli nie ogłosiliśmy adnotacji @Override w podklasie, ale nadpisaliśmy niektóre metody super, to funkcja może działać jak ta z @ Override. Ale to metoda nie może powiadomić dewelopera, gdy metoda super została zmieniona. Bo nie zna celu programisty -- nadpisać metodę super czy zdefiniować nową metodę?

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

Używam go jak najwięcej, aby określić, kiedy metoda jest nadpisywana. Jeśli spojrzysz na język programowania Scala, mają one również słowo kluczowe override. Uważam to za przydatne.

Pozwala ci (dobrze, kompilator) na przechwytywanie, gdy użyłeś niewłaściwej pisowni na nazwie metody, którą nadpisujesz.

Override adnotacja jest używana do wykorzystania kompilatora do sprawdzania, czy rzeczywiście nadpisujesz metodę z klasy nadrzędnej. Jest on używany do powiadamiania, jeśli popełnisz jakikolwiek błąd, taki jak błąd literowania nazwy metody, błąd nieprawidłowego dopasowania parametrów

Myślę, że najlepiej jest zakodować @ override, gdy jest to dozwolone. pomaga w kodowaniu. należy jednak zauważyć, że dla ecipse Helios, sdk 5 lub 6, adnotacja @ override dla zaimplementowanych metod interfejsu jest dozwolona. jeśli chodzi o Galileo, albo 5 albo 6, adnotacja @override nie jest dozwolona.

Adnotacje dostarczają kompilatorowi metadanych o kodzie, a adnotacja @Override jest używana w przypadku dziedziczenia, gdy nadpisujemy dowolną metodę klasy bazowej. Po prostu mówi kompilatorowi, że nadpisujesz metodę. Może to uniknąć niektórych rodzajów typowych błędów, które możemy zrobić, jak nie przestrzeganie właściwego podpisu metody lub błędne w nazwie metody itp. Więc dobrą praktyką jest używanie adnotacji @ Override.

Dla mnie @ Override zapewnia mi poprawny podpis metody. Jeśli wpiszę adnotację i metoda nie jest poprawnie napisana, kompilator narzeka, dając mi znać, że coś jest nie tak.

Proste - jeśli chcesz nadpisać metodę obecną w twojej klasie nadrzędnej, użyj adnotacji @Override, aby wykonać poprawne nadpisanie. Kompilator ostrzeże cię, jeśli nie nadpisasz go poprawnie.