1 Instalacja IDE
     1.1 Poprzez Centrum oprogramowania Ubuntu
     1.2 Poprzez Menedżer pakietów Synaptic
     1.3 Poprzez magiczną komendę w konsoli
2 Konfiguracja JVM
3 Nawigacja po kodach źródłowych
     3.4 Przechodzenie do deklaracji zmiennych, klas i funkcji
     3.5 Szukanie użyć danej klasy, zmiennej lub metody
     3.6 Lokalna historia edycji kodu
4 Refaktoryzacja
     4.7 Zmiana nazwy
     4.8 Automatyczne formatowanie kodu
     4.9 Generowanie konstruktorów i akcesorów
     4.10 Menu Refactor
5 Inne porady
     5.11 Naprawianie importów
     5.12 Uzupełnianie i podpowiadanie na bieżąco
     5.13 Wstawki

Instalacja IDE

Jako, że moim ulubionym system jest Ubuntu, opiszę sposób instalacji w Ubuntu 10.10. Poradnik dotyczy wersji 6.9 środowiska NetBeans.

Poprzez Centrum oprogramowania Ubuntu

Wybieramy menu Programy, potem Centrum oprogramowania Ubuntu, w polu wyszukiwania wklepujemy "netbeans" i zaklikujemy znalezioną paczkę.

Poprzez Menedżer pakietów Synaptic

Wybieramy menu System, potem Administracja i na końcu Menedżer pakietów Synaptic. Wyszukujemy paczkę o nazwie "netbeans" zaklikujemy i dajemy Zastosuj.

Poprzez magiczną komendę w konsoli

Wybieramy menu Programy, potem Akcesoria i na końcu Terminal. Wpisujemy "sudo apt-get install netbeans", podajemy hasło jeśli sudo nas o to pyta i spokojnie obserwujemy proces instalacji.

Konfiguracja JVM

Opcje JVM, z którymi odpalane jest NetBeans IDE znajdują się w pliku /etc/netbeans.conf. Polecam pobawić się opcjami jeżeli ktoś uważa, że NetBeans ma zbyt duże przestoje. Znaczenie wielkości poszczególnych zmiennych jak i różnice w GC są opisane na: http://redstack.wordpress.com/2011/01/06/visualising-garbage-collection-in-the-jvm/

Nawigacja po kodach źródłowych

Przechodzenie do deklaracji zmiennych, klas i funkcji

Aby przejść do deklaracji zmiennej, klasy czy funkcji wykorzystywanej w kawałku kodu, który właśnie oglądamy, musimy nacisnąć i przytrzymać klawisz Ctrl, a następnie kliknąć myszką nazwę obiektu naszego zainteresowania.

Dla przykładu mamy taki kod:

Chcieliśmy się dowiedzieć jak wyglądają źródła klasy, którą rozszerza widoczna klasa. Przytrzymaliśmy klawisz Ctrl, od teraz wszystkie nazwy podświetlają się na niebiesko po najechaniu i dostają podkreślenie (wyglądają dzięki temu jak hyperlinki). Po kliknięciu nazwy przenosi nas do szukanej klasy:

Uwaga: jeżeli nie podaliśmy NetBeansowi kodu źródłowego klasy, którą chcemy przejrzeć dostaniemy coś takiego:

Jedyne co widać to nazwy oraz stałe. Zamiast ciał funkcji NetBeans wypisuje tylko:

//compiled code
throw new RuntimeException("Compiled Code");

Jak widać na obrazkach powyżej, możemy wyświetlić listę klas które dziedziczą klasę którą dziedziczymy. Należy wtedy przytrzymać Ctrl+Alt i kliknąć na nazwie rozszerzanej klasy (tutaj Container).

Należy zwrócić uwagę na trzy małe przyciski w lewym górnym rogu na pokazanych obrazkach. Pierwszy służy do przechodzenia w miejsce ostatniej edycji (jego skrót klawiaturowy to Ctrl+Q). Kolejne naciśnięcia powinny przenosić w miejsca coraz dawniejszych edycji. Kolejne dwa przyciski to Go back i Go forward (skróty klawiaturowe Alt+Lewy i Alt+Prawy). Ich znaczenie jest podobne co w przeglądarkach internetowych - przenosimy się do ostatnio oglądanych dokumentów.

Możemy też posługiwać się okienkiem Navigator. Aby go pokazać należy wybrać menu Window, potem Navigating, a na końcu Navigator. Oto wygląd Navigatora:

Navigator pokazuje wszystkie pola i metody klasy, która jest zaznaczona w okienku Projects. Przyciski na dole służą do filtrowania pozycji oraz wyboru ich sortowania.

Szukanie użyć danej klasy, zmiennej lub metody

Do tego celu służy funkcjonalność o nazwie Find Usages. Dla przykładu kursor w przykładowym kodzie znajduje się na nazwie klasy Integer:

Klikamy prawym przyciskiem myszy i wybieramy Find Usages z rozwiniętego menu:

Wynik operacji jest wyświetlony w okienku Usages. Możemy kliknąć dowolną pozycję z wynikowej listy, aby przenieść się do interesującego nas miejsca w kodzie:

Lokalna historia edycji kodu

Do przeglądania lokalnej historii służy opcja Show Local History z pozycji menu Local History, dostępnego po kliknięciu prawym przyciskiem na nazwę pliku w okienku Projects. Możemy sobie opisać dowolną zachowaną kopię za pomocą etykiety (Label) oraz podejrzeć różnice wobec obecnej wersji. Aby zachować obecną wersję w historii, należy ją jakoś zmodyfikować - wtedy wyląduje w historii.

Przykładowy widok:

Refaktoryzacja

Zmiana nazwy

Jeżeli chcemy zmienić nazwę pola, klasy czy metody najpierw ustawmy kursor w miejscu gdzie znajduje się jej nazwa. Następnie należy nacisnąć Ctrl+R. Jeżeli zmiana dokonuje się tylko w obrębie klasy, np zmieniamy nazwę zmiennej lokalnej albo prywatnej to zobaczymy taki widok:

Teraz możemy wpisać nową nazwę i od razu widzimy jak zmienia się nasz kod. Jeżeli NetBeans uzna, że zmiana nazwy może przenieść się na inne klasy, wyświetli osobne okienko do zmiany nazwy wraz z podglądem refaktoryzacji, czyli listą zmian we wszystkich klasach dotkniętych zmianą, w okienku Refactoring na dole.

Automatyczne formatowanie kodu

Jeśli chcemy mieć ładnie sformatowany kod, zastosujmy funkcjonalność Format, dostępna z menu pod prawym przyciskiem myszy, albo (lepiej) skrótem klawiaturowym Alt+Shift+F. Polecam używać tego skrótu nałogowo, nawet kilka razy na minutę. Niestety funkcjonalność ta ma jedną wadę - gdy kod jest nieprawidłowy, tzn ma nieprawidłową ilość, kolejność lub rodzaj nawiasów, to Format może się pogubić i popsuć całkowicie widok kodu. Z drugiej strony jednak od razu widzimy, że coś zawaliliśmy, a zmiany można cofnąć za pomocą Undo (skrót klawiaturowy Ctrl+Z).

Generowanie konstruktorów i akcesorów

Służy do tego funkcjonalność Insert Code... dostępna jako pozycja w menu pod prawym przyciskiem myszy albo pod skrótem klawiaturowym Alt+Insert. Po ich naciśnięciu wyświetla się lista różnych opcji generowania kodu, zależna od tego, w którym miejscu tą funkcjonalność wywołamy.

Krótkie omówienie znaczenia pozycji w menu tej funkcjonalności:

• Constructor - służy do generowania konstruktora wraz z automatycznymi argumentami i przypisaniami,
• Getter i Setter - służą oczywiście do generowania akcesorów,
• equals() i hashCode() - służą do automatycznej generacji tych metod - nowe metody odwołują się tylko do wybranych przez nas składowych klasy,
• Delegate Method - bardzo fajna funkcjonalność do tworzenia delegatów, pomocne przy stosowaniu wzorca projektowego Dekorator,
• Override Method - tworzenie metody nadpisującej metodę z klas bazowych,

Menu Refactor

Najważniejsze menu w NetBeans :) Oto jego wygląd:

Opiszę w skrócie znaczenie wszystkich opcji w tym podmenu:

• Rename... - to już opisałem w rozdziale Zmiana nazwy,
• Move... - przeniesienie klasy do innej paczki,
• Copy... - skopiowanie klasy,
• Safely Delete... - bezpieczne usuwanie, tzn NetBeans sprawdza czy usuwane pole, metoda czy klasa jest gdzieś używana i jeśli wynik jest pozytywny to protestuje,
• Change Method Parameters... - dodawanie usuwanie albo zmiana kolejności parametrów w metodzie,
• Pull Up... i Push Down... służą do przenoszenia metod lub pól do podklas albo nadklas,
• Extract Interface... - tworzy interfejs złożony z deklaracji metod, które sobie wybierzemy; dodatkowo definicja obecnej klasy od razu zostanie uzupełniona o nazwę nowej klasy po słowie kluczowym implements; Uwaga: oczywiście aby metoda mogła się znaleźć w interfejsie, musi być publiczna,
• Extract Superclass... - podobnie jak wyżej, tylko tworzy nadklasę, czyli można przenosić od razu implementacje metod do nowej klasy,
• Use Supertype Where Possible... - bardzo przydatna opcja, zamienia deklaracje na nadklasy wszędzie tam, gdzie można zmienić typ zmiennej na nadklasę; aby użyć opcji należy umieścić kursor na nazwie klasy w deklaracji pola,
• Move Inner to Outer Level... - przenosi klasę wewnętrzną poza aktualną klasę, do nowego pliku,
• Convert Anonymous to Member... - zamienia anonimową klasę na nazwaną klasę, np zamienia kod:

        new Thread() {

            @Override
            public void run() {
            }
        }.run();

na:

        new ThreadImpl().run();
(...)
    private static class ThreadImpl extends Thread {

        public ThreadImpl() {
        }

        @Override
        public void run() {
        }
    }

• Introduce Variable... - próbuje stworzyć nową zmienną lokalną do której będzie można przypisać aktualne zaznaczenie, np po zaznaczeniu "5 + 6" można utworzyć nową zmienną inicjowaną tym wyrażeniem,
• Introduce Constant... - podobnie jak powyżej ale wprowadza stałą,
• Introduce Field... - podobnie jak Introduce Variable, ale zamiast zmiennej lokalnej próbuje utworzyć pole w klasie,
• Introduce Method... - podobnie jak powyżej, ale zamiast pola w klasie próbuje utworzyć metodę; jeżeli zaznaczenie zawiera kod zależny od zmiennych lokalnych to te zmienne wylądują jako parametry nowo stworzonej metody,
• Encapsulate Fields... - enkapsuluje pola w klasie, tzn. generalnie służy do ukrywania publicznych pól i generowania do nich publicznych akcesorów,

Inne porady

Naprawianie importów

Służy do tego funkcjonalność Fix Imports dostępna pod prawym przyciskiem myszy, albo skrótem klawiaturowym Ctrl+Shift+I (preferowane). Dla przykładu, jeżeli mamy kod:

Widzimy, że mamy tu kilka niepotrzebnych importów i kilka nieobecnych. Uruchamiamy Fix Imports i w naszym przypadku dostajemy okienko o takim wyglądzie:

Okienko to pokazuje się, jeżeli którakolwiek nazwa z niezaimportowanych klas występuje więcej niż raz w zbiorze dostępnych w projekcie klas. W innym wypadku naprawa nastąpi automatycznie. Widzimy, że niejednoznaczność u nas dotyczy klasy o nazwie List. NetBeans automatycznie odgadł klasę, która według niego najbardziej pasuje do naszego kodu. Zwykle NetBeans ma rację, ale zawsze trzeba rzucić okiem na dostępne klasy i zastanowić się, która jest odpowiednia.

Uzupełnianie i podpowiadanie na bieżąco

Aby włączyć tą funkcjonalność należy wejść do menu Tools, potem Options, potem zakładka Editor, następnie Code Completion, wybrać język Java i zaznaczyć opcję Auto Popup on Typing Any Java Identifier Part, tak jak na obrazku:

Wstawki

Wstawki to fragmenty kodu oznaczone jakimś krótkim skrótem. Po wpisaniu owego skrótu i wciśnięciu klawisza Tab wstawka jest rozwijana do pełnej postaci. Dla przykładu jeżeli napiszemy:

sout

i naciśniemy klawisz Tab, to NetBeans zamieni ten skrót na pełne ciało wstawki, czyli:

System.out.println("");

i umieści kursor pomiędzy cudzysłowami.

Listę wszystkich wstawek można znaleźć podążając za menu Tools, potem Options, potem zakładka Editor, a na końcu Code Templates. Wygląda to tak:

Możemy prześledzić działanie zaznaczonej wstawki pfc. Po wpisaniu jej nazwy i wciśnięciu klawisza Tab, ukaże się nam taki kod:

private final class Type {

    Type() {
        
    }
}

Najpierw podświetlony zostanie napis "Type" i będziemy mieć możliwość zmiany tej nazwy, a po zatwierdzeniu nazwy Enterem kursor przeniesie się w środek konstruktora. Zachowanie to zostało w pełni opisane w definicji wstawki lecz składnia wstawek wykracza poza zakres tego artykułu.