Przedstawione poniżej wskazówki pomogą zwiększyć wydajność pracy. Ogólne wskazówki dotyczące platformy Eclipse można również znaleźć w temacie Wskazówki dotyczące platformy, a informacje o opcjach tej wersji w temacie Co nowego w wersji 3.6 (JDT).
Edytowanie | Refaktoryzacja | Wyszukiwanie | Nawigacja | Widoki | Różne | Debugowanie
| Aktywna obsługa treści | Aktywna obsługa treści udostępnia listę sugerowanych uzupełnień dla
częściowo wprowadzonych łańcuchów.
W edytorze Java należy nacisnąć kombinację klawiszy
Ctrl+Spacja lub użyć opcji Edycja > Aktywna obsługa treści.
|
| Aktywna obsługa treści w komentarzach dokumentacji Javadoc | Aktywna obsługa treści jest także dostępna w komentarzach dokumentacji Javadoc.
|
| Aktywna obsługa treści dla importów statycznych | Aby otrzymywać podpowiedzi aktywnej obsługi treści dotyczące składowych statycznych, zdefiniuj listę ulubionych składowych statycznych na stronie preferencji
Java > Edytor > Aktywna obsługa treści > Ulubione.
Jeśli na przykład do tej listy została dodana pozycja
|
| Blokowanie typów w aktywnej obsłudze treści |
Aby zablokować wyświetlanie niektórych typów przez aktywnej obsługi treści, użyj funkcji filtru typów, którą można skonfigurować na stronie preferencji Java > Wygląd > Filtry typów. Typy odpowiadające jednemu ze skonfigurowanych wzorców nie będą
wyświetlane w oknie dialogowym Otwieranie typu i nie będą udostępniane przez funkcje
aktywnej obsługi treści, szybkiej poprawki i organizowania instrukcji importu. Wzorce
te nie wpływają na widoki Hierarchia typów i Eksplorator pakietów.
|
| Korzystanie z aktywnej obsługi treści do uzupełniania zmiennych, parametrów metod i nazw pól |
Za pomocą aktywnej obsługi treści można przyspieszyć tworzenie pól, parametrów
metod i zmiennych lokalnych. Po umieszczeniu kursora za nazwą typu deklaracji,
należy nacisnąć kombinację klawiszy Ctrl+Spacja lub użyć opcji Edycja > Aktywna obsługa treści.
Jeśli w nazwach pól, zmiennych lokalnych lub parametrów używane są przedrostki lub przyrostki, podaj odpowiednie informacje na stronie preferencji |
| Aktywna obsługa treści dla zmiennych nierozstrzygniętego typu | Podpowiedzi aktywnej obsługi kodu mogą również dotyczyć dostępu do typów, które jeszcze nie zostały zaimportowane. W zależności od ustawienia preferencji
Java > Edytor > Aktywna obsługa treści > Dodaj import zamiast nazwy kwalifikowanej, edytor może albo automatycznie dodawać importy, albo tworzyć pełne ścieżki typów wyświetlanych w takich propozycjach.
Naciśnięcie klawisza ; w następującej sytuacji:
Wynik:
|
| Aktywna obsługa treści po wystąpieniu warunku instanceof | Aktywna obsługa treści może
proponować dostępne składowe na podstawie typów użytych w warunkach instanceof.
Po wybraniu takiej propozycji środowisko Eclipse doda potrzebne rzutowanie. |
| Wskazówki do parametrów | Umieszczenie kursora w argumencie metody pozwala wyświetlić listę
wskazówek dotyczących parametrów. W edytorze Java należy nacisnąć kombinację
klawiszy Ctrl+Shift+Spacja lub wywołać opcję Edycja > Aktywna obsługa
treści > Wskazówki do parametrów.
|
| Aktywna obsługa treści dla klas anonimowych | Aktywna obsługa treści udostępnia również pomoc podczas tworzenia klasy
anonimowej. Gdy kursor znajdzie się po słowie "new" i na początku nazwy klasy
abstrakcyjnej lub interfejsu, należy nacisnąć kombinację klawiszy Ctrl+Spacja lub
wybrać opcję Edycja > Aktywna obsługa treści > Domyślne.
Działa to również po umieszczeniu kursora za nawiasem otwierającym tworzenie instancji klasy:
|
| Przełączanie trybu aktywnej obsługi treści (wstawianie i zastępowanie) | Po wywołaniu aktywnej obsługi treści dla istniejącego identyfikatora może ona albo zastąpić ten identyfikator wybranym uzupełnieniem, albo wstawić nową treść. Zachowanie domyślne (zastępowanie lub wstawianie) można zdefiniować na stronie preferencji Java > Edytor > Aktywna obsługa treści.Aby tymczasowo przełączyć to zachowanie w oknie dialogowym wyboru sugestii aktywnej obsługi treści, naciśnij i przytrzymaj klawisz Ctrl podczas wybierania uzupełnienia. |
| Przyrostowe uzupełnianie aktywnej obsługi treści | Aktywna obsługa treści może teraz również Automatycznie wstawiać typowe przedrostki (zachowanie podobne, jak w przypadku rozszerzeń powłoki systemu Unix). Aby włączyć takie zachowanie, zaznacz pole wyboru na stronie preferencji Java > Edytor > Aktywna obsługa treści.
|
| Obsługa notacji CamelCase w trakcie uzupełniania kodu | W trakcie uzupełniania kodu są obsługiwane wzorce CamelCase.
Na przykład aktywowanie uzupełniania kodu na tekście NPE lub NuPoiE spowoduje zaproponowanie NullPointerException.
Funkcję tę można wyłączyć za pomocą preferencji Pokaż dopasowania zapisu camel case na stronie preferencji Java > Edytor > Aktywna obsługa treści.
|
| Dostosowywanie kategorii aktywnej obsługi treści |
Za każdym wywołaniem aktywnej obsługi treści (Ctrl+Spacja) są wyświetlane kolejne kategorie propozycji.
Java > Edytor > Aktywna obsługa treści > Zaawansowane.
Można również przypisać osobne klawisze skrótu do ulubionych kategorii propozycji. |
| Tworzenie metod pobierających i ustawiających | Aby utworzyć metody pobierające i ustawiające dla danego pola,
wybierz jego deklarację i wywołaj opcję Źródło > Generuj metody
pobierające i ustawiające.
Java > Styl kodu. |
| Szybka asysta umożliwiająca tworzenie metod pobierających i ustawiających | Dla pól dostępna jest szybka
asysta (Ctrl+1), która umożliwia tworzenie metod pobierających i
ustawiających.
|
| Tworzenie metod pobierających i ustawiających za pomocą aktywnej obsługi treści | Innym sposobem tworzenia metod pobierających i ustawiających jest
użycie aktywnej obsługi treści. Umieść kursor w treści typu między składowymi i naciśnij kombinację klawiszy Ctrl+Spacja,
aby wyświetlić propozycje umożliwiające utworzenie szkieletu metody pobierającej lub ustawiającej. ![]() |
| Usuwanie metod pobierających i ustawiających wraz z polem | Podczas usuwania pól z poziomu widoku w środowisku Eclipse może być
wyświetlana propozycja usunięcia odpowiadających temu polu metod pobierających
i ustawiających.
Jeśli w nazwach pól używane są przedrostki lub przyrostki, podaj odpowiednie informacje na stronie preferencji Java > Styl kodu. |
| Tworzenie metod delegowanych | Aby utworzyć metodę delegowaną dla danego pola, wybierz jego
deklarację i wywołaj opcję Źródło > Generuj metody delegowane. Spowoduje to dodanie wybranych metod do typu zawierającego wywołanie wyprzedzające do metod delegowanych. Poniżej przedstawiono przykład metody delegowanej:
|
Utwórz metody hashCode() i equals()
|
Aby utworzyć metody hashCode() i equals(), wywołaj opcję Źródło > Generuj metody hashCode() i equals().
|
| Używanie szablonów do tworzenia metod | Szablony są
wyświetlane wraz z propozycjami aktywnej obsługi treści (Ctrl+Spacja). Dostępne są gotowe szablony, takie jak "private_method", "public_method", "protected_method" i inne, ale można też definiować nowej szablony szkieletów metod. Gdy szablon zostanie już zastosowany, do przechodzenia między
wprowadzanymi wartościami (typ zwracanej wartości, nazwa i argumenty) służy
klawisz Tab. |
| Tworzenie widgetów SWT za pomocą szablonów | W projektach, których ścieżka klas zawiera bibliotekę SWT, można utworzyć widgety SWT, korzystając z
aktywnej obsługi treści (Ctrl+Spacja).
Aby na przykład dodać przycisk SWT, należy wpisać Button i nacisnąć klawisze Ctrl+spacja, a następnie wybrać szablon SWT Button i nacisnąć klawisz Enter. Wszystkie dostępne szablony można obejrzeć na stronie
preferencji
|
| Tworzenie własnych szablonów |
Aby utworzyć własne szablony, przejdź do strony preferencji Java > Edytor> Szablony i naciśnij przycisk Nowy, aby utworzyć szablon. Na przykład szablon służący do iterowania wstecz w tablicy może wyglądać następująco:
|
| Korzystanie z funkcji szybkiej poprawki do tworzenia nowych metod | Rozpocznij od utworzenia wywołania metody i użyj funkcji szybkiej poprawki (Ctrl+1), aby utworzyć tę metodę.
|
| Korzystanie z funkcji szybkiej poprawki do modyfikowania sygnatur metod | Dodaj argument do wywołania metody w miejscu wywołania. Następnie użyj funkcji szybkiej poprawki (Ctrl+1), aby dodać wymagany parametr w deklaracji metody.
|
| Używanie aktywnej obsługi treści do tworzenia szkieletu konstruktora | W miejscu, w którym chcesz dodać nowy konstruktor, wpisz pierwsze litery nazwy konstruktora, a następnie użyj aktywnej obsługi treści.![]() |
| Tworzenie nowych pól na podstawie parametrów | Chcesz utworzyć nowe pola służące do przechowywania argumentów
przekazywanych w konstruktorze? Użyj funkcji szybkiej asysty (Ctrl+1) dla parametru, aby utworzyć przypisanie i deklarację pola,
a środowisko Eclipse zaproponuje nazwę zgodną z ustalonymi preferencjami stylu kodu.![]() |
| Używanie aktywnej obsługi treści do przesłaniania metod | Wywołaj aktywnej obsługi treści (Ctrl+Spacja) w treści typu w miejscu,
w którym ma być dodana metoda. Aktywna obsługa treści udostępni wszystkie metody,
które mogą zostać przesłonięte. Zostanie utworzona treść dla wybranej metody.
|
| Korzystanie z funkcji szybkiej poprawki do dodawania niezaimplementowanych metod | Aby zaimplementować nowy interfejs, dodaj najpierw do typu deklarację implements.
Nawet bez zapisania lub zbudowania typ zostanie podkreślony w edytorze Java, aby zasygnalizować brak metod. Zostanie również
wyświetlona ikona żarówki szybkiej poprawki. Kliknij tę ikonę lub naciśnij kombinację klawiszy Ctrl+1 (Edycja > Szybka poprawka), aby wybrać opcję dodania niezaimplementowanych metod lub opcję przekształcenia klasy w klasę abstrakcyjną.
|
| Korzystanie z operacji czyszczenia w celu dodania niezaimplementowanych metod | Podczas dodawania nowej metody do interfejsu lub metody abstrakcyjnej do klasy abstrakcyjnej środowisko Eclipse może wygenerować szkielety metod we wszystkich konkretnych podklasach jednocześnie. W tym celu należy wywołać opcję Źródło > Wyczyść dla zestawu elementów Java, użyć profilu niestandardowego i wybrać opcję Dodaj niezaimplementowane metody na karcie Brakujący kod w oknie dialogowym Konfiguracja. |
| Przesłonięcie metody z klasy bazowej | Aby utworzyć metodę, która przesłania metodę z klasy bazowej: Wybierz typ, w którym mają zostać dodane metody, i wywołaj opcję Źródło > Przesłoń/implementuj metody. Spowoduje to otwarcie okna dialogowego, które umożliwia wybranie metod do przesłonięcia.
|
| Zmiana nazwy elementu w pliku | Aby przeprowadzić szybką operację zmiany nazwy elementu, która nie wymaga przeprowadzenia pełnej analizy zależności w innych plikach, użyj funkcji szybkiej asysty Zmień nazwę w pliku. W edytorze Java umieść kursor w obrębie identyfikatora zmiennej, metody lub typu i naciśnij kombinację klawiszy Ctrl+1 (Edycja > Szybka poprawka). Edytor zostanie przełączony w tryb edycji połączonej (podobnie jak w przypadku szablonów). Zmiana identyfikatora spowoduje jednoczesne zmodyfikowanie wszystkich pozostałych odwołań do danej zmiennej, metody lub typu.
Ogólne > Klawisze (w kategorii Źródło)
|
| Korzystanie z funkcji szybkiej poprawki do obsługi wyjątków | Obsługa zgłoszonych wyjątków jest łatwa. Nieobsłużone wyjątki są wykrywane podczas pisania i oznaczane w edytorze czerwoną linią.
|
| Uproszczone wprowadzanie przypisań | Zamiast wpisywać przypisanie, rozpocznij od wyrażenia, które ma zostać przypisane.
![]() |
| Uproszczone wprowadzanie wyrażeń rzutowania | Nie musisz już mozolnie wpisywać instrukcji rzutowania. Początkowo pomiń je, a następnie użyj funkcji szybkiej asysty, aby dodać rzutowania po zakończeniu wpisywania instrukcji.
Na przykład dla przypisań: |
| Przypisywanie rzutowanego wyrażenia |
Powszechną praktyką jest rzutowanie wyrażenia i przypisanie go do nowej zmiennej
lokalnej po sprawdzeniu instanceof. Aby ograniczyć ręczne wpisywanie, wywołaj funkcję Szybka asysta (Ctrl+1) na słowie kluczowym instanceof lub na początku treści bloku:
|
| Otaczanie wierszy | Aby otoczyć instrukcje blokiem lub instrukcją if/while/for, zaznacz wiersze do otoczenia i wywołaj opcję Źródło > Otocz lub naciśnij kombinację klawiszy Alt+Shift+Z.
Wpisy w menu pochodzą ze zwykłych szablonów edytora: w menu są wyświetlane wszystkie szablony zawierające zmienną ${line_selection}. Szablony można skonfigurować na stronie preferencji Java > Edytor > Szablony. Aby dostosować kod wynikowy lub zdefiniować własne szablony otaczania, należy edytować odpowiednie szablony. |
| Więcej szybkich asyst i poprawek |
Pełną listę dostępnych transformacji kodu, można znaleźć na stronie Szybka asysta. Listę szybkich poprawek można znaleźć tutaj. |
| Skróty do szybkich poprawek i asyst |
Niektóre często stosowane operacje szybkiej asysty, na przykład Zmień nazwę w pliku czy Przypisz do zmiennej lokalnej, można wywoływać bezpośrednio za pomocą kombinacji klawiszy Ctrl+2 R i Ctrl+2 L. Inne szybkie poprawki i operacje szybkiej asysty wywoływane bezpośrednio możesz znaleźć na stronie preferencji Ogólne > Klawisze.
W polu filtru należy wpisać wartość Szybka asysta lub Szybka poprawka:
|
| Nazwy argumentów mogą być wstawiane automatycznie przez aktywną obsługę treści |
Aktywna obsługa treści może automatycznie wstawiać nazwy argumentów podczas
uzupełniania metody. Zachowanie to można dostosować na stronie preferencji
Java > Edytor >
Asystent treści (patrz pole wyboru Wypełnij argumenty metody i
pokaż wykryte argumenty). Na przykład wybranie drugiej pozycji:
spowoduje, że aktywna obsługa treści automatycznie wstawi nazwy argumentów:
Między wstawianymi nazwami można przechodzić, naciskając klawisz Tab. Jeśli zostanie wybrana opcja Wstaw argumenty wykryte z wysokim prawdopodobieństwem, argumenty wykryte z wysokim prawdopodobieństwem będą wstawiane domyślnie. Alternatywne propozycje będą również dostępne. |
| Automatycznie wstawiaj argumenty typu |
Włączenie opcji Wypełnij argumenty metody i
pokaż wykryte argumenty na stronie preferencji
Java > Edytor >
Asystent treści może być również pomocne podczas pracy z typami
sparametryzowanymi w środowisku J2SE 5.0.
Wynik:
|
| Usuwanie otaczających instrukcji | Aby usunąć otaczającą instrukcję lub blok, umieść kursor przy
nawiasie otwierającym lub zamykającym i naciśnij kombinację klawiszy Ctrl+1 (Edycja > Szybka poprawka).
|
| Sprawdzanie pisowni | Obsługę sprawdzania pisowni w edytorze Java można włączyć na stronie preferencji Ogólne > Edytory > Edytory tekstu > Pisownia. Błędy pisowni są wyświetlane
w edytorze Java. Dostępne są również odpowiadające im szybkie poprawki:
Słownik można również udostępnić aktywnej obsłudze treści. Szybka poprawka umożliwia dodawanie nowych słów do słownika użytkownika podczas pracy. |
| Wybieranie strukturalne | Działania wyboru ustrukturyzowanego mogą być
używane do powiększania bieżącego wyboru tak, aby objął kolejny element
obejmujący:
Należy podświetlić tekst i nacisnąć kombinację klawiszy Alt+Shift+Strzałka w górę lub wybrać na pasku menu opcję Edycja > Rozwiń wybór do > Element obejmujący. Wybór zostanie rozwinięty do najmniejszego elementu składni Java zawierającego dane zaznaczenie. Można jeszcze bardziej rozwinąć wybór, ponownie wywołując to samo działanie (lub inne działania z menu Rozwiń wybór do). Ta funkcja może być użyteczna na przykład przy wybieraniu obejmującego identyfikatora w celu zmiany nazwy lub przy wybieraniu przylegających instrukcji na potrzeby refaktoryzacji wyodrębniania metody. |
| Znajdowanie pasujących nawiasów | Aby znaleźć pasujący nawias, zaznacz nawias otwierający lub
zamykający i naciśnij kombinację klawiszy Ctrl+Shift+P lub wybierz opcję Nawigacja > Idź
do > Pasujący nawias. Można też dwukrotnie kliknąć
obok nawiasu - spowoduje to zaznaczenie tekstu między nawiasami.
Edytor Java obsługuje też podświetlanie obejmujących nawiasów.
Tę opcję można skonfigurować na stronie preferencji
|
| Inteligentna dokumentacja Javadoc | Wpisz "/**" i naciśnij klawisz Enter. Spowoduje to
automatyczne dodanie szkieletu komentarza Javadoc zawierającego standardowe
znaczniki @param, @return oraz @exception.
Java > Styl kodu> Szablony kodu.
|
| Korzystanie z lokalnej historii do przywracania wcześniejszej wersji metody | Podczas edycji pliku jego wcześniejsza treść jest przechowywana w
lokalnej historii. Narzędzia Java umożliwiają uzyskanie dostępu do poszczególnych elementów Java przechowywanych w historii, dzięki czemu można przywrócić wcześniejszą wersję pojedynczej metody (nie trzeba odtwarzać całego pliku).
Zaznacz element (np. na widoku Schemat) i użyj opcji Zamień na > Lokalna historia, aby przywrócić wcześniejszą wersję elementu.
|
| Korzystanie z lokalnej historii do odtwarzania usuniętych metod | Podczas edycji pliku jego wcześniejsza treść jest przechowywana w
lokalnej historii. Narzędzia Java umożliwiają uzyskanie dostępu do elementów Java przechowywanych w tej historii, tak aby można było odtwarzać usunięte metody w sposób selektywny.
Zaznacz kontener (np. na widoku Schemat) i użyj opcji Odtwórz z lokalnej historii, aby odtworzyć usunięte składowe.
|
| Generowanie konfigurowalnego kodu | Na stronie preferencji Java > Styl kodu > Szablony kodu można dostosować generowany kod i komentarze w podobny sposób, jak w przypadku zwykłych szablonów.
Te szablony kodu są używane przy generowaniu kodu.
|
| Tworzenie komentarzy w kodzie | Komentarze można dodawać jawnie za pomocą opcji Źródło > Generowanie komentarza elementu (Alt+Shift+J) lub automatycznie przy użyciu kreatorów, refaktoryzacji lub szybkich poprawek. Szablony komentarzy można skonfigurować na stronie preferencji Java > Styl kodu > Szablony kodu.Automatyczne generowanie komentarzy można włączać lub wyłączać bezpośrednio w kreatorze (np. za pomocą pola wyboru Generuj komentarz w kreatorach nowego typu Java) lub za pomocą pola wyboru Automatycznie dodawaj nowe komentarze dla nowych metod i typów znajdującego się na stronie preferencji Java > Styl kodu > Szablony kodu.Te opcje można także skonfigurować dla poszczególnych projektów. Aby włączyć ustawienia właściwe dla projektu, otwórz jego Właściwości. |
| Sortowanie składowych | Składowe jednostki lub wielu jednostek kompilacji Java można sortować za pomocą opcji Sortuj składowe zgodnie z porządkiem kategorii zdefiniowanym na stronie preferencji Java > Wygląd> Porządek sortowania składowych.Odpowiednią akcję można znaleźć w menu, wybierając opcję Źródło > Sortuj składowe. |
| Zawijanie łańcuchów |
Literały łańcuchowe mogą być zawijane podczas edycji. W przypadku np. następującego kodu:
String message= "To jest bardzo długi komunikat."; można umieścić kursor za słowem "bardzo" i nacisnąć klawisz Enter. Kod zostanie automatycznie zmieniony na: String message= "To jest bardzo" +
" długi komunikat.";
Zachowanie to można dostosować na stronie preferencji |
| Inteligentne wpisywanie i sposoby sterowania tą funkcją |
Funkcje edytora Java związane z inteligentnym wpisywaniem ułatwiają codzienną
pracę. Można je skonfigurować na stronie preferencji Java > Edytor > Wpisywanie.
Po włączeniu opcji Automatyczne wstawianie średników w odpowiedniej pozycji przy wpisywaniu średnika kursor
zostanie przeniesiony na koniec instrukcji przed jego wstawieniem. Eliminuje to konieczność dodatkowego przemieszczania kursora. |
| Naprawianie wcięć w kodzie jednym naciśnięciem klawisza | Jedną z bardzo użytecznych funkcji jest opcja Źródło
> Popraw wcięcie, którą można także wywołać za pomocą kombinacji klawiszy Ctrl+I. Zaznacz fragment kodu z niepoprawnymi wcięciami i wywołaj tę akcję. Jeśli nic nie jest zaznaczone, wcięcie zostanie wykonane w bieżącym wierszu. |
| Naprawianie wcięć w kodzie przy zapisywaniu | Środowisko Eclipse może poprawiać
wcięcia w kodzie w momencie zapisywania zmian w edytorze. W tym celu należy przejść do
strony preferencji
Java > Edytor > Działania
zapisywania i wybrać opcję Konfiguruj Dodatkowe
działania, a następnie opcję Popraw wcięcia na karcie
Organizowanie kodu.
|
| Szybkie menu dla akcji menu Źródło i Refaktoryzacja |
Dostęp do akcji refaktoryzacji i kodu źródłowego można uzyskać za
pośrednictwem szybkiego menu. Zaznacz element, nad którym chcesz pracować w edytorze lub widoku Java, i naciśnij kombinację klawiszy Alt+Shift+S w celu wyświetlenia szybkiego menu kodu źródłowego, Alt+Shift+T w celu wyświetlenia szybkiego menu refaktoryzacji lub Alt+Shift+Z w celu wyświetlenia menu otaczania.
|
| Znajdowanie nieużywanego kodu | Kompilator Java wykrywa nieosiągalny kod, nieużywane zmienne,
parametry i instrukcje importu oraz nieużywane typy, metody i pola private.
Ustawienia wykrywania można zmieniać na stronie preferencji
Java > Kompilator > Błędy/Ostrzeżenia. Ustawienia te można również określać na poziomie projektu - w tym celu należy skorzystać ze strony Projekt > Właściwości > Kompilator Java > Błędy/Ostrzeżenia.
|
| Znajdowanie problemów z wartością null | Kompilator może wspomagać programistę w lokalizowaniu problemów związanych w obecnością w kodzie wartości null.
Na stronie preferencji Java > Kompilator > Błędy/Ostrzeżenia dostępne są trzy opcje wykrywania problemów:
|
| Znajdowanie problemów z eksternalizowanymi łańcuchami | Działanie Źródło > Szukaj zerwanych
eksternalizowanych łańcuchów wyszukuje niezdefiniowane, nieużywane i zduplikowane klucze:
|
| Zmiana istotności problemu w podpowiedzi dotyczącej problemu | Po powiększeniu podpowiedzi
dotyczącej problemu (przez naciśnięcie klawisza F2 lub umieszczenie wskaźnika
myszy w obszarze podpowiedzi) udostępniane jest działanie umożliwiające zmianę istotności
bieżącego problemu.
Kliknięcie tego przycisku na pasku narzędzi powoduje przejście do
strony preferencji
|
| Obsługa komentarzy dokumentacji Javadoc | Kompilator Java w środowisku Eclipse może przetwarzać komentarze
dokumentacji Javadoc. Istnieje możliwość wyszukiwania odwołań w komentarzach dokumentacji, a refaktoryzacja powoduje aktualizowanie tych odwołań. Działaniem tej funkcji można sterować na stronie preferencji Java > Kompilator > Dokumentacja Javadoc. Można również określać jej ustawienia dla poszczególnych projektów, wybierając
opcję Projekt > Właściwości > Kompilator Java > Dokumentacja Javadoc.
|
| Blokowanie ostrzeżeń | W środowiskach J2SE 5.0 i nowszych można zablokować wszystkie opcjonalne ostrzeżenia kompilacji za pomocą adnotacji SuppressWarnings.W poniższym przykładzie metoda addAll() została oznaczona jako nieużywana. Aby zablokować wyświetlanie ostrzeżenia dla tej metody, za pomocą opcji Szybka poprawka (Ctrl+1) dodana zostaje adnotacja SuppressWarnings.
|
| Czyszczenie kodu | Funkcja Źródło > Czyść pozwala naprawiać wiele problemów naraz i pomaga programiście utrzymać spójny styl kodowania. Można np.:
Operacje czyszczenia są zorganizowane w profile czyszczenia. Profil może być powiązany z obszarem roboczym lub poszczególnym projektami. Ustawienia projektu mogą też być współużytkowane w ramach zespołu za pośrednictwem systemu kontroli wersji. Dodatkowo możliwe jest eksportowanie i importowanie poszczególnych profili.
Procedury czyszczące mogą być wykonywane jako działania zapisywania podczas
zapisywania. Aby skonfigurować procedury czyszczące wywoływane podczas
zapisywania, należy przejść do strony
|
| Skrypty refaktoryzacji |
Większość refaktoryzacji oferowanych przez JDT można wykonywać nie tylko interaktywnie, ale również przez skrypt refaktoryzacji. Utwórz skrypt refaktoryzacji z historii refaktoryzacji, korzystając z opcji Refaktoryzacja > Utwórz skrypt. Skrypt refaktoryzacji można później zastosować w dowolnym obszarze roboczym, korzystając z opcji Refaktoryzacja > Zastosuj skrypt. Takich skryptów refaktoryzacji można używać w różnych scenariuszach, jak np. automatyczne naprawianie zmian przerywających interfejsy API między warstwami oprogramowania lub udostępnianie poprawek o bogatej semantyce. |
| Bezpieczne migrowanie plików JAR |
Podczas eksportowania pliku JAR z obszaru roboczego kreator eksportowania plików JAR oferuje opcję włączenia informacji o refaktoryzacji do pliku JAR. Wybierz opcję Plik > Eksportuj, a następnie Plik JAR. Na pierwszej stronie kreatora eksportowania pliku JAR wybierz opcję Eksportuj refaktoryzacje z wybranych projektów. Kliknij łącze, aby wybrać refaktoryzacje, które zostaną włączone. Następnie możliwa jest migracja klientów ze starej wersji pliku JAR do nowej za pomocą refaktoryzacji Refaktoryzacja > Migruj plik JAR. Ta refaktoryzacja automatycznie aktualizuje cały kod, który jest zależny od starej wersji pliku JAR, aby korzystał z nowej jego wersji. |
| Znajdowanie zmiennych i operacji odczytu/zapisu tych zmiennych | Aby znaleźć zmienne i sprawdzić ich status odczytu/zapisu, wybierz odpowiedni identyfikator (deklarację lub odwołanie do zmiennej, metody lub typu) i wywołaj opcję Szukaj > Wystąpienia w pliku > Identyfikator. Spowoduje to oznaczenie wszystkich odwołań do tego identyfikatora w danym pliku. Wyniki zostaną również wyświetlone w widoku wyszukiwania (prawo do odczytu i
prawo do zapisu oznaczone różnymi kolorami) razem z ikonami sygnalizującymi
prawo do odczytu lub zapisu zmiennej.
Możesz też użyć opcji Oznacz wystąpienia, aby dynamicznie wyróżnić wystąpienia. Wyszukiwanie może obejmować kilka plików - w tym celu skorzystaj z ogólnych funkcji wyszukiwania (Wyszukaj > Odwołania). |
| Wyszukiwanie metod z określonym typem zwracanej wartości |
Aby wyszukać metody z określonym typem zwracanej wartości, użyj oznaczenia "* <typ zwracanej wartości>" w następujący sposób:
|
| Filtrowanie wyników wyszukiwania w dokumentacji Javadoc | Domyślnie użycie funkcji Wyszukiwanie Java powoduje wyszukanie odwołań w obrębie kodu Java i dokumentacji Javadoc. Jeśli nie chcesz widzieć odwołań w dokumentacji Javadoc, możesz odfiltrować te wyniki, włączając opcję Filtrowanie dokumentacji Javadoc w menu Widok (symbol trójkąta) widoku wyszukiwania. |
| Filtrowanie potencjalnych wyników wyszukiwania | Potencjalne wyniki wyszukiwania występują wtedy, gdy problem czasu kompilacji uniemożliwia całkowite rozwiązanie dopasowania przez mechanizm wyszukiwania. Wyniki te można odfiltrować za pomocą ikony Filtruj potencjalne (symbol trójkąta). |
| Śledzenie łańcuchów wywołań metody za pomocą hierarchii wywołań |
Użyj hierarchii wywołań, aby śledzić długie, złożone łańcuchy wywołań, nie tracąc z pola widzenia pierwotnego kontekstu - po prostu wybierz metodę i wywołaj opcję Nawigacja > Otwórz hierarchię wywołań (Ctrl+Alt+H).
Można również użyć przeciągania i upuszczania, aby zastąpić dane wejściowe widoku w wybranych metodach. Kombinacja Ctrl+przeciągnięcie powoduje dodanie wybranych metod do istniejących elementów w widoku. Metody z klas anonimowych lub typów specjalnych (np. |
| Otwieranie wyboru w edytorze Java | Istnieją dwa sposoby otwierania
elementu z poziomu odwołania w edytorze Java.
Przytrzymanie klawisza Ctrl na metodzie, którą można przesłonić, spowoduje wyświetlenie elementu wywoływanego z pozycją Otwórz implementację. Jej wybranie spowoduje bezpośrednie otworzenie implementacji (jeśli istnieje tylko jedna) lub wyświetlenie wszystkich konkretnych implementacji danej metody w hierarchii jej typu deklarującego przy użyciu skróconej hierarchii typów. Nawigację w stylu odsyłaczy hipertekstowych można skonfigurować na stronie preferencji Ogólne >
Edytory > Edytory tekstu > Tworzenie odsyłaczy hipertekstowych.
|
| Schematy wstawiane | Naciśnij kombinację klawiszy Ctrl+F3 w edytorze Java, aby
wywołać schemat elementu znajdującego się w bieżącej pozycji kursora. Możesz również nacisnąć kombinację Ctrl+O (Nawigacja > Szybki schemat), aby wywołać schemat dla bieżącego pliku źródłowego.
|
| Schematy wstawiane przedstawiające dziedziczone składowe | Naciśnij ponownie kombinację klawiszy Ctrl+O lub
Ctrl+F3, aby dodać dziedziczone składowe do otwartego schematu
wstawianego. Dziedziczone składowe są opatrzone etykietą w kolorze niebieskim.
Za
pomocą menu w prawym górnym rogu możesz przefiltrować i posortować elementy schematu.
).
|
| Hierarchia wstawiana | Do wyszukania możliwych odbiorników wywołania wirtualnego możesz użyć funkcji Skrócona hierarchia typów.
Umieść kursor w obrębie wywołania metody i naciśnij kombinację klawiszy Ctrl+T (Nawigacja > Skrócona hierarchia typów).
Wszystkie typy implementujące daną metodę zostaną wyświetlone w widoku przy użyciu pełnej ikony.
Naciśnij klawisz Enter, aby otworzyć odpowiednią metodę w edytorze. Naciśnij ponownie kombinację klawiszy Ctrl+T, aby przełączyć widok na widok hierarchii nadtypów. |
| Ścieżka nawigacyjna edytora Java | Edytor Java zawiera pasek
nawigacyjny ścieżki nawigacyjnej reprezentujący ścieżkę do elementu znajdującego
się w miejscu wskazywanym przez kursor. Ścieżkę nawigacyjną można włączyć,
klikając znajdujący się na pasku narzędzi przycisk Przełącz ścieżkę nawigacyjną lub naciskając klawisze Alt+Shift+B.
Użytkownik może wybrać dowolny z elementów w ścieżce nawigacyjnej i wywołać odpowiednie działania, używając menu kontekstowego lub skrótów klawiaturowych. Możliwe jest również przechodzenie do innych elementów w ścieżce nawigacyjnej za pośrednictwem pól rozwijanych. |
| Zaawansowane wyróżnianie |
Edytor Java może wyróżniać kod źródłowy w zależności od jego semantyki (na
przykład pola static, zmienne lokalne, wywołania metod static). Przyjrzyj się różnym opcjom na stronie preferencji Java > Edytor > Kolorowanie składni.
|
| Wstępnie zwinięte regiony | Można określić, które regiony będą domyślnie zwinięte po otwarciu edytora. Aby to dostosować, należy użyć strony preferencji Java > Edytor > Zwijanie.
|
| Oznaczanie wystąpień |
Podczas pracy w edytorze można włączyć opcję Oznacz wystąpienia na pasku narzędzi
( ) lub nacisnąć kombinację klawiszy Alt+Shift+O, aby wyświetlić plik, w którym znajduje się odwołanie do zmiennej,
metody lub typu.
Do oznaczania praw do odczytu i zapisu są używane inne kolory. Wybranie typu zwracanej wartości umożliwia wyświetlenie punktów wyjścia metody. Aby oznaczyć miejsce zgłoszenia wyjątku, należy zaznaczyć dany wyjątek. Wybierz nadklasę lub interfejs, aby wyświetlić metody przesłaniające lub implementujące metodę z wybranego nadtypu. Dostrój funkcję oznaczania wystąpień na stronie preferencji Aby wystąpienia były pokazywane w widoku Wyszukiwanie, skorzystaj z funkcji Znajdź > Wystąpienia. |
| Przechodzenie do następnej/poprzedniej metody | Aby szybko przejść do następnej lub poprzedniej metody lub pola, użyj
kombinacji klawiszy Ctrl+Shift+Strzałka w górę (Nawigacja > Idź do > Poprzednia składowa) lub Ctrl+Shift+Strzałka w dół (Nawigacja > Idź do > Następna składowa). |
| Sterowanie ustawieniami przechodzenia między adnotacjami |
Do przechodzenia między adnotacjami w pliku źródłowym Java użyj przycisków Następna/Poprzednia adnotacja
znajdujących się na pasku narzędzi lub opcji Nawigacja > Następna adnotacja (Ctrl+.) oraz
Nawigacja > Poprzednia adnotacja (Ctrl+,).
Korzystając z menu rozwijanych dostępnych wraz z tymi przyciskami, możesz określić, przy jakich adnotacjach chcesz się zatrzymywać:
|
| Przypomnienia w kodzie Java | Oznaczenie komentarza w pliku źródłowym Java przy użyciu znacznika
"TODO" spowoduje, że kompilator Java automatycznie utworzy odpowiadające mu zadanie w formie przypomnienia. Otwarcie tego zadania spowoduje przejście z powrotem do znacznika "TODO" w kodzie. Na stronie preferencji Java > Kompilator > Znaczniki zadania można skonfigurować inne specjalne znaczniki (np. "FIXME"), które mają być śledzone na liście czynności.
|
| Wskazówki dotyczące okna dialogowego Otwieranie typu |
Okno dialogowe Otwieranie typu (Nawigacja > Otwieranie typu lub przycisk paska narzędzi) umożliwia znalezienie typu po jego nazwie.
![]() |
| Przypinanie podpowiedzi | Naciskając
klawisz F2 (Edycja > Pokaż opis podpowiedzi) lub umieszczając wskaźnik
myszy nad podpowiedzią, można wyświetlić tekst podpowiedzi
w postaci przewijalnego okna. W oknie tym można zaznaczać i kopiować treść, wywoływać działania
i używać odsyłaczy.
Sposób powiększania podpowiedzi można skonfigurować na stronie
preferencji
|
| Podpowiedzi w edytorze Java | Korzystając z klawiszy
modyfikujących (Shift, Ctrl i Alt), w
edytorze Java można wyświetlić różne podpowiedzi. Umieszczenie wskaźnika myszy na identyfikatorze w edytorze Java, który nie ma adnotacji o ostrzeżeniu lub problemie, domyślnie powoduje wyświetlenie podpowiedzi zawierającej dokumentację Javadoc wyodrębnioną z odpowiedniego kodu źródłowego danego elementu. Jeśli identyfikator ma adnotację o problemie, w podpowiedzi zostanie wyświetlony odpowiedni komunikat. Przytrzymując klawisz Shift, można wyświetlić kod źródłowy:
Java > Edytor > Podpowiedzi.
|
| Ustalona sygnatura metody ogólnej |
Ustaloną sygnaturę metody ogólnej można wyświetlić za pomocą podpowiedzi.
|
| Otwieranie i konfigurowanie zewnętrznej dokumentacji Javadoc | Aby otworzyć dokumentację Javadoc dla typu, metody lub pola za pomocą
kombinacji klawiszy Shift+F2 (Nawigacja > Otwórz zewnętrzną dokumentację
Javadoc), należy najpierw określić położenie dokumentacji względem
biblioteki nadrzędnej elementów (plik JAR, folder klas) lub projektu (folder źródłowy). W przypadku biblioteki otwórz stronę ścieżki budowania (Projekt > Właściwości > Ścieżka budowania Java), przejdź do pozycji Biblioteki i rozwiń węzeł biblioteki, w którym możesz przeprowadzić edycję węzła Położenie dokumentacji Javadoc. Dokumentacja może być przechowywana lokalnie w archiwum lub w folderze systemu plików lub na serwerze WWW.
|
| Organizowanie obszaru roboczego z wieloma projektami | Opcja Elementy najwyższego poziomu > Zbiory robocze w menu Widok Eksploratora pakietów umożliwia włączenie nowego trybu,
który pokazuje zbiory robocze jako elementy najwyższego poziomu. Dzięki temu zarządzanie obszarami roboczymi zawierającymi
wiele projektów jest znacznie łatwiejsze.
Aby skonfigurować, które zbiory robocze będą wyświetlane, należy użyć opcji Konfigurowanie zbiorów roboczych w menu Widok Eksploratora pakietów. To okno dialogowe umożliwia utworzenie nowych zbiorów roboczych Java oraz określenie, które zbiory robocze będą wyświetlane i w jakim porządku. Jeśli opcja Konfigurowanie zbiorów roboczych nie jest włączona, rozmieszczenie zbiorów roboczych można także zmieniać bezpośrednio w Eksploratorze pakietów za pomocą metod przeciągnij i upuść. |
||||
| Przypisywanie do zbiorów roboczych | Aby przypisać element do innego zbioru roboczego, zaznacz element w Eksploratorze pakietów i z menu podręcznego wybierz opcję Przypisz zbiory robocze.
|
||||
| Widok Deklaracja | W widoku Deklaracja ( Okna > Pokaż widok > Inne > Java > Deklaracja) prezentowany jest kod źródłowy elementu wybranego w edytorze lub widoku Java.
|
||||
| Widok Dokumentacja Javadoc | Widok Dokumentacja Javadoc ( Okna > Pokaż widok> Inne > Java > Dokumentacja Javadoc) prezentuje dokumentację Javadoc elementu wybranego w edytorze Java lub w widoku Java.
|
||||
| Widok Hierarchia typów a implementacje / definicje metod | Aby dowiedzieć się, które typy w
hierarchii przesłaniają metodę, skorzystaj z funkcji wyświetlania składowych w
hierarchii:
isEmpty() została zdefiniowana w typie List i zaimplementowana w typie ArrayList i Vector, ale nie w typie AbstractList.
|
||||
| Widok Hierarchia typów obsługuje grupowanie według typu definiującego | Widok Hierarchia typów pozwala sortować metody wybranego typu według ich typów definiujących.
Na przykład dla typu AbstractList można wyświetlić informacje o tym, że zawiera on metody zdefiniowane w typach Object, Collection i List:
|
||||
| Wskazówki dotyczące hierarchii typów |
|
||||
| Strukturalne porównywanie kodu źródłowego Java | Podczas strukturalnego porównywania kodu źródłowego Java ignorowana jest tekstowa kolejności elementów Java, takich jak metody oraz pola, dzięki czemu można łatwiej stwierdzić, które elementy zostały zmienione, dodane lub usunięte. Aby rozpocząć strukturalne porównanie plików Java, możesz użyć jednej z dwóch opcji:
|
||||
| Strukturalne porównywanie plików właściwości | Podczas strukturalnego porównanie plików właściwości Java (o rozszerzeniu .properties) ignorowana jest tekstowa kolejności właściwości, dzięki czemu można sprawdzić, które właściwości zostały zmienione, dodane lub usunięte. Aby rozpocząć strukturalne porównanie plików właściwości, możesz użyć jednej z dwóch opcji:
|
||||
| Hierarchiczna lub płaska prezentacja pakietów | W menu widoku Pakiety Java (oraz widoku Eksplorator pakietów) dostępna jest opcja umożliwiająca zmianę sposobu wyświetlania pakietów. Opcja Prezentacja pakietu > Hierarchiczny powoduje wyświetlenie pakietów w postaci drzewa, w którym pod danymi pakietami znajdują się pakiety podrzędne. Opcja Prezentacja pakietu > Płaski służy do wyświetlania pakietów w sposób standardowy, w formie płaskiej listy zawierającej wszystkie pakiety i pakiety podrzędne (jako elementy równorzędne).
|
||||
| Pakiety logiczne | W widoku Pakiety Java (w perspektywie Przeglądanie Java) pakiety o tej samej nazwie są łączone dla folderów źródłowych w obrębie danego projektu. Na tym zrzucie ekranu jest pokazany widok Pakiety zawierający pakiet logiczny.
|
||||
| Kompresowanie nazw pakietów | Jeśli nazwy pakietów są bardzo długie, można skonfigurować nazwę
skompresowaną, która będzie wyświetlana w przeglądarkach.
Konfigurację wzorca kompresji można przeprowadzić na stronie preferencji Java > Wygląd.
|
||||
| Skróty nazw pakietów | Nazwy pakietów w widokach Java mogą być skracane przy użyciu reguł niestandardowych. Na przykład następujące reguły powodują przedstawione poniżej renderowanie:
org.eclipse.ui={UI}
org.eclipse.ui.texteditor={T}
org.eclipse.ui.internal.texteditor=[iT]
Reguły skrótów można konfigurować na stronie preferencji
|
||||
| Operowanie ścieżką budowania Java bezpośrednio w Eksploratorze pakietów | Zamiast operować ścieżką budowania Java za pomocą okna Projekt > Właściwości > Ścieżka budowania Java można użyć akcji w menu kontekstowym Eksploratora pakietów.
Można na przykład dodać do ścieżki budowania nowe foldery źródłowe, archiwa i biblioteki lub włączyć pliki i foldery do folderu źródłowego czy też wykluczyć je z niego.
|
||||
| Wklejanie fragmentów kodu w celu utworzenia typu | Aby utworzyć nową jednostkę kompilacji, można wkleić fragment kodu zawierający typ Java bezpośrednio do folderu źródłowego lub pakietu
Można na przykład zaznaczyć i skopiować następujący kod źródłowy:
package pack;
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Witaj świecie");
}
}
Następnie należy zaznaczyć folder źródłowy w eksploratorze pakietów i użyć
funkcji Ctrl+V (Edycja > Wklej).
Automatycznie zostanie utworzony nowy pakiet pack i plik HelloWorld.java wraz ze skopiowaną treścią.
Możliwe jest również wklejenie metody lub zestawu instrukcji. Środowisko Eclipse automatycznie utworzy wymagane elementy obejmujące. Jeśli obiekt zostanie wklejony, gdy w eksploratorze pakietów nie jest zaznaczona żadna pozycja, środowisko Eclipse utworzy nowy projekt Java oraz plik *.java. W schowku mogą się też znajdować deklaracje wielu pakietów i typów; w takim przypadku w momencie wklejenia środowisko Eclipse automatycznie utworzy wszystkie niezbędne pakiety i pliki *.java. |
||||
| Wklejanie poprawek do eksploratora pakietów | Jaki jest najszybszy sposób zastosowania poprawki z programu Bugzilla? Wystarczy otworzyć załącznik, skopiować poprawkę do schowka i wkleić ją do eksploratora pakietów. | ||||
| Grupowanie problemów Java |
Skonfigurowanie widoku Problemy umożliwia pogrupowanie problemów Java na kategorie za pomocą opcji Grupuj wg > Typ problemu Java w menu widoku.
Java > Kompilator > Błędy/Ostrzeżenia można określić, czy konfigurowalny błąd ma być krytyczny, czy nie.
|
||||
| Indykator typu Java |
Włączenie opcji Indykator typu Java na stronie preferencji Ogólne > Wygląd > Dekoracje etykiet umożliwia stwierdzenie, jaki jest pierwszy typ w jednostce kompilacji lub pliku klasy. Wyświetlane są ozdoby interfejsów, adnotacji i wyliczeń, podczas gdy zwykła klasa pozostaje nieudekorowana.
|
| Preferencje właściwe dla projektu | Wszystkie style kodów oraz opcje kompilatora można określać dla poszczególnych projektów. Aby otworzyć stronę właściwości projektu i włączyć ustawienia właściwe dla projektu, otwórz strony właściwości projektu (Projekt > Właściwości) lub użyj odsyłacza w preferencjach obszaru roboczego (np. Java > Styl kodu).
|
||||||||||||
| Reguły dostępu |
Reguły dostępu umożliwiają wymuszenie użycia reguł interfejsu API
dla typów pochodzących z przywoływanych bibliotek. Poddaj edycji węzeł Reguły dostępu dostępny dla przywoływanych projektów,
archiwów, folderów klas i bibliotek na stronie ścieżki budowania Java (Projekt > Właściwości > Ścieżka budowania
Java). Pakiety i typy w tych odwołaniach można zaklasyfikować w następujący sposób:
Java > Kompilator > Błąd/Ostrzeżenie.
|
||||||||||||
| JUnit | Zaznacz metodę testową JUnit w widoku i wybierz opcję Wykonaj > Test JUnit z menu kontekstowego lub opcję Wykonaj > Wykonaj jako > Test JUnit z menu głównego. Spowoduje to utworzenie konfiguracji startowej umożliwiającej uruchomienie wybranego testu. | ||||||||||||
| Ukrywanie widoku JUnit do momentu wystąpienia błędów lub awarii | Otwieranie widoku JUnit można ograniczyć tylko do sytuacji, w której
występują błędy lub awarie. W tym celu należy włączyć opcję Aktywuj tylko w razie błędu/niepowodzenia w menu widoku JUnit. W ten sposób można ustawić ten widok jako szybki
widok, który nie będzie wyświetlany, jeśli wykonanie testu zakończy się poprawnie. Podczas bezproblemowego przetwarzania testów widoczna będzie następująca ikona: (liczba małych, zielonych kwadratów będzie się zwiększać, sygnalizując postęp). Po zakończeniu testu zostanie wyświetlona ikona . Jednak jeśli wystąpią błędy lub awarie, ikona zmieni się na ikonę (lub po zakończeniu testów). Zostanie również wyświetlony widok JUnit. |
||||||||||||
| Aktywna obsługa treści w polach okien dialogowych | Aktywna obsługa treści (Ctrl+Spacja) jest dostępna także w polach
wejściowych różnych okien dialogowych Java. Zwróć uwagę na ikonę małej żarówki pojawiającą się obok aktywnego pola.
|
||||||||||||
| Inteligentne ustawianie kursora w oknach dialogowych, w których są wyświetlane nazwy Java |
Pola tekstowe służące do edytowania nazw Java obsługują inteligentne ustawianie kursora. Naciskając klawisze Ctrl+Lewo lub Ctrl+Prawo, zatrzymasz się na granicach zapisu camel case w nazwie. Klawisze Ctrl+Shift+Lewo i Ctrl+Shift+Prawo umożliwiają rozszerzanie wyboru małymi krokami.
Klawisz Ctrl+Delete umożliwia usunięcie następnej, a klawiszCtrl+Backspace poprzedniej części nazwy.
|
||||||||||||
| Definiowanie przedrostków i przyrostków dla pól, parametrów i zmiennych lokalnych | Dla pól, pól static, parametrów i zmiennych lokalnych można skonfigurować przedrostek lub przyrostek.
Ustawienia ze strony preferencji Java > Styl kodu są używane przez funkcje aktywnej obsługi treści, szybkiej poprawki i refaktoryzacji zawsze przy obliczaniu nazwy zmiennej.
|
||||||||||||
| Organizowanie instrukcji importu działa nie tylko dla pojedynczych plików | Opcję Źródło > Organizuj instrukcje importu można wywoływać dla zestawów jednostek kompilacji, pakietów, folderów źródłowych i projektów Java. | ||||||||||||
| Organizuj importy podczas zapisu | Środowisko Eclipse może automatycznie organizować importy przy każdym zapisaniu edytora.
Funkcję tę można włączyć na poziomie globalnym na stronie preferencji Java > Edytor > Akcje zapisu.
Akcje zapisu można też konfigurować na poziomie projektu, co ułatwia wprowadzenie standardowych ustawień dla całego projektu poprzez współużytkowanie ich w skali całego zespołu:
Poza organizowaniem importów, w ramach akcji zapisu może też być wykonywane formatowanie kodu i inne czynności związane z czyszczeniem. |
||||||||||||
| Formatuj zaznaczenie | Zaznacz kilka plików Java do sformatowania i wybierz opcję Źródło > Formatuj, aby sformatować wszystkie te pliki naraz. Akcja formatowania jest również dostępna dla pakietów, folderów źródłowych i projektów Java.
W edytorze Java, wybranie komendy Źródło > Formatuj (Ctrl+Shift+F) spowoduje sformatowanie tylko zaznaczonego obszaru. Jeśli nic nie jest zaznaczone, zostanie sformatowany cały plik. |
||||||||||||
| Wybór środowiska wykonawczego projektu Java | Podczas tworzenia projektu Java, który ma być współużytkowany z zespołem, dobrym zwyczajem jest używanie środowiska wykonawczego zamiast konkretnego środowiska JRE.
Środowiska wykonawcze to symboliczne reprezentacje środowisk JRE, zawierające standaryzowane wpisy, jak na przykład "J2SE-1.4" lub "J2SE-1.5". Dzięki temu w skład współużytkowanej ścieżki budowania nie wchodzi żadna ścieżka w systemie plików. Środowiska JRE można przypisywać poszczególnym środowiskom wykonawczym na stronie preferencji
Aby ustawić środowisko JRE specyficzne dla istniejącego projektu, otwórz stronę właściwości ścieżki budowania Java dla tego projektu (Projekt > Właściwości > Ścieżka budowania Java), następnie stronę Biblioteki, wybierz pozycję Biblioteka systemowa środowiska JRE i kliknij przycisk Edytuj. W oknie dialogowym Edycja biblioteki możesz wybrać środowisko wykonawcze, środowisko JRE specyficzne dla danego projektu lub domyślne środowisko JRE obszaru roboczego. |
||||||||||||
| Korzystanie z metody "przeciągnij i upuść" |
Metoda "przeciągnij i upuść" stanowi wygodną alternatywę dla opcji Edycja > Wytnij i Edycja > Wklej lub Edycja > Kopiuj i Edycja > Wklej. Jeśli chcesz skopiować zamiast przenieść, przytrzymaj klawisz Ctrl w trakcie przeciągania.
Warto wiedzieć:
|
||||||||||||
| Propagowanie znacznika nieaktualności |
Kompilator Java można skonfigurować do diagnozowania nieaktualności przy użyciu opcji na stronie
Java > Kompilator> Błąd/Ostrzeżenie.
|
||||||||||||
| Przywracanie spójności |
W rzadkich przypadkach zaburzonego funkcjonowania środowiska JDT mogą ujawniać się pewne niespójności, takie jak:
Aby przywrócić JDT do spójnego stanu, należy przeprowadzić następujące akcje dokładnie w przedstawionej tutaj kolejności:
|
||||||||||||
| Dekorator błędów ścieżki budowania |
Widoki Eksplorator pakietów i Eksplorator projektów wyświetlają ten dekorator błędów w projektach i zbiorach roboczych środowiska Java, jeśli zawierają one błędy ścieżki budowania:
|
||||||||||||
| Typ pliku „Plik *.class bez źródła” |
Nowy typ pliku Plik *.class bez źródła pozwala powiązać wewnętrzny lub zewnętrzny edytor
z plikami klas bez dołączonego źródła. Pozwala to na przykład otwierać plik klas w dekompilatorze:
|
||||||||||||
| Selektywnie ignoruj błędy/ostrzeżenia z folderów źródłowych |
Narzędzia JDT można skonfigurować tak, aby ignorowały opcjonalne błędy/ostrzeżenia z niektórych folderów źródłowych.
Patrz strona Właściwości projektu > Ścieżka budowania Java > Kompilator > Źródło.
Po ustawieniu tej opcji na wartość Tak narzędzia JDT będą ignorować błędy/ostrzeżenia skonfigurowane na stronie preferencji
|
|
Uruchamianie z poziomu menu kontekstowego |
Aplikacje Java mogą być uruchamiane i debugowane z poziomu menu kontekstowego. Można uruchomić plik źródłowy, pakiet, metodę, typ itp., wybierając opcję Wykonaj jako (lub Debuguj jako) > Aplikacja Java z menu kontekstowego w widoku lub edytorze. Innym sposobem jest użycie powiązania klawiszy skrótu dla uruchamiania aplikacji Java (Alt+Shift+D, J). Akcje najwyższego poziomu Wykonaj jako (lub Debuguj jako) zależą także od bieżącego wyboru i aktywnego edytora.
|
| Wartościowania w debugerze |
Wartościowanie fragmentów kodu jest dostępne w kilku miejscach debugera. Wybranie opcji Wyświetl lub Kontroluj z menu kontekstowego edytora lub widoku Zmienne spowoduje wyświetlenie wyniku w oknie podręcznym, którego treść można przesłać do widoków Wyświetlanie lub Wyrażenia.
|
|
Zarządzanie widokami w perspektywach innych niż Debugowanie |
Widok Debugowanie automatycznie zarządza widokami powiązanymi z debugowaniem na podstawie wyboru widoków (na przykład wyświetlanie widoków Java dla ramek stosu Java i widoków C dla ramek stosu C). Domyślnie automatyczne zarządzanie widokami odbywa się tylko w perspektywie Debugowanie, ale można je włączyć dla innych perspektyw na stronie preferencji Zarządzanie widokami dostępnej w menu rozwijanym na pasku narzędzi widoku Debugowanie. |
|
Zmienne środowiskowe |
Na karcie Środowisko można określić środowisko używane do uruchamiania aplikacji Java.
|
|
Podstawianie łańcuchów |
Dla wielu parametrów konfiguracji startowych aplikacji Java są obsługiwane zmienne. Obok większości pól obsługujących zmienne, takich jak pola argumentów programu i maszyny VM, dostępny jest przycisk Zmienne. Pole Typ główny także obsługuje zmienne; zmienna ${java_type_name} pozwala tworzyć konfiguracje uruchamiające wybrany typ.
|
|
Struktury logiczne |
Przełącznik Struktury logiczne na pasku narzędzi widoku Zmienne umożliwia dostęp do alternatywnych struktur często spotykanych typów. Środowisko JDT udostępnia widoki logiczne dla odwzorowań, kolekcji oraz elementów złożonych SWT. Struktury logiczne dla innych typów można określić na stronie preferencji Struktury logiczne.
|
|
Kolumny widoku Zmienne |
Kolumny widoku Zmienne mogą być konfigurowane przez wybranie opcji Układ > Wybierz kolumny... w menu widoku. Okno dialogowe umożliwia wybranie kolumn, które zostaną wyświetlone. Na przykład można dodać kolumnę, aby wyświetlić liczbę instancji klas (podczas debugowania przy użyciu środowiska JavaSE 1.6). Kolumny mogą być wyświetlane i ukrywane za pomocą działania Układ > Pokaż kolumny.
|
|
Pokaż odwołania |
W przypadku debugowania przy użyciu środowiska JavaSE 1.6 odwołania do obiektów można wyświetlać w widoku Zmienne przez wybranie opcji Java > Pokaż odwołania w menu widoku. Obiekt "przywoływany" zostanie wyświetlony pod każdym obiektem, który może być rozwijany w celu pokazania wszystkich odwołań do tego obiektu.
|
|
Wszystkie instancje |
W przypadku debugowania przy użyciu środowiska JavaSE 1.6 wszystkie instancje klasy mogą być sprawdzane przez wybranie klasy w schemacie edytora, w widoku zmiennych, w jednostce kompilacji lub w edytorze plików klas oraz wywołanie opcji Wszystkie instancje... z menu kontekstowego. W wywoływanym oknie dialogowym zostaną wyświetlone wszystkie instancje wybranej klasy.
|
|
Domyślne argumenty maszyny VM |
Jeśli do określonej maszyny VM przekazywane są często te same argumenty, można skonfigurować domyślne argumenty maszyny VM na stronie preferencji Zainstalowane środowiska JRE. Jest to wygodniejsze niż określanie ich dla każdej konfiguracji startowej.
|
| Zatrzymywanie w elemencie głównym |
Korzystając z opcji Zatrzymaj w elemencie głównym w ramach
konfiguracji startowej aplikacji Java można spowodować, że po uruchomieniu
programu w trybie debugowania będzie on zatrzymywany w pierwszym wykonywalnym wierszu metody main.
|
| Warunkowe punkty zatrzymania | Przy użyciu wyrażeń można definiować warunkowe punkty zatrzymania, korzystając z okna dialogowego Właściwości punktu zatrzymania... lub panelu szczegółów widoku punktów zatrzymania. Warunek steruje wstrzymaniem wykonywania w punkcie zatrzymania. Możesz wskazać, czy punkt zatrzymania ma powodować
zawieszenie wykonywania tylko w przypadku spełnienia danego warunku, czy też w
przypadku zmiany jego wartości. Edytor warunków punktów zatrzymania obsługuje aktywną obsługę treści.
|
| Debugowanie przez zapisywanie w konsoli |
Aby zapisywać w widoku Konsola, można uniknąć umieszczania instrukcji System.out.println() w kodzie na potrzeby debugowania, używając warunkowych punktów zatrzymania.
W tym celu należy ustawić warunkowy punkt zatrzymania za pomocą opcji Zawieś w przypadku wartości true, a
także warunek, który zawsze ma wartość false np.
|
| Wyłączanie punktów zatrzymania |
Jeśli często dodajesz lub usuwasz punkt zatrzymania w tym samym miejscu,
możesz wziąć pod uwagę wyłączenie go, gdy nie jest potrzebny, i ponowne
włączenie, gdy będzie to konieczne. Można to zrobić za pomocą opcji Wyłącz
punkt zatrzymania w jego menu kontekstowym lub przez usunięcie zaznaczenia
danego punktu w widoku Punkty zatrzymania.
Można także czasowo wyłączyć wszystkie punkty za pomocą akcji Pomiń wszystkie punkty zatrzymania na pasku narzędzi widoku Punkty zatrzymania. Spowoduje to, że debuger będzie pomijał wszystkie punkty zatrzymania, zachowując ich stan jako Włączony.
|
| Zmiana wartości zmiennych |
Kiedy wątek jest zawieszony w debugerze, można zmieniać wartości
zmiennych łańcuchowych i podstawowych w widoku Zmienne. Z menu
kontekstowego zmiennej wybierz opcję Zmień wartość zmiennej. Można również zmienić wartość, wpisując nową wartość w panelu Szczegóły i korzystając z akcji Przypisz wartość w menu kontekstowym (przypisanie klawisza CTRL+S).
|
| Wartości zmiennych w pomocy w dymku | Kiedy wątek jest zawieszony, umieszczenie kursora nad zmienną w
edytorze Java powoduje wyświetlenie wartości tej zmiennej w postaci pomocy w dymku.
|
| Powrót do ramki |
Podczas krokowego wykonywania kodu może się czasem zdarzyć, że wykonanie posunie się za daleko lub że wiersz, który miał zostać wykonany krokowo z zagłębianiem, zostanie wykonany bez zagłębiania. Zamiast restartować sesję debugowania, można użyć działania Wróć do ramki, aby szybko wrócić do początku metody. Wybierz ramkę stosu odpowiadającą metodzie, którą chcesz zrestartować, a następnie wybierz opcję Wróć do ramki z paska narzędzi widoku Debugowanie lub z menu kontekstowego ramki stosu. Wskaźnik bieżącej instrukcji zostanie zresetowany do pierwszej instrukcji
wykonywalnej danej metody. Procedura ta działa także w odniesieniu do ramek
stosu innych niż najwyższa.
Należy zwrócić uwagę, że funkcja powrotu do ramki jest dostępna wyłącznie podczas debugowania za pomocą maszyny VM w wersji 1.4 lub wyższej, lub maszyny VM J9. W niektórych sytuacjach zdjęcie wymaganych ramek ze stosu przez maszynę JVM może okazać się niemożliwe. Przykładowo niemożliwy jest zwykle powrót do najniższej ramki stosu lub do ramki znajdującej się poniżej metody rodzimej. |
| Wymiana kodu podczas przetwarzania | Debuger obsługuje wymianę kodu podczas przetwarzania w przypadku debugowania z użyciem maszyny VM w wersji 1.4 lub wyższej albo maszyny VM J9. Pozwala to wprowadzać zmiany w kodzie, który jest aktualnie debugowany. Należy zwrócić uwagę, że niektóre zmiany - takie jak dodawanie lub usuwanie metod, zmiennych klas lub klas wewnętrznych - nie mogą być wykonywane podczas przetwarzania. Zależy to od funkcji udostępnianych przez określoną maszynę VM. |
| Wchodzenie do zaznaczeń i debugowanie z wykorzystaniem odsyłaczy |
Debuger Java pozwala wchodzić do pojedynczej metody w obrębie serii powiązanych lub zagnieżdżonych wywołań metod. W tym celu wystarczy wybrać metodę i wybrać opcję Wejdź do wyboru z menu kontekstowego edytora Java.
Funkcja ta działa w miejscach innych niż wykonywany aktualnie wiersz. Spróbuj debugować do punktu zatrzymania i wejść do metody znajdującej się kilka wierszy poniżej wskaźnika bieżącej instrukcji.
Gdy kursor nie znajduje się w nazwie metody, ta opcja powoduje wejście do następnej metody w wybranym
wierszu.
Jeśli na przykład kursor znajduje się na początku wiersza Można też wejść do metody, korzystając z nawigacji opartej na odsyłaczach. W tym celu po prostu umieść kursor nad metodą, do której chcesz wejść, a następnie użyj kombinacji Ctrl+Alt+kliknięcie, aby wejść do metody (w odróżnieniu od kombinacji Ctrl+kliknięcie, która spowoduje przejście do kodu źródłowego).
|
| Blokada i unieruchomienie konsoli | Dane wyświetlane w konsoli można zablokować na poziomie określonego procesu za pomocą akcji Unieruchom konsolę dostępnej na pasku narzędzi widoku Konsola. Dostępna jest również akcja Blokada przewijania, która blokuje funkcję przewijania konsoli w miarę dodawania nowych danych wyjściowych. |
| Tworzenie elementów obserwowanych | Element obserwowany to wyrażenie w widoku Wyrażenia, którego wartość jest aktualizowana w miarę debugowania. Elementy obserwowane można tworzyć z poziomu edytora Java, zaznaczając wyrażenie lub zmienną, a następnie wybierając opcję Obserwuj z menu kontekstowego lub z menu najwyższego poziomu Wykonaj. |
| Punkty kontrolne |
Punkt kontrolny to punkt zatrzymania, który powoduje zawieszenie
wykonywania przy każdym dostępie do określonego pola lub w razie jej
modyfikacji. Aby ustawić punkt kontrolny, zaznacz pole w widoku
Schemat, a następnie wybierz opcję Przełącz punkt kontrolny z jej menu
kontekstowego. Aby skonfigurować punkt kontrolny, wybierz go w widoku Punkty
kontrolne, a następnie wybierz opcję Właściwości z menu
kontekstowego. Najważniejsze właściwości w przypadku tego typu punktu
zatrzymania to pola wyboru Dostęp i Modyfikacja, które
umożliwiają określenie, kiedy dany punkt zatrzymania ma zawieszać wykonywanie.
|
| Punkty zatrzymania ładowania klas |
Punkt zatrzymania ładowania klasy zawiesza wykonywanie, gdy określona klasa jest ładowana do maszyny wirtualnej. Aby
ustawić punkt zatrzymania ładowania klasy, należy wybrać klasę w widoku Schemat i wybrać opcję Przełącz punkt
zatrzymania ładowania klasy z jej menu kontekstowego. Punkt zatrzymania ładowania klasy można także utworzyć
przy użyciu działania menu Wykonaj > Dodaj punkt zatrzymania ładowania klasy....
|
| Punkty zatrzymania w metodzie |
Punkt zatrzymania w metodzie zawiesza wykonywanie podczas wchodzenia do określonej metody lub wychodzenia z tej metody.
Aby ustawić punkt zatrzymania w metodzie, należy wybrać metodę w widoku Schemat i wybrać opcję Przełącz punkt
zatrzymania w metodzie z jej menu kontekstowego. Można także kliknąć dwukrotnie wiersz deklaracji
metody w linijce edytora lub użyć działania menu Wykonaj > Przełącz punkt zatrzymania w metodzie, aby utworzyć
punkt zatrzymania w wybranej aktualnie metodzie.
Domyślnie punkt zatrzymania w metodzie zawiesza wykonywanie tylko podczas wchodzenia do metody. Aby skonfigurować zawieszanie wykonywania podczas wychodzenia z metody, można użyć panelu szczegółów punktu zatrzymania lub okna dialogowego właściwości punktu zatrzymania. Punkty zatrzymania w metodzie obsługują także warunki.
|
| Wątki i monitory |
Debuger Java może opcjonalnie wyświetlać informacje o monitorach w widoku Debugowanie. Aby zobaczyć, które wątki mają blokady, a które oczekują na nie, użyj działania Pokaż monitory w menu rozwijanym
widoku Debugowanie. Wątki znajdujące się w zakleszczeniu są oznaczane na czerwono.
|
| Filtry kroków | Filtry kroków zapobiegają zawieszeniu debugera w określonych klasach
i pakietach podczas krokowego wykonania kodu z zagłębianiem. Filtry kroków są ustanawiane na stronie preferencji Java > Debugowanie > Filtrowanie kroków.
Jeśli przełącznik Użyj filtrów kroków jest włączony (na pasku narzędzi i w menu debugera), filtry
kroków będą stosowane do wszystkich akcji krokowych. W widoku Debugowanie można szybko dodać do listy filtrów
pakiet lub typ deklarujący wybranej ramki stosu - w tym celu wybierz opcję
Filtruj typ lub Filtruj pakiet z menu kontekstowego ramki. |
| Korzystanie z zeszytu testowego |
Jeśli chcesz poeksperymentować z interfejsem API lub wypróbować nowy
algorytm, rozwiązaniem łatwiejszym od utworzenia nowej klasy jest często użycie
strony zeszytu testowego Java.
Strona zeszytu testowego to kontener dla luźnych
fragmentów kodu, które można wykonywać w dowolnym momencie bez kontekstu. Aby
utworzyć stronę zeszytu testowego, utwórz nowy plik z rozszerzeniem
.jpage (albo użyj kreatora Nowa strona zeszytu testowego).
Wprowadź dowolny kod, który chcesz wykonać, a następnie go zaznacz. Dostępne są trzy sposoby wykonania kodu:
Akcje te są dostępne na pasku narzędzi środowiska roboczego, a także w menu kontekstowym strony zeszytu testowego. |
| Edytowanie konfiguracji startowych |
Przytrzymanie klawisza Ctrl i wybranie opcji z menu Wykonaj lub Debuguj powoduje otwarcie powiązanej konfiguracji startowej do edycji. Można ją również otworzyć z menu kontekstowego powiązanego z dowolnym elementem w widoku Debugowanie. |
| Ulubione konfiguracje startowe | Konfiguracje startowe są wyświetlane w menu rozwijanym Wykonaj/debuguj w kolejności od najnowszych do najstarszych uruchomień. Istnieje jednak możliwość wymuszenia wyświetlania konfiguracji startowej na samej górze menu rozwijanego, poprzez nadanie jej charakteru konfiguracji "ulubionej". Aby określić ulubione konfiguracje startowe, użyj opcji Organizuj ulubione dostępnej w odpowiednim menu rozwijanym. |
| Formatery szczegółów |
W widokach Zmienne i Wyrażenia w panelu szczegółów
wyświetlana jest rozwinięta reprezentacja aktualnie wybranej zmiennej. Domyślnie reprezentacja ta stanowi wynik wywołania metody toString() dla wybranego obiektu, ale można utworzyć niestandardowy formater szczegółów, który będzie używany zamiast niej. W tym celu wybierz opcję Nowy formater szczegółów z menu kontekstowego zmiennej. Formater będzie stosowany do wszystkich obiektów tego samego typu. Wszystkie formatery szczegółów można wyświetlać i edytować na stronie preferencji
Java > Debugowanie > Formatery szczegółów.
|
| Uruchamianie kodu z błędami kompilacji |
Istnieje możliwość wykonywania i debugowania kodu, który nie został
skompilowany bezbłędnie. Jedyna różnica w porównaniu z wykonywaniem kodu bez błędów kompilacji polega na tym, że podczas wykonywania wiersza kodu z błędami zachodzi jedna z dwóch sytuacji:
Należy podkreślić, że dopóki ścieżka wykonywania pomija wiersze kodu zawierające błędy kompilacji, wykonywanie i debugowanie przebiega w sposób normalny. |
| Zawijanie tekstu w widoku Zmienne | Obszar szczegółów w widokach debugera Zmienne i
Wyrażenia obsługuje funkcję zawijania tekstu, dostępną z poziomu menu kontekstowego widoku.
|
| Aktywna obsługa kodu w debugerze |
Aktywna obsługa kodu jest dostępna w wielu sytuacjach, nie tylko podczas pisania kodu w edytorze Java:
|
| Szczegóły wiersza komend | Istnieje możliwość wyświetlenia pełnego wiersza komend użytego do
uruchomienia programu w trybie wykonywania lub debugowania - w tym celu wybierz opcję Właściwości z menu kontekstowego procesu lub celu debugowania, nawet jeśli wykonywanie zostało zakończone.
|
| Odsyłacze hipertekstowe stosu wywołań |
Dane śledzenia stosu Java są wyświetlane w konsoli przy użyciu odsyłaczy
hipertekstowych. Umieszczenie wskaźnika myszy na wierszu w oknie śledzenia stosu spowoduje, że wskaźnik przybierze
kształt dłoni.
Po naciśnięciu przycisku myszy zostanie otwarty powiązany plik
źródłowy Java, a kursor przejdzie do odpowiedniego wiersza. Naciśnięcie
przycisku myszy po wskazaniu nazwy wyjątku w górnej części okna śledzenia stosu spowoduje
utworzenie punktu zatrzymania wyjątku.
|
| Debugowanie w perspektywie Java |
Aby debugować w perspektywie Java, należy skonfigurować preferencje
Wykonaj/debuguj > Zarządzanie widokiem. Należy wybrać
perspektywę, z której ma być wykonane debugowanie.
Należy sprawdzić, czy włączono preferencję aktywującą widok debugowania po trafieniu punktu zatrzymania (na stronie preferencji najwyższego poziomu Wykonywanie/debugowanie).
Na stronie preferencji Wykonaj/debuguj > Perspektywy można wyłączyć pytanie o przełączenie perspektywy. Przy takich ustawieniach widok debugowania zostanie automatycznie otwarty w perspektywie Java po trafieniu punktu zatrzymania.
Po umieszczeniu widoku debugowania u góry perspektywy i dopasowaniu jego wysokości do wielkości jednego elementu widok zostanie przełączony na prezentację ścieżki nawigacyjnej. Pozwala to na zminimalizowanie przestrzeni zajmowanej na ekranie przez widok.
|