Java-wykład Grafika

Grafika Starsze wersje Javy posiadały bibliotekę AWT, służącą do tworzenia GUI – graficznego interfejsu użytkownika. AWT wykorzystywała narzędzia graficzne platformy, na której był uruchomiony program Elementy graficzne, jak menu, paski przewijania, pola tekstowe mogły się różnić na różnych platformach, stąd niejednolitość działania tego samego programu w zależności od środowiska.

Grafika W aktualnym pakiecie graficznym Javy – Swing – system rysuje tylko bazowe, puste okno, pozostałe elementy umieszczane są na tym oknie przez program. Aplikacja napisana z użyciem Swing wygląda tak samo na różnych platformach. Programista może jej jednak łatwo nadać cechy wyglądu charakterystyczne dla platformy.

Grafika Okno najwyższego poziomu (takie które nie zawiera się w innym oknie) – to ramka. Do tworzenia i obsługi ramek służy klasa JFrame pakietu Swing. Ramka nie jest rysowana w obszarze roboczym – jej narysowanie zlecane jest systemowi operacyjnemu.

Grafika Klasy Swing znajdują się pakiecie javax.swing. Nazwa javax oznacza że jest to pakiet rozszerzający a nie podstawowy (rozszerza AWT). Metoda setDefaultCloseOperation klasy JFrame określa, co ma się stać, kiedy użytkownik zamknie ramkę aplikacji. Istotne zwłaszcza przy aplikacjach z wieloma ramkami Domyślnie ramka zostaje ukryta, a program się nie kończy.

Grafika Ramki zwykle tworzymy, potem dodajemy do nich komponenty, a następnie dopiero wyświetlamy wywołując metodę setVisible Po zakończeniu main program się nie kończy; dopiero gdy zamkniemy ramkę lub wywołamy System.exit

Grafika Do zmiany wyglądu i położenia ramki służą metody klasy JFrame: setLocation, setBounds – ustawiają położenie ramki setIconImage – określa ikonę na pasku tytułu setTitle – ustawia tekst na pasku tytułu setResizable – dla argumentu false blokuje możliwość zmian wymiaru okna przez użytkownika; dla true – daje tę możliwość

Grafika Spośród czterech warstw, z których składa się ramka, potrzebna będzie nam jedna: warstwa treści (content pane), do której będziemy dodawać komponenty. Warstwę tę pobieramy metodą getContentPane, otrzymując obiekt klasy Container Container cp = frame.getContentPane();

Grafika Następnie tworzymy komponent(y): Component c = … i dodajemy je do kontenera: cp.add(c); W nowszych wersjach Javy możemy dodawać komponenty wywołując metodę add na obiekcie klasy JFrame, bez pośrednictwa pobieranego kontenera.

Grafika Chcemy umieścić na ramce jakiś komunikat (tekst). W tym celu utworzymy klasę dziedziczącą z JComponent i przesłonimy jej metodę paintComponent, po czym umieścimy obiekt tej klasy (komponent) na ramce. Metoda painComponent ma jeden argument: obiekt klasy Graphics (zawiera on ustawienia dotyczące rysowania obrazów i tekstu: czcionka, koloritp.)

Grafika A zatem utworzenie komponentu będzie wyglądało tak: class MojKomponent extends JComponent { public void paintComponent(Graphics g) { //rysowanie } Następnie tworzymy obiekt tej klasy: MojKomponent mk = new MojKomponent(); i dodajemy go do ramki: frame.add(mk);

Grafika Metoda paintComponent nie jest wywoływana przez programistę. Wywołuje ją automatycznie specjalny wątek (EDT) we wszystkich komponentach naszej aplikacji w sytuacji, gdy np. użytkownik zmieni rozmiar okna lub przesunie okno, lub jakieś inne okno przesłoni nasze, a potem odsłoni tę część, która była niewidoczna (trzeba ją dorysować, i tym zajmują się właśnie metody paintComponent wywoływane dla wszystkich komponentów przez wątek czuwający nad zdarzeniami)

Grafika Jeśli chcemy wymusić ponowne narysowanie, wywołujemy metodę repaint, która wywoła we wszystkich komponentach paintComponent W klasie Graphics jest metoda drawString, dzięki której możemy „narysować” napis g.drawString(”witaj świecie”, 30, 45); Co oznacza narysowane napisu poczynając od miejsca odległego od lewej krawędzi okna o 30 pikseli, a od górnej krawędzi okna o 45 pikseli.

Grafika Klasa Graphics umożliwia też rysowanie linii, prostokątów, elips itp., jednak jej możliwości w tym zakresie są skromne (nie można np. ustawiać grubości linii) Dlatego wprowadzono bibliotekę Java2D. Aby móc rysować jej obiekty, musimy w metodzie paintComponent zrzutować obiekt klasy Graphics na obiekt jej klasy pochodnej: Graphics2D, czyli

Grafika public void paintComponent(Graphics g) { Graphics2D g2 = (Graphics2D) g; … } W bibliotece Java2D istnieją obiekty reprezentujące linie,prostokąty, elipsy itd.: Line2D, Rectangle2D, Ellipse2D,… Wszystkie te klasy implementują wspólny interfejs Shape

Grafika Aby narysować którąś z figur biblioteki Java2D, w metodzie paintComponent tworzonego komponentu piszemy np: Rectangle2D rect = … g2.draw(rect); Obiekty typu Shape używają, do określania parametrów, liczb typu float z jednym miejscem po przecinku.

Grafika Trzeba przy tym uważać, bo np. zapis Podobnie wywołanie float f = 1.2; spowoduje błąd. Stała 1.2 jest bowiem typu double i kompilator obawia się utraty precyzji. Dlatego piszemy: float f = 1.2F; Podobnie wywołanie Rectangle2D r = … float f = r.getWidth();

Grafika jest błędne i trzeba w tej sytuacji rzutować: Rectangle2D r = … float f = (float) r.getWidth(); Dla wygody utworzono w Java2D dla każdej klasy reprezentującej figurę klasę alternatywną, posługującą się wyłącznie liczbami typu double (które jednak zajmują sporo pamięci, a obliczenia na nich są czasem wolniejsze)

Grafika Tak więc (abstrakcyjna!) klasa Rectangle2D posiada dwie konkretne podklasy: Rectangle2D.Float Rectangle2D.Double (są to wewnętrzne klasy statyczne) Rectangle2D.Float floatRect=new Rectangle2D.Float(10.0F, 25.0 f, 22.5F, 20.0F);

Grafika Rectangle2D.Double doubleRect = new Rectangle2D.Double(10.0, 25.0, 22.5, 20.0); Referencje do obu typów prostokątów (czy innych figur) należy przechowywać w zmiennych typu Rectangle2D (lub innych)

Grafika Parametry konstruktora prostokąta określają górny lewy róg, szerokość i wysokość. Metody klasy Rectangle2D zawsze zwracają liczby typu double (nawet jeśli mamy do czynienia z obiektami klasy Rectangle2D.Float) W Java2D istnieje klasa Point2D, która jest bardzo przydatna (wiele konstruktorów innych figur pobiera obiekty tej klasy jako argumenty)

Grafika Utworzenie punktu np: Point2D p = new Point2D.Double(10, 20); Klasy Rectangle2D i Ellipse2D dziedziczą po wspólnej nadklasie RectangularShape. Wprawdzie elipsa nie przypomina prostokąta, ale można na niej opisać prostokąt.

Grafika Tworząc elipsę, podajemy jako argumenty do konstruktora parametry opisanego na niej prostokąta, np. Ellipse2D e = new Ellipse2D.Double(150,200,100,50); utworzy elipsę wpisaną w prostokąt, którego górny lewy róg znajduje się w punkcie o współrzędnych (150, 200) o szerokości 100 i wysokości 50.

Grafika Możemy utworzyć pusty prostokąt: Rectangle2D r = new Rectangle2D.Double(); a potem określić jego wymiary: r.setFrameFromDiagonal(px, py, qx, qy); gdzie px,py oznaczają współrzędne lewego górnego rogu, a qx, qy – współrzędne prawego dolnego rogu.

Grafika Albo bardziej elegancko: r.setFrameFromDiagonal(p, q); gdzie p i q są obiektami klasy Point2D. Tworząc elipsę podajemy środek, szerokość i wysokość opisanego na niej prostokąta: Ellipse2D e = new Ellipse2D.Double(centerX – width/2, centerY – height/2, width, height);

Grafika Aby utworzyć linię, podajemy punkt początkowy i punkt końcowy w postaci obiektów klasy Point2D Line2D linia = new Line2D.Double(start,end);

Grafika Metoda setPaint z klasy Graphics2D ustawia kolor; wszystkie kolejne rysunki będą tego koloru. Np. g2.setPaint(Color.RED); g2.drawString(”Witamy”, 100, 100); Mając ustawiony kolor, figury zamknięte (prostokąt, elipsa) możemy wypełniać, używając metody fill (zamiast rysować metodą draw)

Grafika Rectangle2D rect = … g2.setPaint(Color.RED); g2.fill(rect); Kolory pobieramy z klasy Color (z pakietu java.awt); jest w niej 13 stałych (pól statycznych) reprezentujących kolory (Color. BLACK, Color.GREEN, itp.)

Grafika Niestandardowy kolor definiujemy tworząc nowy obiekt klasy Color i podając w konstruktorze trzy liczby z przedziału 0-255 (model rgb, czyli pierwszy argument określa ilość czerwonego, drugi ilość zielonego, a trzeci niebieskiego – „mieszanka” tych trzech barw w takich proporcjach to wynikowy kolor) Np. g2.setPaint(new Color(0, 128, 128)); g2.drawString(”Witaj”, 75, 125);

Grafika Kolor tła ustawiamy metodą setBackground, którą dziedziczymy z klasy Component (będącą nadklasą klasy JComponent.) MojKomponent mk = new MojKomponent(); mk.setBackground(Color.PINK);

Grafika Obrazy zapisane w plikach graficznych można wyświetlać w Javie. Jeśli obraz znajduje się na dysku lokalnym, piszemy: String plik = ” ...”; Image im = ImageIO.read(new File(plik)); a jeśli plik pochodzi z internetu: String url = ”…”; Image im = ImageIO.read(new URL(url));

Grafika Metoda read powyżej powoduje wyjątek IOException jeśli obraz jest niedostępny. W ten sposób pobrany obrazek wyświetlamy public void paintComponent(Graphic d) { g.drawImage(im, x, y, null); }

Grafika W Javie model obsługi zdarzeń wygląda następująco: Obiekt nasłuchujący jest egzemplarzem klasy implementującej specjalny interfejs nasłuchu. Źródło zdarzeń to obiekt , który może rejestrować obiekty nasłuchujące i wysyłać do nich obiekty zdarzeń Źródło zdarzeń wysyła obiekty zdarzeń do wszystkich zarejestrowanych słuchaczy w chwili wystąpienia zdarzenia. Informacje zawarte w obiekcie zdarzeń są wykorzystywane przez obiekty nasłuchujące przy podejmowaniu decyzji dotyczącej reakcji na zdarzenie

Grafika ActionListener s = new Sluchacz(…) JButton p = new JButton(”OK”); p.addActionListener(s); Obiekt s jest słuchaczem=obiektem nasłuchującym. Źródłem zdarzenia jest przycisk. Zdarzenia przycisku, czyli kliknięcia na przycisk, będą przekazywane słuchaczowi. Przycisk, jak i każde inne źródło, może mieć wielu słuchaczy nasłuchujących na jego zdarzenia (niekoniecznie kliknięcia myszką w przypadku innych źródeł)

Grafika ActionListener w powyższym schemacie to interfejs, typ zmiennej. Chcąc utworzyć obiekt słuchacza, musimy stworzyć klasę: class Sluchacz implements ActionListener { … public void actionPerformed(ActionEvent event) { }

Grafika Kiedy użytkownik kliknie przycisk, obiekt JButton tworzy obiekt typu ActionEvent - zdarzenie – i przekazuje ten obiekt słuchaczowi wywołując s.actionPerformed(event); Jeśli źródło zdarzeń (np. przycisk) ma wielu słuchaczy, utworzony na skutek zdarzenia obiekt typu ActionEvent jest przekazywany wszystkim słuchaczom

Grafika Jako przykład przeanalizujmy panel z trzema przyciskami; każdy przycisk ma jednego słuchacza. Słuchacz, po odebraniu zdarzenia, zmienia kolor tła panelu, który jest z nim stowarzyszony. Przycisk jest obiektem klasy JButton. Klasa ta dziedziczy z klasy JComponent, a więc przyciski są komponentami, które możemy umieszczać w ramce tak samo, jak wcześniej umieszczaliśmy nasze własne komponenty.

Grafika Konstruktor przycisku pobiera napis jaki będzie na nim wyświetlony, bądź obrazek. Tworzymy więc nasze trzy przyciski: JButton a = new JButton(”Żółty”); JButton b = new JButton(”Niebieski”); JButton c = new JButton(”Czerwony”); Przycisków tych nie wstawimy bezpośrednio do ramki, lecz utworzymy panel (obiekt klasy JPanel), dodamy je do panelu, a na koniec panel umieścimy w ramce.

Grafika JPanel p = new JPanel(); p.add(a); p.add(b); p.add(c); add(p); Potrzebujemy trzech obiektów klasy implementującej interfejs ActionListener (który zawiera tylko jedną metodę o sygnaturze public void actionPerformed(ActionEvent event);

Grafika Schemat tej klasy: class ColorAction implements ActionListener { private Color backgroundColor; ColorAction(Color c) { backgroundColor = c; } public void actionPerformed(ActionEvent event) { //ustawienie koloru tła panelu

Grafika Teraz tworzymy trzech słuchaczy – trzy obiekty klasy ColorAction: ColorAction zolty = new ColorAction(Color.YELLOW); ColorAction niebieski = new ColorAction(Color.BLUE); ColorAction czerwony = new ColorAction(Color.RED);

Grafika I rejestrujemy ich jako słuchaczy – każdy do innego źródła zdarzeń (przycisku): a.addActionListener(zolty); b.addActionListener(niebieski); c.addActionListener(czerwony); Jeśli teraz użytkownik kliknie przycisk z napisem „Żółty”, wykonana zostanie metoda actionPerformed obiektu zolty; ustawi ona kolor tła panelu na żółty.

Grafika Aby metoda actionPerformed miała dostęp do panelu (którego kolor ma zmienić) klasa ColorAction musi być klasą wewnętrzną klasy tworzącej ramkę.

Grafika II Omówimy różne rodzaje rozmieszczania komponentów na kontenerze. Zarządca brzegowy (border layout) pozwala, w przeciwieństwie do ciągłego (flow), wybrać położenie dla każdego komponentu. Do określania położenia używamy kierunków: północ, wschód itd. oraz centrum.

Grafika II North Center West East South

Grafika II frame.add(component.BorderLayout.SOUTH); Zamiast stałych możemy używać napisów, np. "South" (jednak w przypadku błędu, kompilator go nie rozpozna.) Jeśli np chcemy umieścić trzy przyciski na dolnej części ramki: JPanel p = new JPanel(); panel.add(x); panel.add(y); panel.add(z); frame.add(p, "South");

Grafika II Rozkład siatkowy (grid layout) rozmieszcza komponenty w wierszach i kolumnach tworzących siatkę. Wszystkie komponenty mają ten sam rozmiar. panel.setLayout(new GridLayout(4, 4)); W konstruktorze podajemy ilość wierszy i kolumn.

Grafika II Do odbioru danych tekstowych służą komponenty JTextField (pole tekstowe, przyjmuje tylko jeden wiersz tekstu) i JTextArea (obszar tekstowy, wiele wierszy)

Grafika II JPasswordField przyjmuje jeden wiersz, nie pokazuje wpisywanego tekstu. Te trzy klasy dziedziczą po klasie abstrakcyjnej JTextComponent Konstruktor pola tekstowego może zainicjować jakiś tekst oraz ustawić szerokość (w spodziewanej liczbie znaków) pola: JTextField tf = new JTextField("tutaj wpisuj tekst", 20);

Grafika II Gdy użytkownik wpisze tekst nie mieszczący się w polu, nie będzie on widoczny (choć będzie się na nim znajdował). Pole ma metodę setText tf.setText("Dzień dobry"); Metodą getText odczytujemy zawartość pola, metoda setFont ustawia krój czcionki.

Grafika II Etykiety zawierają tekst, ale nie pozwalają na wprowadzanie tekstu przez użytkownika. Mogą służyć jako identyfikatory komponentów. JLabel lab = new JLabel("Nazwa użytkownika:", SwingConstant.RIGHT); -tworzymy etykietę i wyrównujemy jej tekst do prawej strony. Metody setText i setIcon pozwalają ustawić tekst i ikonę etykiety w czasie działania programu.

Grafika II Obszar tekstowy nie posiada pasków przewijania. Aby się pojawiły, należy obszar tekstowy umieścić wewnątrz panelu przewijanego (scroll pane) JTextArea ta = new JTextArea(8, 40); JScrollPane sp = new JScrollPane(ta); Paski pojawiają się automatycznie, jeśli tekst nie mieści się w obszarze tekstowym, i automatycznie znikają, gdy tekstu zrobi się mniej. Ten sam mechanizm dodawania pasków przewijania działa też dla innych komponentów.

Grafika II Do odbierania danych typu "tak" lub "nie" służy pole wyboru (radiobutton) Jeśli chcemy wymusić, aby użytkownik mógł wybrać tylko jedną możliwość, używamy przełączników. Zaznaczenie jednego pola powoduje automatyczne usunięcie zaznaczenia innego. Tworzymy grupę przycisków radiowych ButtonGroup bg = new ButtonGroup();

Grafika II A następnie tworzymy przyciski JRadioButton a = new JRadioButton("Mała",false); JRadioButton b = new JRadioButton("Średnia",true); Po czym łączymy je, dodając do wspólnej grupy group.add(a); group.add(b);

Grafika II Drugi argument konstruktora przycisku ma wartość true, jeśli przycisk ten ma być włączony na początku, a false - jeśli nie. Umieszczenie przycisków we wspólnej grupie sprawia, że tylko jeden z nich może być włączony. Natomiast grupa nie ma wpływu na rozmieszczenie przycisków, trzeba użyć panelu i odpowiedniego zarządcy rozmieszczenia.

Grafika II Jeśli w panelu jest kilka grup radio-boxów, należy je wyróżnić na przykład obramowując je. Do wyboru jest kilka rodzajów obramowania. Obramowanie możemy zastosować do dowolnego komponentu. Schemat postępowania: Tworzymy obramowanie statyczną metodą klasy BorderFactory, np. Border b = BorderFactory.createEtchedBorder(); Inne metody: createLineBorder, createLoweredBevelBorder itd

Grafika II Aby dodać tytuł do obramowania wywołujemy Border c = BorderFactory.createTitledBorder(b, "Tytuł"); Gdybyśmy chcieli połączyć kilka obramowań w jedno: metoda BorderFactory.createCompoundBorder Dodajemy utworzone obramowanie do komponentu za pomocą metody setBorder, np. panel.setBorder(c);

Grafika II Klasa SoftBevelBorder służy do tworzenia obramowań z zaokrąglonymi rogami… Klasa JComboBox służy do tworzenia listy rozwijalnej. Aby uczynić listę edytowalną, należy wywołać metodę setEditable z parametrem true. Do sprawdzenia aktualnie wybranego elementu listy służy metoda getSelectedItem. Metodą addItem dodajemy elementy na koniec listy. Metoda insertItemAt wstawia element w wybrane miejsce:

Grafika II JComboBox cb = new JComboBox(); cb.setEditable(true); cb.addItem("Serif"); cb.addItem("SansSerif"); … cb.insertItemAt("Monospaced",0); //dodaje na początek

Grafika II Do usuwania elementów z listy służą metody removeItem i removeItemAt. Pierwsza bierze jako argument napis umieszczony na elemencie do usunięcia, druga – pozycję elementu do usunięcia na liście Zwróconą przez getSelectedItem wartość trzeba rzutować na String.

Grafika II Menu użytkownika składa się z paska menu, na którym umieszczone są poszczególne menu: kliknięcie któregoś z nich powoduje rozwinięcie listy z elementami menu oraz podmenu. Utworzenie paska menu: JMenuBar mb = new JMenuBar(); Jest to zwykły komponent, który możemy umieścić na ramce lub w panelu metodą add

Grafika II Użycie metody setJMenuBar spowoduje umieszczenie paska menu z całą jego zawartością w górnej części okna: frame.setMenuBar(mb); Dla każdego menu tworzymy osobny obiekt: JMenu jm = new JMenu("Edycja"); … Po czym tak utworzone obiekty menu wstawiamy do paska menu: mb.add(jm);

Grafika II Elementy menu (obiekty JMenuItem) możemy rozdzielać separatorami: JMenuItem mi = new JMenuItem("wklej"); jm.add(mi); jm.addSeparator(); JMenu jm1 = new JMenu("opcje"); //podmenu jm.add(jm1);

Grafika II Do nasłuchiwania zdarzeń – kliknięć w menu – korzystamy z interfejsu ActionListener ActionListener ai = new… mi.addActionListener(ai); Elementy do menu można także dodawać metodą add(String) jm.add("wklej"); Dodany zostanie na końcu menu "wklej"

Grafika II Ta wersja metody add zwraca utworzony przez siebie obiekt JMenuItem: JMenuItem mi = jm.add("wklej"); mi.addActionListener(listener);

Grafika II Klasa JList definiuje listę. Można na niej przechowywać dowolne obiekty, nie tylko tekst. Jeden ze sposobów utworzenia listy: String[] words = { "quick", "brown", "hungry", "wild", … }; JList wordList = new JList(words); Aby lista mogła przewijać swoją zawartość, należy ją umieścić w komponencie JScrollPane: JScrollPane scrollPane = new JScrollPane(wordList);

Grafika II Następnie obiekt scrollPane (a nie wordList) umieszczamy na panelu bądź w ramce Domyślnie widocznych na liście jest 8 elementów. Można to zmienić, np. wordList.setVisibleRowCount(4); Zdarzenia listy obsługuje interfejs ListSelectionListener, z którego musimy zaimplementować metodę public void valueChanged(ListSelectionEvent event);

Grafika II Metoda ta obsługuje zdarzenia wyboru na liście. Metoda getSelectedValues zwraca tablicę obiektów – wybranych (zaznaczonych) elementów listy. Lista utworzona za pomocą jednego z konstruktorów JList(String) lub JList(Vector) nie pozwala dodać ani usunąć żadnego elementu – jest obiektem statycznym

Grafika II Jeśli chcemy w sposób niestandardowy (nie sprowadzający się do użycia tablic lub wektorów) określić zawartość listy - musimy stworzyć własny model danych Jeśli chcemy mieć listę dynamiczną tzn. zmieniającą swoją zawartość - możemy stworzyć własny model lub posłużyć się modelem standardowym, implementowanym w klasie DefaultListModel

Grafika II Model danych dla listy jest określany przez interfejs ListModel, abstrakcyjna klasa AbstractListModel implementuje ten interfejs, pozostawiając do zdefiniowania w klasach pochodnych dwie metody: Object getElementAt(int i), zwraca i-ty element listy int getSize(), zwraca rozmiar listy

Grafika II Utwórzmy własny model, np. class NewListModel extends AbstractListModel{ Object getElementAt(int i){ return (i+1)+ " stycznia"; } int getSize(){ return 31;

Grafika II Tworzymy teraz model listy: ListModel m = new NewListModel(); Ustalenie modelu dla listy może odbyć się na dwa sposoby: JList lista = new JList(); lista.setModel(m); JList lista = new JList(m);

Grafika II Zauważmy że w modelu NewListModel dane nie są przechowywane, lecz wyznaczane dynamicznie, w momencie gdy są potrzebne. Klasa JList wykorzystuje model danych (obiekt implementujący interfejs ListModel), pobierając z niego dane do wyświetlenia.

Grafika II Jeśli chcemy dodawać elementy do listy i usuwać z listy, musimy utworzyć nowy model -obiekt klasy DefaultListModel, która zawiera implementacje metod dodających i usuwających. DefaultListModel model = new DefaultListModel(); model.addElement("jeden"); model.addElement("dwa"); … JList lista = new JList(model);

Grafika II Możemy teraz dodawać i usuwać elementy modelu, który będzie powiadamiać listę o tych zmianach. model.removeElement("dwa"); model.addElement("trzy"); Klasa DefaultListModel używa do przechowywania danych Vector.

Grafika II Jeśli do konstruktora listy przekażemy tablicę lub wektor napisów bądź ikon, lista sama potrafi narysować te elementy; w pozostałych przypadkach trzeba dostarczyć jej obiekt odrysowujący zawartość komórek listy: obiekt klasy implementującej poniższy interfejs z jedną metodą: interface ListCellRenderer { Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus); }

Grafika II Najczęściej obiekt odrysowujący komórki jest obiektem klasy pochodnej komponentu JComponent.Schemat takiej klasy: class Rysownik extends JComponent implements ListCellRenderer { public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus){ //przechowuje dane do rysowania i wyznaczania rozmiaru return this; } public void paintComponent(Graphics g){ //kod rysujący public Dimension getPreferredSize(){ //kod wyznaczający rozmiary }}

Grafika II Ponieważ klasa Rysownik implementuje interfejs ListCellRendered, musi ona mieć napisaną metodę getListCellRendererComponent. Ponadto przesłania ona dwie metody z klasy JComponent. Mając napisaną tego typu klasę, tworzymy jej obiekt i dołączamy go do listy w sposób nast.: JList lista = new JList(); lista.setCellRenderer(new Rysownik());