Bölüm 9: Grafikler

9.1Grafik programlama

9.1.1Bileşen, olay ve görsel oluşturma

Bir kullanıcı bilgisayarı çoğunlukla pencereler üzerinden kullanır. Pencerenin başlığı, düğmeleri, menüleri ve metin alanları vardır. Kullanıcı fareyle tıklar, klavyeyle yazar, pencereyi büyütür. Program da bu eylemlere yanıt verir. Bu türden bir arayüze grafik kullanıcı arayüzü denir.

Java, GUI geliştirmek için kapsamlı bir sınıf kütüphanesi sunar. Bu kütüphaneyle bir GUI programı yazmak için üç kavramı anlamak gerekir.

• Bileşen (component): Pencere, düğme, etiket ve metin alanı gibi arayüzün yapı taşlarıdır. Her bileşen bir sınıfın nesnesidir. Bir düğme, JButton sınıfından oluşturulmuş bir nesnedir; metni, rengi ve boyutu bu nesnenin alanlarında saklanır.
• Olay işleme (event handling): Fare tıklaması, tuşa basma gibi kullanıcı eylemleri yakalanır ve bunlara yanıt veren metotlar çağrılır.
• Görsel oluşturma (painting): Şekiller çizilir, ekran güncellenir ve bileşenler görüntülenir.

Bir GUI programı, müşteriyi bekleyen bir dükkâna benzer. Önce vitrin hazırlanır: bileşenler oluşturulur ve pencereye yerleştirilir. Sonra program bekler. Müşteri ne zaman neye dokunursa o işle görevli kişi çalışır. Programda vitrinin karşılığı bileşenler, dokunuşun karşılığı olay, görevlinin karşılığı da dinleyici metottur (Şekil 9.1).

9.1.2Konsol programı ve GUI programı

Konsol programında akış sıralıdır. main metodu baştan sona çalışır. Programın bir girdiye ihtiyacı olduğunda soruyu program sorar ve Scanner ile klavyeden bir satır okur. Sonuç System.out.println ile yazılır. main bitince program da biter.

GUI programının akışı başkadır. main yalnız arayüzü kurar ve biter. Program bundan sonra kullanıcının hamlesini bekler. Kullanıcı bir düğmeye bastığında ya da panele tıkladığında ilgili metot çalışır. Bu çalışma biçimine olay güdümlü programlama denir.

Tablodaki son satırların ikisi önemlidir. GUI programında main bittiği hâlde program sürer. Bunun nedeni, Java'nın pencere açılınca ayrı bir iş parçacığı başlatmasıdır. Bu iş parçacığı olay kuyruğunu bekler ve gelen her olayı ilgili dinleyiciye iletir. JVM, bu iş parçacığı çalıştıkça kapanmaz.

GUI programında “sonra ne olacak?” sorusunun cevabı koddaki sıra değildir; kullanıcının sıradaki eylemidir. Bu yüzden kodun büyük kısmı “şu olursa şunu yap” biçimindeki dinleyicilerden oluşur. Programcı her eylem için bir yanıt yazar, ama eylemlerin hangi sırayla geleceğini bilmez.

9.1.3AWT ve Swing

Java'nın grafik sınıfları iki kütüphaneye dağılmıştır. İkisi de JDK ile gelir; ayrıca bir şey kurmak gerekmez.

• AWT (Abstract Window Toolkit), java.awt paketi: Java'nın ilk grafik kütüphanesidir. Bugün daha çok ortak sınıfları için kullanılır: Graphics, Color, Font, Point, yerleşim yöneticileri ve olay sınıfları (java.awt.event).
• Swing, javax.swing paketi: AWT'nin üzerine kurulmuş, bileşenleri Java'nın kendisinin çizdiği kütüphanedir. Sınıf adları J ile başlar: JFrame, JPanel, JButton, JLabel.

İki kütüphane arasındaki fark bileşenlerin nasıl çizildiğindedir. AWT bir düğme istediğinde işletim sisteminin kendi düğmesini kullanır. Bu yüzden aynı program Windows'ta ve Linux'ta farklı görünür. Swing ise düğmeyi kendisi boyar. Görünüm her sistemde aynıdır ve Java'nın denetimindedir. Bu notta bileşenler Swing'den, çizim ve yardımcı sınıflar AWT'den gelir. Tipik bir GUI programı bu yüzden iki paketi birlikte içe aktarır: import java.awt.*; ve import javax.swing.*;.

Şekil 9.2, kalıtımın GUI kütüphanesinde nasıl kullanıldığını gösterir. Ağacın kökünde Component vardır: ekranda yeri ve boyutu olan her şey bir bileşendir. Container, başka bileşenleri içinde tutabilen bileşendir. Container'dan iki dal ayrılır. Birinci dalda Window, Frame ve en sonda JFrame bulunur. İkinci dalda Swing bileşenlerinin ortak üst sınıfı JComponent vardır. JPanel, JLabel ve metin bileşenleri doğrudan ya da kısa bir yoldan JComponent'ten türer. JButton ise araya AbstractButton sınıfını alır.

Bu ağacın pratik bir sonucu vardır. Bir metot parametre olarak Component bekliyorsa ona düğme de, etiket de, panel de verilebilir. Çok biçimlilik burada gündelik bir araçtır. Örneğin panel.add(...) metodu herhangi bir bileşeni kabul eder.

9.1.4Ekran koordinatları

Grafik bir uygulama üç adımda kurulur. Önce Java'nın grafik sınıflarıyla arayüze bileşenler eklenir. Sonra kullanıcının eylemlerine yanıt veren olay işleme metotları tanımlanır. Son olarak paint() ya da paintComponent() gibi metotlarla görsel oluşturulur. Çizime geçmeden önce ekranın nasıl adreslendiğini bilmek gerekir.

Ekran bir piksel ızgarasıdır. Her pikselin bir sütun numarası (x) ve bir satır numarası (y) vardır. Koordinatlar tam sayıdır ve bileşenin sol üst köşesinden ölçülür.

Matematikteki eksenle en önemli fark y'nin yönüdür. Matematikte y yukarı doğru büyür; ekranda aşağı doğru. Bu tercih ekranın tarihinden gelir: katot ışınlı tüpler görüntüyü üstten alta, satır satır çiziyordu. Sonuç olarak y değeri büyüyen bir nokta ekranda aşağı iner. y'yi azaltmak noktayı yukarı taşır.

9.1.5Tuval, kalem, renk ve yazı tipi

Çizim için üç şey gerekir: üzerine çizilecek bir yüzey, çizimi yapan bir kalem ve kalemin özellikleri.

• Tuval (canvas): Üzerine resim çizilebilen yüzeydir. Swing'de genellikle JPanel kullanılır. AWT'de bu iş için Canvas sınıfı vardır. Programcı JPanel'den bir alt sınıf türetir ve çizimi onun içine yapar.
• Graphics sınıfı: Çizim işlemlerini yapan “kalem”dir. Metotları drawLine(), drawRect(), fillOval(), drawString() ve drawImage() gibi adlar taşır.
• Color ve Font: Kalemin rengini Color, yazı tipini Font belirler: g.setColor(Color.RED), g.setFont(new Font("Serif", Font.BOLD, 24)).

Kalem benzetmesi bir kuralı da açıklar. Graphics nesnesi programcının elindeki kalemdir. setColor kalemi değiştirir. Kalem değiştirilene kadar bütün çizimler aynı renkle yapılır. Yazı tipi için de durum aynıdır: setFont çağrısından sonraki bütün drawString'ler yeni yazı tipini kullanır. Graphics nesnesi bu yüzden durum tutan bir nesnedir: kendi rengini ve yazı tipini hatırlar.

9.1.6paintComponent ile çizim

Bir panele kalıcı çizim yapmanın yolu, JPanel'den türetilen bir sınıfta paintComponent metodunu geçersiz kılmaktır.

import java.awt.*;
import javax.swing.*;

class CizimPaneli extends JPanel {
    @Override
    public void paintComponent(Graphics g) {
        super.paintComponent(g);     // zemini temizle
        g.setColor(Color.BLUE);
        g.drawRect(20, 30, 50, 70);  // x, y, en, boy
        g.drawString("Merhaba, Java Grafik!", 100, 100);
    }
}

Sınıf JPanel'i genişletir ve üst sınıftaki paintComponent(Graphics g) metodunu geçersiz kılar. @Override notu derleyiciye “bu metot üst sınıftaki bir metodun yerini alıyor” der. Metot adı yanlış yazılırsa derleyici bu notu görüp hata verir. Gövdenin ilk satırı super.paintComponent(g)'dir: üst sınıfın kendi çizimi, yani zeminin arka plan rengiyle boyanması yapılır. Ardından kalem maviye çevrilir. drawRect(20, 30, 50, 70) sol üst köşesi (20, 30)'da olan, 50 piksel geniş ve 70 piksel yüksek bir dikdörtgen çerçevesi çizer. Son satır (100, 100) noktasına bir metin yazar.

Bu kodda dikkat çeken bir şey vardır: paintComponent'i programın hiçbir yeri çağırmaz. Metodu Swing çağırır. Pencere ilk açıldığında, boyutu değiştiğinde, üstündeki başka bir pencere çekildiğinde ya da program repaint() ile yeniden çizim istediğinde Swing bu metodu çalıştırır. Çağırırken de hazır bir Graphics g nesnesi verir. Bu nesne o anda çizilecek bölgeye bağlıdır.

Metodun gerçekte hangi çizim çağrılarını yaptığını görmek için Swing'in DebugGraphics sınıfı kullanılabilir. Bu sınıf, her çizim çağrısını bir satır olarak yazan bir kalemdir. CizimPaneli 300 × 160 boyutunda bir resim üzerinde bu kalemle çalıştırıldığında şu çağrılar görülür (kısaltılmış):

setColor(238, 238, 238)
fillRect(0, 0, 300, 160)
setColor(0, 0, 255)
drawRect(20, 30, 50, 70)
drawString("Merhaba, Java Grafik!", 100, 100)

İlk iki satırı programcı yazmadı. Onlar super.paintComponent(g)'nin işidir: kalem panelin arka plan rengine, (238, 238, 238) açık griye çevrilir ve bütün panel bu renkle doldurulur. Sonraki üç satır programcının yazdığı çağrılardır.

Bir grafik nesnesi panel.getGraphics() ile de alınabilir. Ancak bu nesneyle yapılan çizim kalıcı değildir. Pencere bir sonraki kez yeniden çizildiğinde, örneğin küçültülüp büyütüldüğünde, Swing paintComponent'i çağırır ve getGraphics() ile çizilenler silinir. Kalıcı çizimin yolu paintComponent'tir. Çizimin verisi alanlarda saklanır ve metot her çağrıldığında bu veriden yeniden üretilir.

Metnin konumu da bir ayrıntı taşır. drawString'in y parametresi metnin üst kenarı değil, taban çizgisidir. Taban çizgisi harflerin “oturduğu” çizgidir. drawString("Merhaba, Java Grafik!", 100, 100) çağrısında harflerin gövdesi 100. satırın üstünde kalır; yalnız “g”, “j” gibi harflerin kuyrukları bu çizginin altına iner.

9.1.7Graphics çizim metotları

Graphics sınıfının sık kullanılan metotları Tablo 9.2'de toplanmıştır. Adlarda bir düzen vardır: draw… ile başlayan metotlar yalnız çerçeveyi, fill… ile başlayanlar içi dolu şekli çizer.

Elips ve daireler merkezleriyle değil, sınırlayıcı dikdörtgenleriyle verilir. Elipsin sığdığı dikdörtgenin sol üst köşesi ve boyutu yazılır.

Merkezi (cx, cy), yarıçapı r olan bir daire çizmek için sınırlayıcı karenin sol üst köşesi hesaplanır. Kare, merkezden sola ve yukarı r kadar uzanır; kenarı 2r'dir. Sonuç: fillOval(cx − r, cy − r, 2r, 2r). Tersine, verilen bir drawOval(x, y, en, boy) çağrısında elipsin merkezi (x + en / 2, y + boy / 2)'dir.

Son cümledeki fark küçük ama gerçektir. drawRect(20, 30, 50, 40) çerçevenin sağ alt köşe pikseli (70, 70)'tir; (71, 70) boş kalır. Aynı argümanlarla fillRect ise (69, 69)'a kadar boyar. Bir çerçeveyi dolu bir dikdörtgenin üstüne çizerken bu bir piksellik fark görünür hâle gelir.

9.1.8Kod izleme: şekillerin çizim sırası

Aşağıdaki panel, temel metotların her birini bir kez kullanır.

class SekillerPaneli extends JPanel {
    @Override
    public void paintComponent(Graphics g) {
        super.paintComponent(g);
        g.drawLine(10, 10, 110, 60);
        g.drawRect(130, 10, 80, 50);
        g.fillRect(230, 10, 80, 50);
        g.drawOval(10, 80, 100, 60);
        g.fillOval(130, 80, 60, 60);
        g.drawString("Merhaba", 230, 115);
    }
}

Kodda hiç setColor çağrısı yoktur. Renk verilmediğinde kalem panelin ön plan rengiyle çizer. Swing'in varsayılan görünümünde bu renk (51, 51, 51) koyu gridir; çalıştırılan programda getForeground() bu değeri döndürür. Tablo 9.3 metodun adımlarını izler.

2. adımdaki çizgi (10, 10)'dan (110, 60)'a gider. İkinci noktanın y'si daha büyük olduğu için çizgi sağa ve aşağı iner. 3. ve 4. adımlar aynı boyutta iki dikdörtgen çizer. Biri yalnız çerçevedir, öbürü kalemin rengiyle doludur. 5. adımda (10, 80) noktası elipsin değil, sınırlayıcı kutunun köşesidir.

6. adımda en ve boy eşittir, bu yüzden dolu bir daire çizilir. Merkez (130 + 30, 80 + 30) = (160, 110), yarıçap 30'dur. 7. adımda metnin taban çizgisi y = 115'tir; harfler bu çizginin üstüne yazılır. Metot bittiğinde panel tamamlanmıştır. Pencere her yeniden boyandığında aynı çağrılar aynı sırayla baştan yapılır.

Çizimler üst üste boyanır. Sonradan çizilen şekil öncekini örter. Bu programda şekiller çakışmadığı için sıra görünmez. Şekiller çakıştığında ise son çizilen üstte kalır.

9.2Pencere ve panel

9.2.1JFrame sınıfı

Bir GUI programının bütün bileşenleri bir pencerenin içinde yaşar. Swing'de pencere JFrame sınıfıyla oluşturulur.

Pencere boyutunun iki yolu vardır. setSize boyutu doğrudan verir; bu boyut başlık çubuğunu ve kenarlıkları da içerir. pack() ise içerikteki bileşenlerin tercih ettiği boyutları toplar ve pencereyi tam o kadar büyütür. Bileşenleri yerleşim yöneticisiyle dizilmiş bir pencerede pack() genellikle daha iyi sonuç verir, çünkü yazı tipi ve ekran çözünürlüğü değişse de içerik pencereye sığar.

add çağrısı bileşeni aslında pencerenin kendisine değil, içerik bölmesine (content pane) ekler. İçerik bölmesi, başlık çubuğunun altında kalan iç alandır. Eski Java sürümlerinde pencere.getContentPane().add(...) yazmak zorunluydu. Java 5'ten beri pencere.add(...) bu çağrıyı kendisi yapar. Bu nottaki örnekler iki yazımı da kullanır; anlamları aynıdır.

9.2.2İlk pencere

import javax.swing.JFrame;

public class JFrameOrnegi {
    public static void main(String[] args) {
        JFrame pencere = new JFrame("Java JFrame Örneği");
        pencere.setSize(400, 300);
        pencere.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        pencere.setVisible(true);
    }
}

Program yalnız JFrame sınıfını içe aktarır. main başlığı “Java JFrame Örneği” olan bir pencere oluşturur, boyutunu 400 × 300 yapar, kapatma davranışını belirler ve pencereyi görünür kılar. Pencerenin içi boştur. main bu dört satırdan sonra biter, ama program pencere kapanana kadar çalışmayı sürdürür.

Bu kısa programda üç tuzak vardır:

• setVisible(true) unutulursa pencere bellekte oluşur ama ekranda görünmez. Program hata vermez; yalnız hiçbir şey olmuyormuş gibi görünür.
• EXIT_ON_CLOSE verilmezse varsayılan davranış HIDE_ON_CLOSE'dur. Kullanıcı × düğmesine basınca pencere gizlenir, ama program arka planda çalışmaya devam eder. Geliştirme ortamında bu, durdurulması unutulan program örnekleri olarak birikir.
• Boyut verilmezse pencere 0 × 0'a yakın, yalnız başlık çubuğu kadar açılır.

setDefaultCloseOperation'ın kabul ettiği dört sabit WindowConstants arayüzünde tanımlıdır. DO_NOTHING_ON_CLOSE (0) kapatmayı tümüyle engeller. HIDE_ON_CLOSE (1) pencereyi gizler. DISPOSE_ON_CLOSE (2) pencereyi yok eder; başka pencere kalmamışsa program bitebilir. EXIT_ON_CLOSE (3) System.exit(0) çağırır.

Bu program, ekranı olmayan bir ortamda çalıştırılırsa ilginç bir sonuç verir. Java, ekransız ortamı “başsız” (headless) kip olarak tanır. Bu kipte new JFrame(...) çağrısı java.awt.HeadlessException fırlatır, çünkü gösterilecek ekran yoktur. Panel, düğme ve metin alanı gibi bileşenler ise bu kipte de oluşturulabilir. Notta verilen çıktıların çoğu bu yolla, pencere açılmadan, bileşenleri doğrudan çalıştırarak elde edilmiştir.

9.2.3JPanel sınıfı

JPanel'in dört kullanımı vardır:

• Gruplamak: Birden fazla panel iç içe konarak karmaşık düzenler kurulur. Örneğin bir pencerenin altındaki düğme sırası ayrı bir panelde toplanır.
• Özelleştirmek: setBackground(), setBorder() ve setPreferredSize() ile rengi, kenarlığı ve tercih edilen boyutu değiştirilir.
• Tuval olmak: Çizim, animasyon ve grafikler panelde yapılır: JPanel'den türetilir ve paintComponent geçersiz kılınır.
• Kodu bölmek: Her panel ayrı bir sınıf olabilir. Büyük bir arayüz böylece küçük, ayrı ayrı anlaşılabilen parçalara bölünür.

Şekil 9.9'daki yapı bir ağaçtır. Kök pencerededir, yapraklar düğme ve etiket gibi bileşenlerdir. Ara düğümler kapsayıcılardır. Bir kapsayıcı yeniden boyanırken önce kendisini, sonra içindeki bileşenleri çizer. Bileşen ağacının her düzeyinde aynı kural işler.

9.2.4Panel örneği

import java.awt.Color;
import javax.swing.*;

public class PanelOrnegi {
    public static void main(String[] args) {
        JPanel panel = new JPanel();
        panel.setBackground(Color.LIGHT_GRAY);
        panel.add(new JButton("Tıkla"));
        JFrame pencere = new JFrame("JPanel Örneği");
        pencere.add(panel);
        pencere.setSize(300, 150);
        pencere.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        pencere.setVisible(true);
    }
}

Program bir panel oluşturur ve arka planını Color.LIGHT_GRAY, yani (192, 192, 192) açık gri yapar. Panele “Tıkla” yazılı bir düğme eklenir. Ardından pencere oluşturulur, panel pencereye eklenir ve pencere 300 × 150 boyutunda gösterilir. Düğmenin bir dinleyicisi yoktur; tıklanınca görsel olarak basılır, ama hiçbir şey olmaz.

Pencerede düğme panelin üst ortasında durur. Panel ise bütün pencereyi kaplar. Bu iki gözlemin nedeni yerleşim yöneticileridir. JPanel'in varsayılan yerleşim yöneticisi FlowLayout'tur. Bu yönetici bileşenleri tercih ettikleri boyutta, satır satır ve ortalı dizer. Panelin içinde tek bir düğme olduğu için düğme ilk satırın ortasına konur. JFrame'in içerik bölmesi ise BorderLayout kullanır. Bölge belirtilmeden eklenen panel merkez bölgeye yerleşir. Merkez de geriye kalan bütün alanı alır.

9.3Çizim araçları

Çizimde üç küçük sınıf sürekli kullanılır: bir noktayı tutan Point, rengi tutan Color ve yazı tipini tutan Font. Üçü de java.awt paketindedir.

9.3.1Point sınıfı

Point, sarmalama ilkesinin bilinçli bir istisnasıdır: alanları public'tir ve doğrudan okunup yazılabilir. Grafik kodunda nokta koordinatlarına çok sık erişildiği için kütüphane sadeliği tercih etmiştir. Sınıfın metotları da vardır. Aşağıdaki kod bunların çoğunu kullanır.

Point nokta = new Point(30, 40);
double xKoordinati = nokta.getX();
double yKoordinati = nokta.getY();
System.out.println(xKoordinati + " " + yKoordinati);
System.out.println(nokta.x + " " + nokta.y);
System.out.println(nokta.distance(0, 0));
nokta.setLocation(60, 80);
System.out.println(nokta);
nokta.translate(5, -10);   // 5 sağa, 10 yukarı
System.out.println(nokta);
System.out.println(Point.distance(0, 0, 3, 4));

30.0 40.0
30 40
50.0
java.awt.Point[x=60,y=80]
java.awt.Point[x=65,y=70]
5.0

1. adımda (30, 40) noktası oluşur. 2. ve 3. adımlarda getX() ve getY() değerleri double değişkenlere alınır. 4. adım bu değerleri yazar: 30.0 40.0. Ondalık nokta, değerin double olduğunu gösterir. 5. adım alanlara doğrudan erişir; nokta.x bir int olduğu için 30 40 yazılır. Aynı sayının iki farklı biçimde yazılması, tipin çıktıyı nasıl etkilediğini gösterir.

6. adımda distance(0, 0) noktanın orijine uzaklığını hesaplar. Pisagor bağıntısıyla √(30² + 40²) = √2500 = 50.0 bulunur. 7. adımda setLocation(60, 80) noktayı yeni bir konuma taşır. xKoordinati ve yKoordinati değişmez. Onlar 2. ve 3. adımda alınmış kopyalardır; nesneyle bağları kalmamıştır. 8. adımda println(nokta) nesnenin toString() metodunu çağırır ve sınıf adıyla alanları yazar: java.awt.Point[x=60,y=80].

9. adımdaki translate(dx, dy) göreli bir kaydırmadır: x'e dx, y'ye dy eklenir. dy = −10 olduğu için y 80'den 70'e azalır ve nokta ekranda yukarı çıkar (Şekil 9.10). Son satırdaki Point.distance(0, 0, 3, 4) bir sınıf metodudur. Nesne gerektirmez; iki noktanın koordinatlarını alır ve 5.0 döndürür.

java.awt.Point[x=30,y=25] true
4.0
140 70 35

Çıktının üçüncü satırı bir sonraki sınıfla ilgilidir: new Color(200, 100, 50).darker() rengin bileşenlerini verir.

9.3.2Color sınıfı

java.awt.Color, arayüzün ve çizimlerin rengini tutar. Ekrandaki her renk, üç ana rengin karışımıdır: kırmızı (red), yeşil (green) ve mavi (blue). Bu düzene RGB denir.

Rengi elde etmenin iki yolu vardır. Birincisi hazır sabitlerdir: Color.RED, Color.GREEN, Color.WHITE, Color.LIGHT_GRAY gibi. Bu sabitlerin küçük harfli eş adları da vardır (Color.red); ikisi aynı nesneyi gösterir. İkincisi RGB üçlüsüyle yeni bir nesne oluşturmaktır. 0–255 dışındaki bir değer IllegalArgumentException fırlatır; new Color(300, 0, 0) çağrısının iletisi Color parameter outside of expected range: Red'dir.

Color turuncu = new Color(255, 128, 0);
System.out.println(turuncu);
System.out.println(turuncu.getGreen());
System.out.println(Color.RED.darker());

java.awt.Color[r=255,g=128,b=0]
128
java.awt.Color[r=178,g=0,b=0]

Bir rengin koyu ve açık tonları için iki metot vardır. darker() her bileşeni 0,7 ile çarpar ve tam sayıya keser. brighter() ise her bileşeni 0,7'ye böler, sonucu 255'te sınırlar. İki metot da asıl rengi değiştirmez; yeni bir Color nesnesi döndürür. Color nesneleri değiştirilemezdir.

Tablonun son satırı bir uyarı taşır. darker() ve brighter() birbirinin tam tersi değildir. Her işlem sonucu tam sayıya keser ve kesilen kesir geri gelmez. Kırmızıyı koyultup yeniden açınca (255, 0, 0) değil, (254, 0, 0) elde edilir.

brighter()'ın sıfır bileşenleri neden değiştirmediği de sorulabilir. Sıfırın 0,7'ye bölümü yine sıfırdır. Bu yüzden saf kırmızı “açılınca” pembeye dönmez, aynı kalır. Kütüphane tek bir özel durumu ayrıca ele alır: siyah (0, 0, 0) açılınca (3, 3, 3) olur, çünkü aksi hâlde siyah hiç açılamazdı.

9.3.3Font sınıfı

java.awt.Font, metnin yazı tipini, stilini ve boyutunu belirler. Yapıcı üç parametre alır: new Font(ad, stil, punto).

Mantıksal ad, Java'nın her sistemde gerçek bir yazı tipine eşlediği addır. "Serif" Windows'ta çoğunlukla Times New Roman'a, "Monospaced" Courier New'e karşılık gelir. Gerçek bir yazı tipi adı verilir ve o yazı tipi sistemde yoksa Java "Dialog"'a döner. Taşınabilir programlar bu yüzden mantıksal adları tercih eder.

Stil sabitleri bit bayraklarıdır. BOLD sayının 1. bitini, ITALIC 2. bitini kullanır. | işleci (bit düzeyinde VEYA) iki bayrağı birleştirir: 1 | 2 = 3. new Font("Serif", Font.BOLD | Font.ITALIC, 20) nesnesinde getStyle() 3 döndürür; isBold() ve isItalic() ikisi de true'dur.

public void paintComponent(Graphics g) {
    super.paintComponent(g);
    g.setColor(new Color(0, 102, 204));
    g.setFont(new Font("Serif", Font.BOLD, 24));
    g.drawString("Java", 20, 40);
    g.setFont(new Font("Monospaced", Font.PLAIN, 14));
    g.drawString("Grafik", 20, 70);
}

Metot kalemi önce (0, 102, 204) mavisine çevirir. İlk metin kalın, 24 puntoluk Serif ile (20, 40)'a yazılır. Ardından yazı tipi değiştirilir ve ikinci metin 14 puntoluk Monospaced ile (20, 70)'e yazılır. Renk değiştirilmediği için iki metin de aynı mavidedir.

JLabel gibi bileşenlerde de aynı Font nesnesi kullanılır: etiket.setFont(f). Var olan bir yazı tipinden yeni bir tane türetmek için deriveFont metodu vardır. f.deriveFont(Font.ITALIC, 18f) aynı ailede, italik ve 18 puntoluk yeni bir nesne döndürür. f değişmez.

9.4Yerleşim yöneticileri

9.4.1Yerleşim yöneticisi nedir?

Bir pencereye beş düğme konacağını düşünelim. Her düğmenin konumu ve boyutu elle verilebilir: “birinci düğme (10, 10)'da, 80 × 30”. Bu yöntem bir sorunla karşılaşır. Kullanıcı pencereyi büyütünce düğmeler sol üstte kalır. Ekran çözünürlüğü ya da yazı tipi değişince düğme metinleri kutulara sığmaz. Java bu işi bir nesneye devreder.

Yerleşim yöneticisi koordinatları elle vermenin yerine kullanılır. Pencere büyüyünce, yazı tipi ya da ekran çözünürlüğü değişince düzen kendiliğinden yeniden hesaplanır. Programcı yalnız kuralı seçer: “satır satır diz”, “beş bölgeye yerleştir”, “eşit hücrelere böl”. Java'nın standart yöneticilerinden dördü bu notta işlenir.

Daha esnek ama karmaşık olan GridBagLayout, farklı boyutlarda hücrelerden oluşan bir ızgara kurar. Çoğu zaman buna gerek kalmaz. Panelleri iç içe koyup her birine basit bir yönetici vermek yeterlidir. Örneğin bir pencerenin içerik bölmesi BorderLayout kullanır, alttaki düğme şeridi ise FlowLayout kullanan ayrı bir paneldir.

Yerleşim yöneticilerinin davranışı etkileşimli olarak Swing Yerleşim Yöneticileri simülatöründe izlenebilir. Simülatörde pencere boyutu değiştikçe dört yöneticinin düzeni nasıl yeniden hesapladığı görülür.

9.4.2Kod izleme: FlowLayout satırları nasıl doldurur?

Yerleşim yöneticisinin çalışmasını anlamanın en iyi yolu, bir düzeni elle hesaplamaktır. Aşağıdaki kod, 260 piksel genişliğindeki bir panele genişlikleri farklı beş düğme ekler ve hesaplanan konumları yazar.

int[] gen = {90, 60, 110, 70, 80};
JPanel panel = new JPanel();   // FlowLayout(CENTER, 5, 5)
panel.setSize(260, 120);
for (int i = 0; i < gen.length; i++) {
    JButton b = new JButton("B" + i);
    b.setPreferredSize(new Dimension(gen[i], 30));
    panel.add(b);
}
panel.doLayout();              // konumları hesapla
for (Component c : panel.getComponents())
    System.out.println(c.getX() + ", " + c.getY());

52, 5
147, 5
37, 40
152, 40
90, 75

FlowLayout'un varsayılan ayarları FlowLayout(CENTER, 5, 5)'tir: satırlar ortalanır, bileşenler arasında yatayda ve dikeyde 5 piksel boşluk kalır. Aynı boşluk panelin kenarlarında da bırakılır. Her düğmenin tercih ettiği boyut setPreferredSize ile verilmiştir: genişlikler 90, 60, 110, 70 ve 80; yükseklikler 30.

İzlemenin ilk dersi 2. ve 3. adımlardadır. add düğmeyi kapsayıcının bileşen listesine ekler, ama yerleştirmez. Döngü bittiğinde beş düğmenin de konumu (0, 0), boyutu 0 × 0'dır. Yerleşim ancak düzen hesaplanınca yapılır. Gerçek bir pencerede bu iş pack(), setVisible(true) ya da pencere boyutunun değişmesiyle kendiliğinden tetiklenir. Örnekte ise doLayout() açıkça çağrılır.

doLayout() satırları şöyle doldurur. Kullanılabilir genişlik, panel genişliğinden iki kenar boşluğunun çıkarılmasıyla bulunur: 260 − 2 × 5 = 250. Düğmeler sırayla satıra eklenir. B0 (90) ve B1 (60) aralarındaki 5 piksel boşlukla 155 piksel tutar; sığar. B2 de eklense satır 155 + 5 + 110 = 270 piksel olurdu. 270 > 250 olduğu için B2 alt satıra iner.

Bir satır kapanınca ortalanır. Satırın boşta kalan genişliği iki yana eşit dağıtılır: x0 = 5 + (250 − 155) / 2 = 5 + 47 = 52. Tam sayı bölmesi 47,5'i 47'ye keser. B0 x = 52'ye, B1 x = 52 + 90 + 5 = 147'ye konur; ikisinin y'si 5'tir.

İkinci satır B2 (110) ve B3 (70) ile 185 piksel tutar. B4 eklense 185 + 5 + 80 = 270 olurdu; yine sığmaz. Ortalama: x0 = 5 + (250 − 185) / 2 = 5 + 32 = 37. B2 x = 37'ye, B3 x = 37 + 110 + 5 = 152'ye konur. Satırın y'si, önceki satırın altı artı boşluktur: 5 + 30 + 5 = 40. B4 üçüncü satırda yalnızdır: x0 = 5 + (250 − 80) / 2 = 90, y = 5 + 30 + 5 + 30 + 5 = 75. Hesap çıktıyla birebir tutar.

Panel genişlerse satırlar yeniden hesaplanır. Aynı panel 400 piksele çıkarılıp düzen yeniden hesaplatıldığında kullanılabilir genişlik 390 olur. İlk dört düğme (90 + 60 + 110 + 70 + 3 × 5 = 345) tek satıra sığar; B4 ikinci satıra iner:

(27, 5) (122, 5) (187, 5) (302, 5) (160, 40)

9.4.3BorderLayout

BorderLayout, kapsayıcıyı beş bölgeye ayırır: NORTH (kuzey), SOUTH (güney), WEST (batı), EAST (doğu) ve CENTER (merkez). Önceliği farklı bileşenleri düzenli göstermek için uygundur: araç çubuğu üstte, durum satırı altta, asıl içerik ortada.

Yöneticinin kuralları şunlardır:

• Bölge belirtilmeden eklenen bileşen merkeze yerleşir: add(b) ile add(b, BorderLayout.CENTER) aynıdır.
• Her bölgede tek bileşen olur. Aynı bölgeye ikinci ekleme öncekinin yerini alır.
• Kuzey ve güney bütün genişliği alır; yükseklikleri bileşenin tercih ettiği yüksekliktir. Batı ve doğu, kuzeyle güney arasında kalan yüksekliği alır; genişlikleri tercih edilen genişliktir. Merkez geriye kalan her şeyi doldurur.
• setHgap() ve setVgap() bölgeler arasındaki yatay ve dikey boşluğu piksel olarak ayarlar. Aynı değerler yapıcıya da verilebilir: new BorderLayout(5, 5).

İkinci kuralın ince bir yanı vardır. Aynı bölgeye ikinci bileşen eklendiğinde birincisi kapsayıcıdan silinmez. Kapsayıcının bileşen sayısı 2'dir; ama yönetici yalnız son ekleneni o bölgeye bağlar. Birinci bileşen yerleşime katılmaz ve boyutu 0 × 0 kalır. Ekranda görünmez.

9.4.4Kod izleme: bölgeleri doldurmak

JPanel panel = new JPanel();
BorderLayout yerlesim = new BorderLayout();
yerlesim.setHgap(5);
yerlesim.setVgap(5);
panel.setLayout(yerlesim);
panel.add(new JButton("Kuzey"), BorderLayout.NORTH);
panel.add(new JButton("Güney"), BorderLayout.SOUTH);
panel.add(new JButton("Batı"), BorderLayout.WEST);
panel.add(new JButton("Doğu"), BorderLayout.EAST);
panel.add(new JButton("Merkez"), BorderLayout.CENTER);

Kod bir panel ve bir BorderLayout nesnesi oluşturur, boşlukları 5 piksel yapar ve yöneticiyi panele verir. Ardından beş bölgenin her birine bir düğme eklenir. Tablo 9.9 her eklemenin düzene etkisini anlatır.

Piksel değerleri panel boyutuna ve düğmelerin tercih ettiği boyuta bağlıdır. Panel 400 × 250 yapılıp düzen hesaplatıldığında değerler şöyle çıkar. Düğmeler varsayılan yazı tipinde 26 piksel yüksektir. Kuzey (0, 0)'da 400 × 26, güney (0, 224)'te 400 × 26'dır. Batı ve doğu kuzeyin altından 5 piksel boşlukla başlar: y = 26 + 5 = 31. Yükseklikleri 250 − 26 − 26 − 2 × 5 = 188'dir. Batı 56, doğu 63 piksel geniştir; bunlar “Batı” ve “Doğu” metinlerinin gerektirdiği genişliklerdir. Merkez x = 56 + 5 = 61'den başlar ve 400 − 56 − 63 − 2 × 5 = 271 piksel genişliğindedir. Merkezin tercih ettiği 76 piksel bu hesapta hiç kullanılmaz.

Pencere büyütülürse en çok merkez büyür. Kuzey ve güney yalnız genişler, batı ve doğu yalnız uzar. Bu özellik BorderLayout'u ana pencere düzeni için uygun kılar: metin alanı ya da çizim tuvali merkeze konur ve pencereyle birlikte büyür.

9.4.5GridLayout ve BoxLayout

GridLayout(satır, sütun), kapsayıcıyı eşit boyutlu hücrelere böler. Bileşenler satır satır, soldan sağa yerleşir. Her bileşen hücresini tümüyle doldurur; tercih edilen boyut dikkate alınmaz.

Satır ya da sütun sayısından biri 0 verilebilir. new GridLayout(0, 2) “iki sütun, satır sayısı gerektiği kadar” demektir. 200 × 150'lik bir panele beş düğme eklenirse üç satır oluşur. Hücreler 100 × 50 olur ve beşinci düğme (0, 100)'e konur. Bileşen sayısı satır × sütun sayısını aşarsa ve ikisi de sıfırdan farklıysa, Java satır sayısını korur ve sütun sayısını artırır. GridLayout(2, 3)'e yedi düğme eklenince ızgara 2 × 4 olur ve hücreler 75 piksele daralır.

BoxLayout bileşenleri tek satıra ya da tek sütuna dizer. Yapıcısı, yönettiği kapsayıcıyı da parametre olarak alır: panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS)). Y_AXIS alt alta, X_AXIS yan yana dizer. Formlarda etiketleri ve alanları alt alta sıralamak için kullanılır.

9.5Uygulama: giriş yasak işareti

9.5.1Hedef ve katmanlar

Bu uygulama, trafikteki “girişi olmayan yol” işaretini çizen bir panel yazar. İşaret, üst üste boyanan dört katmandan oluşur:

1. Yeşil arka plan (setBackground ile).
2. Beyaz büyük daire (dış halka).
3. Kırmızı, biraz küçük daire.
4. Ortada beyaz yatay bar.

Programın önemli bir tasarım kararı vardır: bütün ölçüler getWidth() ve getHeight()'tan hesaplanır. Sabit piksel değeri kullanılmaz. Pencere büyütülünce işaret de büyür ve her zaman ortada kalır. Çizim, panelin o anki boyutuna göre her seferinde baştan hesaplanır.

9.5.2paintComponent kodu

public class GirisYasaktirIsareti extends JPanel {
    @Override
    public void paintComponent(Graphics g) {
        super.paintComponent(g);
        var c = new Point(getWidth() / 2, getHeight() / 2); // merkez
        var r = Math.min(getWidth() / 2, getHeight() / 2) - 5; // yarıçap
        var r2 = (int) (r * 0.9);   // iç yarıçap
        var bw = (int) (r2 * 1.4);  // bar genişliği
        var bh = (int) (r2 * 0.35); // bar yüksekliği
        g.setColor(Color.WHITE);
        g.fillOval(c.x - r, c.y - r, 2 * r, 2 * r);
        g.setColor(Color.RED);
        g.fillOval(c.x - r2, c.y - r2, r2 * 2, r2 * 2);
        g.setColor(Color.WHITE);
        g.fillRect(c.x - bw / 2, c.y - bh / 2, bw, bh);
    }
}

Kod beş değişken hesaplar, sonra üç şekil çizer. Değişkenler var ile tanımlanmıştır. Java 10'dan beri var, yerel değişkenin tipini derleyicinin sağdaki ifadeden çıkarmasını sağlar. Burada c'nin tipi Point, diğerlerinin tipi int'tir. Klasik yazım şöyledir: Point c = new Point(…); int r = …;. var tipi ortadan kaldırmaz; tip derleme anında belirlenir ve sonradan değişmez.

Satırları sırayla okuyalım:

• c: Panelin merkezi. Genişlik ve yükseklik ikiye bölünür. İki işlenen de int olduğu için tam sayı bölmesi yapılır.
• r: Dış dairenin yarıçapı. Merkezden kısa kenara olan uzaklık seçilir (Math.min) ve 5 piksel pay bırakılır. Daire böylece panelin dışına taşmaz.
• r2: İç dairenin yarıçapı, r'nin %90'ı. r * 0.9 bir double'dır; (int) dönüşümü ondalık kısmı atar.
• bw ve bh: Barın genişliği ve yüksekliği, iç yarıçapın 1,4 ve 0,35 katı.

Çizim üç adımda yapılır. Önce kalem beyaza çevrilir ve dış daire çizilir. Sonra kalem kırmızıya çevrilir ve iç daire çizilir. Kırmızı daire beyazın üstüne boyanır; beyazdan geriye yalnız dışta ince bir halka kalır. Son olarak kalem yeniden beyaza çevrilir ve bar çizilir. Bar, sınırlayıcı dikdörtgenin sol üst köşesiyle verilir: merkezden yarı genişlik kadar sola, yarı yükseklik kadar yukarı.

Gerekli içe aktarmalar java.awt.* ve javax.swing.*'tır. Point, Graphics ve Color birincisinden, JPanel ikincisinden gelir.

9.5.3Kod izleme: işareti çizmek

Panel 384 × 261 piksel olsun. Bu boyut, 400 × 300'lük bir pencereden başlık çubuğu ve kenarlıklar düşülünce kalan iç alanın tipik değeridir. Gerçek değer işletim sistemine ve tema ayarlarına göre birkaç piksel değişir.

2. adımda merkez (384 / 2, 261 / 2) hesaplanır. 261 / 2 matematikte 130,5'tir, ama tam sayı bölmesi ondalığı atar: (192, 130). 3. adımda yarıçap için min(192, 130) − 5 = 125 bulunur. Kısa kenar yükseklik olduğu için yarıçapı o belirler.

4.–6. adımlar tip dönüşümünü gösterir. 125 × 0,9 = 112,5; (int) bunu 112'ye keser. Yuvarlama yapılmaz: 112,5 bile aşağı iner. 112 × 1,4 ise 156,8 olmalıdır. double aritmetiği bu değeri tam gösteremez; Java'da çarpımın sonucu 156.79999999999998'dir. Kesme yine 156 verir. Bar yüksekliği 112 × 0,35 = 39,2; kesilince 39'dur.

7. adımdaki fillOval(c.x − r, c.y − r, 2 * r, 2 * r) çağrısının argümanları (192 − 125, 130 − 125, 250, 250) = (67, 5, 250, 250)'dir. 8. adımda iç daire (192 − 112, 130 − 112, 224, 224) = (80, 18, 224, 224) ile çizilir. İki yarıçap arasındaki fark 125 − 112 = 13 piksellik beyaz halkayı verir. 9. adımda bar (192 − 78, 130 − 19, 156, 39) = (114, 111, 156, 39)'a çizilir. bw / 2 = 78 ve bh / 2 = 19 değerleri de tam sayı bölmesidir.

Hesaplanan çağrılar Java'da doğrulandı. Panel başsız kipte 384 × 261 boyutuna getirildi ve paintComponent bir resim üzerinde DebugGraphics kalemiyle çalıştırıldı. Kayıtta tam olarak fillOval(67, 5, 250, 250), fillOval(80, 18, 224, 224) ve fillRect(114, 111, 156, 39) görüldü. Resimdeki pikseller de beklenen renkleri taşıyordu: merkez beyaz (bar), (192, 25) kırmızı, (192, 10) beyaz (halka), (5, 5) yeşil.

setColor(0, 178, 0)
fillRect(0, 0, 240, 180)
setColor(255, 255, 255)
fillOval(35, 5, 170, 170)
setColor(255, 0, 0)
fillOval(44, 14, 152, 152)
setColor(255, 255, 255)
fillRect(67, 77, 106, 26)

9.5.4main ve pencere

public static void main(String[] args) {
    SwingUtilities.invokeLater(() -> {
        var panel = new GirisYasaktirIsareti();
        panel.setBackground(Color.GREEN.darker());
        var frame = new JFrame("Basit bir grafik programı");
        frame.setSize(400, 300);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.getContentPane().add(panel, BorderLayout.CENTER);
        frame.setVisible(true);
    });
}

main metodunun tek işi, arayüzü kuracak kodu SwingUtilities.invokeLater'a vermektir. () -> { … } bir lambda ifadesidir: “sonra çalıştırılacak kod parçası”. invokeLater bu parçayı olay iş parçacığında çalıştırılmak üzere kuyruğa koyar. Bu kalıp her Swing programının main'inde bulunur; gerekçesi olay iş parçacığının çalışma kuralıdır.

Lambdanın içinde panel oluşturulur ve arka planı Color.GREEN.darker(), yani (0, 178, 0) yapılır. Saf yeşil (0, 255, 0) göz yoracak kadar parlaktır; koyu ton trafik işaretine daha çok benzer. super.paintComponent(g) zemini bu renkle boyar. Panel, pencerenin içerik bölmesinin merkezine eklenir. Tek bileşen olduğu için bütün alanı kaplar.

400 × 300 pencerede kenarlık ve başlık çubuğu düşülünce panel yaklaşık 384 × 261 olur. Bu değer işletim sistemine göre değişir. Programın doğru çalışması bu değere bağlı değildir: ölçüler her çizimde getWidth() ve getHeight()'tan yeniden hesaplanır. Panel 768 × 522'ye büyütülürse dış daire fillOval(128, 5, 512, 512) ile çizilir ve işaret yine ortadadır.

9.6Fare olayları ve olay iş parçacığı

9.6.1Etkileşimli grafik ve olay döngüsü

Bilgisayar grafikleri, görsel içerik oluşturma ve işleme sürecidir. Etkileşimli (interactive) grafiklerde kullanıcı fare, klavye gibi giriş aygıtlarıyla görüntüyü değiştirir. Çizim programları, oyunlar ve haritalar bu türdendir. Grafik kütüphaneleri şekil çizmeyi ve renklendirmeyi sağlar; etkileşim ise bir olay döngüsüyle kurulur.

Döngüdeki adımlar sırasıyla şunlardır. Kullanıcı fareye basar. İşletim sistemi bu eylemi algılar ve Java'ya bildirir. Java bir olay nesnesi oluşturur ve olay kuyruğuna koyar. Olay iş parçacığı kuyruktaki sıradaki olayı alır ve o bileşene kayıtlı dinleyicinin metodunu çağırır. Dinleyici metot programın verisini günceller ve repaint() ile yeniden çizim ister. Swing uygun bir anda paintComponent'i çağırır; ekran yeni veriyle çizilir. Olay iş parçacığı sıradaki olaya geçer.

Bu döngünün bir kuralı vardır: dinleyici metot ekranı doğrudan boyamaz. Yalnız veriyi değiştirir ve yeniden çizim ister. Çizimi her zaman paintComponent yapar. Bu ayrım, çizimin tek bir yerde toplanmasını ve pencere her yeniden boyandığında doğru görüntünün oluşmasını sağlar.

9.6.2Dinleyici arayüzü ve adaptör sınıfı

Fare olayları için Java'nın arayüzü MouseListener'dır. Arayüzün beş soyut metodu vardır. Bir sınıf bu arayüzü uygularsa beş metodun hepsini yazmak zorundadır. İlgilenmediği metotların gövdesi boş kalır.

class Dinleyici implements MouseListener {
    public void mouseClicked(MouseEvent e) {
        System.out.println("tık");
    }
    public void mousePressed(MouseEvent e) { }
    public void mouseReleased(MouseEvent e) { }
    public void mouseEntered(MouseEvent e) { }
    public void mouseExited(MouseEvent e) { }
}

Beş metottan dördü boştur. Yalnız tıklamayla ilgilenen bir sınıf için bu fazla yazımdır. Java bu durum için hazır sınıflar sunar.

class Dinleyici extends MouseAdapter {
    @Override
    public void mouseClicked(MouseEvent e) {
        System.out.println("tık");
    }
}
// panel.addMouseListener(new Dinleyici());

MouseAdapter soyut bir sınıftır, ama soyut metodu yoktur; bütün metotları boş gövdelidir. Soyut tanımlanmasının amacı, doğrudan nesnesinin oluşturulmasını engellemektir. MouseAdapter üç arayüzü birden uygular: MouseListener, MouseMotionListener ve MouseWheelListener. Tek bir alt sınıf böylece tıklama, hareket ve tekerlek olaylarının hepsini yazabilir.

Hareket olayları ayrı bir arayüzdedir: MouseMotionListener. Bu arayüzün iki metodu vardır: mouseDragged ve mouseMoved. Kendi adaptörü MouseMotionAdapter'dır. Kayıt da ayrıdır: tıklama türü olaylar addMouseListener(…), hareket olayları addMouseMotionListener(…) ile kaydedilir.

Dinleyici sınıfı ayrı bir dosyada yazmak da gerekmez. Java, tek kullanımlık sınıfı kullanıldığı yerde tanımlamaya izin verir.

Dinleyici.java:6: error: Dinleyici is not abstract and does not override abstract method mouseExited(MouseEvent) in MouseListener
class Dinleyici implements MouseListener {

9.6.3Fare olay metotları

Bir tıklama tek bir olay değildir. Kullanıcı düğmeye basar: mousePressed. Bırakır: mouseReleased. Basma ve bırakma aynı noktada olduysa Java bir de mouseClicked üretir. Basma ile bırakma arasında fare hareket ettiyse mouseClicked gelmez; araya mouseDragged olayları girer. Bu yüzden çizim programı gibi uygulamalar tıklamayı değil, basmayı ve sürüklemeyi dinler.

Başsız kipte bir panele sırayla basma, bırakma ve tıklama olayları gönderildiğinde dinleyiciler bu sırayla çağrıldı. Aynı panele hem Dinleyici (arayüzü uygulayan) hem Dinleyici2 (adaptörden türeyen) kaydedildiği için tıklamada iki kez “tık” yazıldı. Bir bileşene birden çok dinleyici kaydedilebilir; olay geldiğinde hepsi çağrılır.

9.6.4MouseEvent sınıfı

Her fare metodu bir MouseEvent e parametresi alır. Olayın nerede, hangi düğmeyle ve hangi tuşlar basılıyken olduğu bu nesnededir.

panel.addMouseListener(new MouseAdapter() {
    @Override
    public void mousePressed(MouseEvent e) {
        String dugme = "sol";
        if (e.getButton() == MouseEvent.BUTTON3) {
            dugme = "sağ";
        }
        System.out.println(dugme + " (" + e.getX()
                + ", " + e.getY() + ")"
                + (e.isShiftDown() ? " + Shift" : ""));
    }
});

Kod bir panele anonim bir adaptör kaydeder. Basılan düğme sağ düğmeyse dugme değişkeni “sağ” olur. Ardından düğme adı, konum ve Shift tuşu basılıysa “ + Shift” yazılır. Panele (40, 120)'de sol tıklandığında sol (40, 120), Shift basılıyken (70, 30)'da sağ tıklandığında sağ (70, 30) + Shift yazdığı çalıştırılarak görüldü.

Koordinatlar ekrana değil, olayı alan bileşene göredir. Panelin sol üst köşesi, panel pencerenin neresinde olursa olsun, (0, 0)'dır. Bu sayede panelin içinde çizilen şekillerle fare koordinatları doğrudan karşılaştırılabilir.

Özetle, bir tıklama pressed → released → clicked sırasıyla üç olay üretir; sürüklerken ise çok sayıda mouseDragged gelir. Sağ tık BUTTON3'tür.

9.6.5Olay iş parçacığı (EDT)

Swing programlarının main'i SwingUtilities.invokeLater kalıbıyla yazılır. Bu kalıbın nedeni, Swing'in iş parçacıklarıyla ilişkisidir.

Swing bileşenleri iş parçacığı güvenli değildir (not thread-safe). Aynı bileşene aynı anda birden çok iş parçacığı dokunursa bileşenin iç durumu tutarsız hâle gelebilir. Swing bu sorunu kilitlerle değil, basit bir kuralla çözer: bileşenler yalnız olay iş parçacığından kurulur ve değiştirilir. Dinleyici metotlar zaten EDT'de çalışır; onların içinden bileşenlere dokunmak güvenlidir.

Bir benzetme kuralı açıklar. Mutfakta tek bir aşçı vardır: EDT. Garsonlar yemeği kendileri yapmaz; sipariş fişi bırakır. Fiş bir Runnable nesnesidir, yani çalıştırılacak bir kod parçası. Aşçı fişleri geliş sırasıyla, birer birer hazırlar. Tek aşçı olduğu için iki yemek aynı tavaya aynı anda girmez.

invokeAndWait'in EDT içinden çağrılması gerçekten bir Error fırlatır. EDT, kuyruğa koyduğu işin bitmesini beklerse o işi çalıştıracak kimse kalmaz; program sonsuza kadar kilitlenirdi. Swing bunu önceden yakalar:

AWT-EventQueue-0 daemon=false
java.lang.Error: Cannot call invokeAndWait from the event dispatcher thread

İlk satır, invokeAndWait ile çalıştırılan işin hangi iş parçacığında olduğunu gösterir: AWT-EventQueue-0. Bu iş parçacığı arka plan (daemon) iş parçacığı değildir. JVM, arka plan olmayan bir iş parçacığı çalıştıkça kapanmaz. GUI programının main bittikten sonra da sürmesinin nedeni budur.

9.6.6Kod izleme: invokeLater ve invokeAndWait

public static void main(String[] a) throws Exception {
  System.out.println("1 main");
  SwingUtilities.invokeLater(
      () -> System.out.println("3 iş A"));
  SwingUtilities.invokeLater(
      () -> System.out.println("4 iş B"));
  System.out.println("2 main devam ediyor");
  SwingUtilities.invokeAndWait(() -> System.out.println(
      "5 iş C, EDT mi? " + SwingUtilities.isEventDispatchThread()));
  System.out.println("6 main, EDT mi? "
      + SwingUtilities.isEventDispatchThread());
}

1 main
2 main devam ediyor
3 iş A
4 iş B
5 iş C, EDT mi? true
6 main, EDT mi? false

Program main iş parçacığında başlar ve 1 main yazar. 2. adımda invokeLater iş A'yı kuyruğa koyar ve hemen döner. Olay iş parçacığı henüz yoksa bu ilk çağrı onu başlatır. 3. adımda iş B de kuyruğa eklenir; main yine beklemez. 4. adımda main kendi işine devam eder ve 2 main devam ediyor yazar.

5. adımda invokeAndWait iş C'yi kuyruğa koyar ve main'i durdurur. EDT kuyruğu baştan işler: önce A (3 iş A), sonra B (4 iş B), sonra C. Kuyruk sıralıdır; işler kuyruğa giriş sırasıyla çalışır. İş C, isEventDispatchThread() ile kendi iş parçacığını sorar ve true alır. C bitince bekleyen main uyandırılır. Son satırda main aynı soruyu sorar ve false alır.

Çıktının sırası hakkında dikkatli olmak gerekir. 1, 2, 3, 4, 5, 6 sırası bu çalıştırmada görüldü. Program 20 kez çalıştırıldığında da sıra her seferinde aynı çıktı. Ama sıranın bir kısmı garanti değildir. 2 main devam ediyor satırı ile 3 iş A satırı farklı iş parçacıklarından gelir. EDT, main 2. satırı yazmadan önce A'yı çalıştırabilirdi. Kesin olan şunlardır: A, B'den önce; B, C'den önce; C, 6'dan önce çalışır. Aynı ayrım invokeLater(B), println(A), invokeAndWait(C), println(D) dizisinde de geçerlidir. B, C'den ve C, D'den önce gelir. 20 denemede hep ABCD görüldü, ama A ile B'nin yeri çalıştırmaya göre değişebilir.

9.7Uygulama: çizim programı

Bu uygulama, fareyle basılı tutup sürükleyerek çizim yapılan bir programdır. Çalışma ilkesi üç cümleyle özetlenir:

• Basınca (mousePressed) yeni bir eğri başlar.
• Sürükledikçe (mouseDragged) eğrinin sonuna nokta eklenir ve yeniden çizim istenir.
• Çizerken (paintComponent) her eğrinin ardışık noktaları çizgilerle birleştirilir.

Programın temel tasarım kararı, çizimi bir resim olarak değil, noktaların listesi olarak saklamaktır. Ekran her seferinde bu veriden yeniden çizilir. Pencere küçültülüp büyütülse de, üstüne başka bir pencere gelip çekilse de çizim kaybolmaz. Veri ile görüntünün ayrılması, olay döngüsünün kuralını uygular: dinleyiciler veriyi değiştirir, paintComponent veriyi çizer.

9.7.1Eğrileri saklamak

public class BasitCizimPaneli extends JPanel {
    private List<List<Point>> egriler = new ArrayList<>();

    public BasitCizimPaneli() {
        addMouseListener(new MouseAdapter() {
            @Override
            public void mousePressed(MouseEvent e) {
                var yeniEgri = new ArrayList<Point>();
                yeniEgri.add(new Point(e.getX(), e.getY()));
                egriler.add(yeniEgri);
            }
        });
        addMouseMotionListener(new MouseMotionAdapter() {
            @Override
            public void mouseDragged(MouseEvent e) {
                egriler.get(egriler.size() - 1)
                       .add(new Point(e.getX(), e.getY()));
                repaint(0, 0, getWidth(), getHeight());
            }
        });
    }
}

Sınıfın tek alanı egriler'dir. Tipi List<List<Point>>, yani listelerin listesidir. Dış liste eğrileri tutar. Her iç liste bir eğrinin noktalarını sırayla tutar.

Yapıcı iki dinleyici kaydeder. Birincisi MouseAdapter'dan türeyen anonim bir sınıftır ve yalnız mousePressed'ı yazar. Metot yeni ve boş bir nokta listesi oluşturur, basılan noktayı listeye ekler ve listeyi dış listeye koyar. İkinci dinleyici MouseMotionAdapter'dan türer ve yalnız mouseDragged'ı yazar. Metot dış listenin son öğesini, yani en son başlayan eğriyi alır ve sonuna yeni noktayı ekler. Ardından paneli yeniden çizdirir.

Son eğriye egriler.get(egriler.size() - 1) ile ulaşılır. Liste indisleri 0'dan başladığı için son öğenin indisi size() - 1'dir. get(size()) her zaman listenin bir ötesini ister.

java.lang.IndexOutOfBoundsException: Index 1 out of bounds for length 1

Kodun bir de içe aktarma tuzağı vardır. java.awt.* ve java.util.* birlikte içe aktarılırsa List adı iki pakette birden bulunur: java.awt.List bir liste kutusu bileşeni, java.util.List ise koleksiyon arayüzüdür. Derleyici hangisinin kastedildiğini bilemez:

Ana.java:4: error: reference to List is ambiguous
  List<String> x;
  both interface java.util.List in java.util and class java.awt.List in java.awt match

Çözüm, kastedilen sınıfı ayrıca açıkça içe aktarmaktır: import java.util.List;. Tek tip içe aktarma, yıldızlı içe aktarmadan önceliklidir.

9.7.2Kod izleme: fare olayları

Kullanıcı şu hareketleri yapsın: (40, 120)'de basar, (60, 60) ve (80, 120)'ye sürükler, bırakır; sonra (50, 95)'te yeniden basar ve (70, 95)'e sürükler.

addMouseListener(new MouseAdapter() {
    @Override
    public void mousePressed(MouseEvent e) {
        var yeniEgri = new ArrayList<Point>();
        yeniEgri.add(new Point(e.getX(), e.getY()));
        egriler.add(yeniEgri);
    }
});
addMouseMotionListener(new MouseMotionAdapter() {
    @Override
    public void mouseDragged(MouseEvent e) {
        egriler.get(egriler.size() - 1)
               .add(new Point(e.getX(), e.getY()));
        repaint(0, 0, getWidth(), getHeight());
    }
});

1. adımda dış liste boştur. mousePressed yeni bir iç liste oluşturur, (40, 120)'yi ekler ve iç listeyi dış listeye koyar: egriler.size() 1 olur. 2. ve 3. adımlarda mouseDragged iki nokta ekler. İkisi de son eğriye, yani eğri 0'a gider. Her eklemeden sonra repaint yeniden çizim ister ve yeni çizgi parçası ekranda görünür.

Gerçek kullanımda olay sayısı çok daha fazladır. Fare hareket ettikçe işletim sistemi saniyede onlarca konum bildirir ve her biri bir mouseDragged olur. İzlemedeki iki sürükleme, bu akışın iki örneğidir.

4. adımda kullanıcı fareyi bırakır. mouseReleased'ı yazmadık. Olay yine gelir, ama MouseAdapter'ın boş gövdesi çalışır ve hiçbir şey olmaz. 5. adımda yeni bir basma ikinci bir iç liste başlatır; eski eğri olduğu gibi kalır. 6. adımdaki sürükleme yine son eğriye, artık eğri 1'e eklenir.

Olay dizisi başsız kipte panele doğrudan gönderilerek denendi. Her adımdan sonra yazılan veri, tablonun son durumunu verdi: [[(40,120), (60,60), (80,120)], [(50,95), (70,95)]].

9.7.3Kod izleme: eğrileri çizmek

@Override
public void paintComponent(Graphics g) {
    super.paintComponent(g);
    for (var egri : egriler) {
        var onceki = egri.get(0);
        for (var nokta : egri) {
            g.drawLine(onceki.x, onceki.y, nokta.x, nokta.y);
            onceki = nokta;
        }
    }
}

Metot iç içe iki döngü kullanır. Dış döngü eğrileri, iç döngü bir eğrinin noktalarını dolaşır. onceki değişkeni, çizginin başlayacağı noktayı tutar. Her eğrinin başında onceki o eğrinin ilk noktasına ayarlanır. İç döngü her noktada onceki'den o noktaya bir çizgi çizer ve onceki'yi ilerletir.

3. adımda bir ayrıntı göze çarpar. İç döngü ilk noktadan başlar ve onceki de ilk noktadır. İlk çağrı drawLine(40, 120, 40, 120) olur: nokta kendisiyle birleşir ve tek bir piksel çizilir. Ardından onceki = nokta yapılır. 4. ve 5. adımlar gerçek çizgileri çizer: (40,120) → (60,60) ve (60,60) → (80,120).

6. adımda dış döngü ikinci eğriye geçer ve onceki yeniden bu eğrinin ilk noktası olur. İki eğrinin birleşmemesi bu satırın işidir. onceki her eğride sıfırlanmasaydı, eğri 0'ın son noktası (80, 120) ile eğri 1'in ilk noktası (50, 95) arasında istenmeyen bir çizgi çizilirdi. Toplam çağrı sayısı 3 + 2 = 5'tir; görünen çizgi parçası ise 2 + 1 = 3'tür.

DebugGraphics kaydı da aynı beş çağrıyı verdi:

setColor(238, 238, 238)
fillRect(0, 0, 200, 200)
drawLine(40, 120, 40, 120)
drawLine(40, 120, 60, 60)
drawLine(60, 60, 80, 120)
drawLine(50, 95, 50, 95)
drawLine(50, 95, 70, 95)

İlk iki satırı yine super.paintComponent(g) üretti: zemin, panelin arka plan rengiyle temizlendi. Önceki çizimden iz kalmaz. Yeni görüntü her seferinde boş bir zeminden, verinin tamamından kurulur.

setColor(238, 238, 238)
fillRect(0, 0, 200, 200)
drawLine(10, 10, 10, 10)
drawLine(10, 10, 20, 10)
drawLine(20, 10, 30, 20)
drawLine(5, 5, 5, 5)
drawLine(5, 5, 6, 6)

9.7.4main ve repaint

public static void main(String[] args) {
    SwingUtilities.invokeLater(() -> {
        var frame = new JFrame("Basit Çizim Programı");
        frame.getContentPane().add(new BasitCizimPaneli(),
                BorderLayout.CENTER);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(400, 300);
        frame.setVisible(true);
    });
}

main bilinen kalıbı izler: arayüz invokeLater ile EDT'de kurulur, panel içerik bölmesinin merkezine eklenir, pencere 400 × 300 boyutunda gösterilir.

repaint metodu iki biçimde kullanılır ve ikisi de bir istektir:

• repaint() çizimi hemen yapmaz; kuyruğa bir “yeniden boya” isteği koyar. Art arda gelen istekler tek bir boyamada birleştirilebilir. Fare saniyede onlarca olay üretirken bu birleştirme gereksiz çizimleri önler.
• repaint(x, y, en, boy) yalnız o dikdörtgenin yeniden çizilmesini ister. Swing bu bölgenin dışını kırpar (clipping): g bölgenin dışına boyamaz ve iş azalır. repaint(0, 0, getWidth(), getHeight()), repaint() ile aynıdır.

9.8Düğme ve metin bileşenleri

9.8.1JButton sınıfı

JButton, tıklanabilir düğmeler oluşturur. Metni setText(), ikonu setIcon() ile belirlenir. setEnabled(false) düğmeyi pasif yapar: düğme soluk görünür ve tıklanınca olay üretmez.

Düğmenin tıklanmasına yanıt vermek için addActionListener() ile bir dinleyici eklenir. Dinleyici ActionListener arayüzünü uygular. Bu arayüzün tek metodu vardır: actionPerformed(ActionEvent e). Düğme, klavyeden boşluk tuşuyla da tetiklenebilir; iki durumda da aynı metot çağrılır. Bu yüzden düğme için fare olayı değil, “eylem” olayı dinlenir.

Dinleyici eklemek, Gözlemci (Observer) tasarım deseninin bir örneğidir. Düğme “konu”dur; kendisine kayıtlı gözlemcilerin listesini tutar. Bir tıklama olunca listedeki her gözlemciye haber verir. Düğme, gözlemcilerin ne yaptığını bilmez. Yeni bir davranış eklemek için düğmenin koduna dokunmak gerekmez; yalnız yeni bir gözlemci kaydedilir.

class SayacPaneli extends JPanel {
    private int sayac = 0;
    private JLabel etiket = new JLabel("Henüz tıklanmadı");

    SayacPaneli() {
        JButton dugme = new JButton("Tıkla");
        dugme.addActionListener(e -> {
            sayac++;
            etiket.setText(sayac + " kez tıklandı");
        });
        add(dugme);
        add(etiket);
    }
}

9.8.2Kod izleme: sayaç düğmesi

1. adımda new SayacPaneli() çalışmaya başlar. Yapıcının gövdesinden önce alanlara ilk değerleri verilir: sayac 0 olur, etiket “Henüz tıklanmadı” metniyle oluşturulur. 2. adımda yapıcı bir düğme oluşturur. dugme yerel bir değişkendir; yapıcı bitince değişken kaybolur, ama düğme panelin bileşeni olarak yaşamaya devam eder.

3. adım izlemenin en önemli adımıdır. Lambda ifadesi bu anda çalıştırılmaz. Yalnız bir nesne olarak düğmeye kaydedilir. Gövdesindeki sayac++ ve setText ancak tıklanınca çalışacaktır. 4. adımda düğme ve etiket panele eklenir. FlowLayout onları yan yana dizer. Yapıcı biter; panelin bileşen sayısı 2, düğmenin dinleyici sayısı 1'dir.

5. adımda kullanıcı tıklar. EDT actionPerformed'ı, yani lambda gövdesini çağırır. sayac bir alan olduğu için artırılabilir: 1 olur. 6. adımda setText etiketin metnini “1 kez tıklandı” yapar ve Swing etiketi yeniden boyar. 7. ve 8. adımlar ikinci tıklamadır: aynı lambda yeniden çağrılır, alan 2 olur, etiket güncellenir.

Tıklamalar arasında program hiçbir kod çalıştırmaz; yalnız olay bekler. Bu davranış, konsol programının sürekli çalışan akışından çok farklıdır. Başsız kipte panel oluşturulup düğmenin doClick metoduyla iki tıklama verildiğinde etiket “1 kez tıklandı” ve “2 kez tıklandı” oldu. Düğme setEnabled(false) ile pasif yapılıp yeniden tıklandığında etiket değişmedi.

2 1 Henüz tıklanmadı
1 kez tıklandı
2 kez tıklandı
pasif: 2 kez tıklandı

9.8.3Anonim sınıf ve lambda

Aynı dinleyici iki biçimde yazılabilir. Klasik yazım anonim iç sınıftır:

dugme.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        sayac++;
        etiket.setText("Sayı: " + sayac);
    }
});

Java 8'den beri aynı iş bir lambda ifadesiyle yazılır:

dugme.addActionListener(e -> {
    sayac++;
    etiket.setText("Sayı: " + sayac);
});

// tek ifade ise süslü parantez gerekmez:
dugme.addActionListener(e -> System.exit(0));

Lambdanın kullanılabilmesinin nedeni ActionListener'ın yapısıdır. Arayüzün yalnız bir soyut metodu vardır.

Derleyici addActionListener'ın parametre tipine bakar, ActionListener'ı görür ve tek metodunu bulur. Lambdanın parametresi e, o metodun ActionEvent parametresi olur. Gövde tek bir ifadeyse süslü parantez de gerekmez: dugme.addActionListener(e -> System.exit(0));.

MouseListener'ın beş metodu olduğu için lambda ile yazılamaz. Derleyici hangi metodun gövdesinin yazıldığını bilemez:

Ana.java:9: error: incompatible types: MouseListener is not a functional interface
  p.addMouseListener(e -> System.out.println("tık"));
    multiple non-overriding abstract methods found in interface MouseListener

Fare olayları için bu yüzden adaptör sınıfı kullanılır.

Lambdanın bir sınırı daha vardır: içinden yerel değişken değiştirilemez. Lambda, kullandığı yerel değişkenin değerini yakalar (kopyalar); değişkenin kendisine bağlanmaz. Bu yüzden yerel değişken final ya da “fiilen final” olmalıdır, yani tanımlandıktan sonra hiç değiştirilmemelidir.

Ana.java:10: error: local variables referenced from a lambda expression must be final or effectively final
  d.addActionListener(e -> sayac++);

9.8.4JLabel ve JTextField

JLabel bir etikettir. Metin ya da resim gösterir; kullanıcı onu değiştiremez. setText() metni, setIcon() resmi, setFont() yazı tipini, setForeground() metin rengini belirler.

JTextField tek satırlık metin alanıdır. Kullanıcının metin girmesi içindir; formlardan veri bu yolla toplanır. getText() ve setText() alanı okur ve yazar. setColumns() görünen sütun sayısını belirler. Bu sayı alanın tercih ettiği genişliği etkiler, alabileceği metnin uzunluğunu sınırlamaz. Başsız kipte 12 sütunluk alan 136, 24 sütunluk alan 268 piksel genişlik istedi. addActionListener() ile eklenen dinleyici, kullanıcı alanda Enter'a basınca çalışır.

JLabel etiket = new JLabel("Adınız:");
etiket.setFont(new Font("SansSerif", Font.BOLD, 14));
etiket.setForeground(Color.BLUE);
JTextField adAlani = new JTextField(12);
JLabel selam = new JLabel(" ");
adAlani.addActionListener(e -> selam.setText(
        "Merhaba, " + adAlani.getText() + "!"));

Kod iki etiket ve bir metin alanı oluşturur. Birinci etiket kalın, 14 puntoluk ve mavidir. Metin alanı 12 sütun genişliğindedir. İkinci etiket başta bir boşluk içerir: boş metinli bir etiketin tercih ettiği boyut 0 × 0'dır. Tek boşluklu etiket ise 3 × 16 piksel yer tutar ve selamın satırını baştan ayırır. Dinleyici, Enter'a basılınca alandaki metni okur ve selam etiketine yazar. Başsız kipte alana “Ayşe” yazılıp Enter olayı üretildiğinde selam etiketi Merhaba, Ayşe! oldu.

Lambda içinde adAlani ve selam yerel değişkenleri kullanılır. Bu değişkenler tanımlandıktan sonra değiştirilmediği için fiilen finaldir ve lambda onları yakalayabilir. Değişkenin gösterdiği nesnenin içeriği değişebilir; selam.setText(…) buna örnektir. Kural yalnız değişkenin başka bir nesneye yönlendirilmesini yasaklar.

9.8.5JTextArea ve JScrollPane

JTextArea çok satırlı metin alanıdır. İçeriği okunabilir, atanabilir ve güncellenebilir. new JTextArea(satır, sütun) ile görünür boyut önceden verilir. Sık kullanılan metotları şunlardır: getText(), setText(), append() (sona ekler), setEditable(false) (salt okunur yapar) ve setLineWrap(true) (uzun satırları kaydırır).

JScrollPane bir kaydırma bölmesidir. İçine konan bileşen (metin alanı, tablo, resim) ekrana sığmadığında kaydırma çubukları ekler. İçeriğin boyutu değişince kendini uyarlar. setPreferredSize() ile kendi boyutu, setViewportView() ile içeriği değiştirilir. Metin alanı kaydırma bölmesine yapıcıda verilir ve pencereye metin alanı değil, kaydırma bölmesi eklenir.

JTextArea alan = new JTextArea(5, 20);
alan.setText("Birinci satır\n");
alan.append("İkinci satır\n");
JScrollPane kaydirma = new JScrollPane(alan);
System.out.print(alan.getText());
System.out.println(alan.getLineCount());

Birinci satır
İkinci satır
3

setText eski içeriği siler ve yenisini yazar; append sona ekler. Metin "Birinci satır\nİkinci satır\n" olur. getLineCount() satır sonu sayısının bir fazlasını döndürür: metinde iki satır sonu vardır, sonuç 3'tür. Üçüncü satır boştur, ama imleç oraya konabildiği için sayılır. Boş bir metin alanında bile getLineCount() 1'dir.

JTextArea a = new JTextArea("x");
a.append("\ny");
a.append("\n");
System.out.println(a.getLineCount());
a.setText("tek");
a.append(" satır");
System.out.println(a.getText() + " " + a.getLineCount());
JTextField f = new JTextField(10);
f.setText(" 42 ");
System.out.println(Integer.parseInt(f.getText().trim()) + 1);

3
tek satır 1
43

9.9Uygulama: metin dönüştürücü

Bu uygulama, bir metin alanındaki metni iki düğmeyle küçük ya da büyük harfe çevirir. Pencerenin düzeni iki yerleşim yöneticisinin birlikte kullanımına iyi bir örnektir:

• Ortada (CENTER) bir JScrollPane içinde 8 satır × 50 sütunluk bir JTextArea vardır.
• Altta (SOUTH) iki düğmeyi taşıyan bir JPanel vardır. Panel FlowLayout kullandığı için düğmeler ortalı ve yan yanadır.
• pack() pencere boyutunu bu bileşenlerin tercih ettiği boyuttan hesaplar.
• Düğmeler metni toLowerCase() ya da toUpperCase() ile dönüştürür ve alana geri yazar.

import java.awt.BorderLayout;
import javax.swing.*;

public class BuyukHarfeCevirici {
    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> {
            var alan = new JTextArea("Java Programlama", 8, 50);
            var kucukHarfButton = new JButton("Küçük Harfe Çevir");
            var buyukHarfButton = new JButton("Büyük Harfe Çevir");
            kucukHarfButton.addActionListener(e ->
                    alan.setText(alan.getText().toLowerCase()));
            buyukHarfButton.addActionListener(e ->
                    alan.setText(alan.getText().toUpperCase()));
            var panel = new JPanel();
            panel.add(kucukHarfButton);
            panel.add(buyukHarfButton);
            var frame = new JFrame("BuyukHarfeCevirici");
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            frame.getContentPane().add(new JScrollPane(alan),
                    BorderLayout.CENTER);
            frame.getContentPane().add(panel, BorderLayout.SOUTH);
            frame.pack();
            frame.setVisible(true);
        });
    }
}

Bütün arayüz tek bir lambda içinde, EDT'de kurulur. Önce metin alanı ve iki düğme oluşturulur. Her düğmeye bir dinleyici eklenir. Dinleyici alanın metnini okur, dönüştürür ve sonucu alana geri yazar. Sonra düğmeler bir panele konur. Pencere oluşturulur, kaydırma bölmesi merkeze, düğme paneli güneye eklenir. pack() boyutu hesaplar ve pencere gösterilir.

Kodda üç ayrıntı vardır:

• alan yerel bir değişkendir, ama lambda içinde kullanılabilir. Değişken tanımlandıktan sonra başka bir nesneye yönlendirilmez; fiilen finaldir. Lambda alanın kendisini değil, gösterdiği nesneyi kullanır ve o nesnenin metnini değiştirir.
• toUpperCase() yeni bir String döndürür. String değiştirilemez olduğu için asıl metin değişmez; sonucu setText ile alana geri yazmak gerekir. alan.getText().toUpperCase(); tek başına yazılsaydı ekranda hiçbir şey değişmezdi.
• BorderLayout.CENTER tam adıyla yazılır. Yalnız CENTER yazmak derlenmez, çünkü sabit BorderLayout sınıfının içindedir.

Başsız kipte aynı iki düğme ve metin alanı oluşturulup düğmelere doClick ile basıldığında metin önce büyük, sonra küçük harfe döndü:

JAVA PROGRAMLAMA
java programlama
varsayılan yerel ayar tr_TR: İSTANBUL / ENGLISH ISTANBUL / tr İSTANBUL

9.9.1Bir tıklamada neler olur?

Kullanıcının “Büyük Harfe Çevir” düğmesine tıklamasıyla ekranda metnin değişmesi arasında altı adım vardır.

1. Kullanıcı düğmeye tıklar; işletim sistemi bunu Java'ya iletir.
2. Java bir olay nesnesi oluşturur ve olay kuyruğuna koyar.
3. EDT sıradaki olayı alır. Düğme, kayıtlı bütün ActionListener'ların actionPerformed'ını çağırır: lambdamız çalışır.
4. alan.getText() mevcut metni okur.
5. toUpperCase() yeni bir dizgi üretir; eski dizgi değişmez.
6. setText alanın modelini günceller. Alan kendini repaint ile yeniden çizdirir. EDT sıradaki olaya geçer.

6. adımda “model” sözcüğü geçer. Swing'de metin bileşenleri iki parçadan oluşur: metni tutan bir model ve onu ekranda gösteren bir görünüm. setText modeli değiştirir; görünüm bu değişikliği fark eder ve kendini yeniden çizdirir. Para üstü uygulaması bu ayrımı doğrudan kullanır.

9.9.2Büyük harf ve yerel ayar

toUpperCase() ve toLowerCase() parametresiz çağrılırsa bilgisayarın yerel ayarını (locale) kullanır. Türkçe, harf dönüşümünde özel kuralları olan dillerden biridir: noktalı ve noktasız iki ayrı “i” vardır. İngilizce ayarlı bir makinede "istanbul".toUpperCase() sonucu "ISTANBUL", Türkçe ayarlıda "İSTANBUL"'dur. Aynı program, çalıştığı bilgisayara göre farklı sonuç verir.

Sonucu sabitlemek için yerel ayar açıkça verilir: toUpperCase(Locale.forLanguageTag("tr")). Aşağıdaki deneme iki dilin kurallarını karşılaştırır.

String s = "Kış İzmir";
Locale tr = Locale.forLanguageTag("tr");
System.out.println(s.toUpperCase(tr));
System.out.println(s.toLowerCase(tr));
System.out.println(s.toUpperCase(Locale.ENGLISH));
System.out.println(s);

KIŞ İZMİR
kış izmir
KIŞ İZMIR
Kış İzmir

Türkçe kurallarında i → İ, ı → I, İ → i ve I → ı'dır. İngilizce kurallarında hem ı hem i büyüyünce I olur; İ ise olduğu gibi kalır. Bu yüzden üçüncü satır KIŞ İZMIR'dir. Son satır, dizgilerin değiştirilemezliğini bir kez daha gösterir: üç dönüşümden sonra s hâlâ "Kış İzmir"'dir.

Yerel ayar nesnesi eskiden new Locale("tr") ile oluşturulurdu. Bu yapıcı Java 19'dan beri kullanımdan kaldırılmıştır (deprecated); derleyici uyarı verir. Yerine Locale.forLanguageTag("tr") ya da Locale.of("tr") kullanılır.

9.10Uygulama: para üstü hesaplayıcı

Bu uygulama, girilen kuruş miktarının en az sayıda madeni parayla (50, 25, 10, 5 ve 1 kuruş) nasıl ödeneceğini gösterir. Pencerede düğme yoktur: rapor her tuş vuruşunda kendiliğinden güncellenir. Bunu metin alanının belgesine eklenen bir DocumentListener sağlar.

9.10.1Alanlar ve yapıcı

public class ParaUstuHesaplama extends JFrame {
    private JTextField miktarAlani = new JTextField(12);
    private Document metin = miktarAlani.getDocument();
    private JTextArea rapor = new JTextArea(8, 40);

    public ParaUstuHesaplama() {
        var ustPanel = new JPanel();
        ustPanel.add(new JLabel("Miktar:"));
        ustPanel.add(miktarAlani);
        getContentPane().add(ustPanel, BorderLayout.NORTH);
        getContentPane().add(new JScrollPane(rapor),
                BorderLayout.CENTER);
        setBackground(Color.LIGHT_GRAY);
        rapor.setEditable(false);
        metin.addDocumentListener(new DocumentListener() {
            public void insertUpdate(DocumentEvent e) { raporuGuncelle(); }
            public void removeUpdate(DocumentEvent e) { raporuGuncelle(); }
            public void changedUpdate(DocumentEvent e) { raporuGuncelle(); }
        });
    }

Sınıf bu kez JPanel'den değil, JFrame'den türer. Pencerenin kendisi uygulamadır. Üç alan vardır: 12 sütunluk bir miktar alanı, bu alanın belgesi ve 8 satır × 40 sütunluk bir rapor alanı.

Swing'de veri ile görünüm ayrıdır. Bu düzene Model-Görünüm-Denetleyici (Model-View-Controller, MVC) denir. JTextField görünümdür: metni ekranda gösterir ve kullanıcının yazdıklarını alır. getDocument() ile alınan Document nesnesi ise metni tutan modeldir. Kullanıcı bir tuşa bastığında model değişir ve modeli dinleyen herkese haber verilir.

Yapıcı üst paneli kurar: bir “Miktar:” etiketi ve miktar alanı. Panel pencerenin kuzeyine, rapor alanı bir kaydırma bölmesiyle merkeze eklenir. Rapor salt okunur yapılır. Son olarak belgeye anonim bir DocumentListener eklenir.

DocumentListener'ın üç metodu vardır: insertUpdate (metin eklendi), removeUpdate (metin silindi) ve changedUpdate (stil değişti). Düz metin alanında stil olmadığı için changedUpdate hiç çağrılmaz. Ama arayüzün üç metodu da soyuttur ve üçü de yazılmalıdır. Üçü de aynı işi yapar: raporuGuncelle()'yi çağırır.

9.10.2Kod izleme: raporuGuncelle

void raporuGuncelle() {
    try {
        var miktar = Integer.parseInt(
                metin.getText(0, metin.getLength()));
        int[] dizi = {50, 25, 10, 5, 1};
        rapor.setText(miktar
                + " kuruş yapmak için kullanılacaklar:\n");
        for (int x : dizi) {
            rapor.append(miktar / x + " " + x + " kuruş\n");
            miktar %= x;
        }
    } catch (NumberFormatException e) {
        rapor.setText("Tam sayı değil veya aralık dışında");
    } catch (Exception e) {
        rapor.setText(e.toString());
    }
}

Metot belgenin metnini okur ve tam sayıya çevirir. metin.getText(0, metin.getLength()) belgenin 0. karakterinden başlayıp bütün uzunluğu kadar metni döndürür. Ardından para değerleri büyükten küçüğe bir diziye konur. Rapor setText ile sıfırdan başlatılır. Döngü her para değeri için iki iş yapar: kaç adet kullanılacağını (miktar / x) yazar ve kalan miktarı (miktar %= x) hesaplar.

Yöntem, açgözlü (greedy) bir algoritmadır: her adımda kullanılabilecek en büyük para seçilir. 93 kuruşta önce bir 50'lik kullanılır, 43 kalır. Sonra bir 25'lik, 18 kalır. Bir 10'luk, 8 kalır. Bir 5'lik, 3 kalır. Son olarak üç 1'lik. Toplam yedi madeni para. Tam sayı bölmesi adet hesabını, kalan işleci de kalan miktarı verir.

50, 25, 10, 5, 1 dizisi için açgözlü yöntem her zaman en az sayıda parayı verir. Bu her para sistemi için doğru değildir. Örneğin paralar 1, 3 ve 4 olsaydı, 6 için açgözlü yöntem 4 + 1 + 1 (üç para) seçerdi. Oysa 3 + 3 iki parayla aynı tutarı verir.

187 kuruş yapmak için kullanılacaklar:
3 50 kuruş
1 25 kuruş
1 10 kuruş
0 5 kuruş
2 1 kuruş

9.10.3main ve olayların sırası

public static void main(String[] args) {
    SwingUtilities.invokeLater(() -> {
        var frame = new ParaUstuHesaplama();
        frame.setTitle("Para Üstü Hesaplama");
        frame.pack();
        frame.setDefaultCloseOperation(
                JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    });
}

main pencereyi EDT'de oluşturur, başlığını verir, pack() ile boyutunu hesaplar ve gösterir. Programın asıl ilginç yanı, kullanıcının yazdıklarına göre hangi olayların geldiğidir. JFrame başsız kipte oluşturulamadığı için aynı alanlar, dinleyici ve raporuGuncelle metodu pencere olmadan bir sınıfta denendi; belgeye ekleme ve silme doğrudan yapıldı. Gelen olaylar şunlardır:

9 yazar              insert
3 yazar              insert
hepsini siler        remove
abc                  insert
99999999999          remove insert
setText 287          remove insert
setText boş          remove
boştan setText 287   insert
-7                   remove insert
68                   remove insert
187                  remove insert
boşluklu             remove insert

Tablodaki her satır bir dersi taşır. Kullanıcı “93” yazarken iki olay gelir: “9” ve “3” için birer insertUpdate. Rapor her tuşta güncellenir; ara durum (9 kuruş) da bir an için görünür. Alan tamamen silinince metin boş dizgidir ve parseInt("") NumberFormatException fırlatır. İlk catch bunu yakalar.

99999999999 bir sayıdır, ama int'in en büyük değeri olan 2 147 483 647'yi aşar. parseInt bu durumda da NumberFormatException fırlatır; ileti bu yüzden “tam sayı değil veya aralık dışında” der. setText ise bir bütün olarak değil, iki adımda çalışır: önce eski metni siler, sonra yenisini ekler. Alan doluysa iki olay gelir. Birinci olayda alan bir an boştur ve rapor hata iletisini gösterir; ikinci olay doğru raporu yazar.

Negatif sayı ise bir eksikliği ortaya çıkarır. -7 geçerli bir tam sayıdır. Java'da tam sayı bölmesi sıfıra doğru keser ve kalanın işareti bölünenin işaretini alır: -7 / 5 = -1, -7 % 5 = -2. Rapor -1 5 kuruş ve -2 1 kuruş gibi anlamsız satırlar içerir:

-7 kuruş yapmak için kullanılacaklar:
0 50 kuruş
0 25 kuruş
0 10 kuruş
-1 5 kuruş
-2 1 kuruş

Program negatif değeri reddetmelidir. parseInt'ten hemen sonra bir denetim yeterlidir: if (miktar < 0) { rapor.setText("Miktar pozitif olmalı"); return; }.

İki catch bloğunun görevleri farklıdır. İlki beklenen hatayı, yani sayı olmayan metni ve int sınırını aşan değeri yakalar. İkincisi diğer her şey için genel bir güvencedir. Bu blok gereklidir, çünkü getText(0, n) kontrol edilen bir istisna olan BadLocationException'ı fırlatabileceğini bildirir. Derleyici bu istisnanın ele alınmasını ister; catch (Exception e) onu da kapsar.

68 kuruş yapmak için kullanılacaklar:
1 50 kuruş
0 25 kuruş
1 10 kuruş
1 5 kuruş
3 1 kuruş

9.11İyi uygulamalar

GUI programlarının kalitesini birkaç alışkanlık belirler.

Yerleşim yöneticisi kullanmak

Koordinatlar elle verilmez. Yerleşim yöneticisiyle düzen farklı ekran boyutu, çözünürlük ve yazı tipinde bozulmaz. Karmaşık düzenler iç içe panellerle kurulur.

Anlamlı adlar seçmek

b1, t2 yerine buyukHarfButton, miktarAlani gibi adlar kullanılır. Onlarca bileşenli bir arayüzde kod ancak böyle okunur kalır.

Olay güdümlü düşünmek

Tasarım “Kullanıcı şunu yapınca ne olmalı?” sorusuyla yapılır. Her eylem için bir dinleyici yazılır; dinleyiciler birbirinin sırasına güvenmez.

Arayüz ile iş mantığını ayırmak

Para üstü hesabı gibi kurallar ayrı bir metotta ya da sınıfta tutulur. Böylece arayüz olmadan test edilebilir ve başka bir arayüzde de kullanılabilir. Notta verilen çıktıların çoğu bu ayrım sayesinde pencere açılmadan elde edildi.

Arayüzü EDT'de kurmak

main'in içi tek bir çağrıdır: SwingUtilities.invokeLater(() -> { … }).

EDT'yi meşgul etmemek

Dinleyicide uzun bir iş (dosya indirme, büyük bir hesap) yapılırsa EDT o süre boyunca başka olay işleyemez ve pencere donar. Bu işler ayrı bir iş parçacığına taşınır; sonuç invokeLater ile EDT'ye geri verilir.

static int[] paraUstu(int miktar) {
    int[] dizi = {50, 25, 10, 5, 1};
    int[] adet = new int[dizi.length];
    for (int i = 0; i < dizi.length; i++) {
        adet[i] = miktar / dizi[i];
        miktar %= dizi[i];
    }
    return adet;
}

9.12Çözümlü problemler

int cx = getWidth() / 2, cy = getHeight() / 2;
int r = Math.min(cx, cy) - 5;
for (int i = 0; i < 5; i++) {
    int ri = r - i * r / 5;
    g.setColor(i % 2 == 0 ? Color.RED : Color.WHITE);
    g.fillOval(cx - ri, cy - ri, 2 * ri, 2 * ri);
}

if (e.getButton() == MouseEvent.BUTTON3) {
    if (!egriler.isEmpty()) egriler.remove(egriler.size() - 1);
    repaint();
    return;
}

cevir.addActionListener(e -> {
    try {
        double c = Double.parseDouble(alan.getText());
        sonuc.setText(c * 9 / 5 + 32 + " °F");
    } catch (NumberFormatException ex) {
        sonuc.setText("Sayı değil");
    }
});

Daha küçük iki alıştırma da aynı kalıpları kullanır. Sayaç penceresinde “−1”, “+1” ve “Sıfırla” düğmeleri bir private static int sayac alanını değiştirir ve etiketi günceller. İki “+1” ve bir “−1” tıklamasından sonra etiket 1, “Sıfırla”dan sonra 0 gösterir. Çizim programına “Temizle” düğmesi eklemek için düğme dinleyicisi egriler.clear(); repaint(); çalıştırır. Panel ve düğme pencerenin CENTER ve SOUTH bölgelerine konur.

9.13Sık yapılan hatalar

Grafik programlarında hataların bir kısmı derleyiciden gelir, bir kısmı ise programın sessizce yanlış davranmasıyla ortaya çıkar. Derleyici iletileri JDK 21 ile alınmıştır.

İçe aktarma unutulduğunda derleyici aynı satır için iki hata verir: biri değişkenin tipi, biri new ifadesi içindir.

Ana.java:3: error: cannot find symbol
    JFrame f = new JFrame("x");
  symbol:   class JFrame
  location: class Ana
Ana.java:3: error: cannot find symbol
    JFrame f = new JFrame("x");
  symbol:   class JFrame
  location: class Ana

@Override notunun değeri en açık biçimde yanlış yazılmış metot adında görülür. Not olmadan paintcomponent (küçük c) yazan sınıf sorunsuz derlenir. Yeni bir metot tanımlanmıştır ve Swing onu hiç çağırmaz; panel boş kalır. Not eklenince derleyici hatayı hemen bulur:

Ana.java:7: error: method does not override or implement a method from a supertype
  @Override

paintComponent, JComponent'te protected olarak tanımlıdır. Geçersiz kılan metodun erişimi daraltılamaz: protected ya da public olabilir. Erişim belirteci hiç yazılmazsa metot paket erişimli olur ve derleyici reddeder:

Ana.java:7: error: paintComponent(Graphics) in Ana cannot override paintComponent(Graphics) in JComponent
  void paintComponent(Graphics g) {
  attempting to assign weaker access privileges; was protected

Sabitin sınıf adı olmadan yazılması da benzer bir iletidir:

Ana.java:9: error: cannot find symbol
  p.add(new JButton("x"), CENTER);
  symbol:   variable CENTER
  location: class Ana

9.14Özet

• GUI programı olay güdümlüdür: main yalnız arayüzü kurar; akışı kullanıcının eylemleri belirler. Kodun büyük kısmı dinleyicilerden oluşur.
• java.awt paketi Graphics, Color, Font, Point, yerleşim yöneticileri ve olay sınıflarını; javax.swing paketi adı J ile başlayan bileşenleri içerir. Swing bileşenleri Java'nın kendisi çizer.
• Ekran koordinatlarında (0, 0) bileşenin sol üst köşesidir; x sağa, y aşağı doğru büyür.
• Kalıcı çizim için JPanel'den türetilir ve paintComponent(Graphics g) geçersiz kılınır. Gövdenin ilk satırı super.paintComponent(g)'dir. Metodu Swing çağırır.
• draw… metotları çerçeve, fill… metotları içi dolu şekil çizer. Elips ve daireler sınırlayıcı dikdörtgenle verilir: merkezi (cx, cy), yarıçapı r olan daire fillOval(cx − r, cy − r, 2r, 2r)'dir. drawString'in y'si taban çizgisidir.
• Graphics nesnesi rengini ve yazı tipini hatırlar; setColor ve setFont sonraki bütün çizimleri etkiler. Sonradan çizilen şekil öncekini örter.
• JFrame üst düzey penceredir. Boyut setSize ya da pack() ile verilir, kapatma davranışı setDefaultCloseOperation(EXIT_ON_CLOSE) ile belirlenir, en son setVisible(true) çağrılır. Varsayılan kapatma davranışı HIDE_ON_CLOSE'dur.
• JPanel hem kapsayıcı hem tuvaldir; varsayılan yerleşim yöneticisi FlowLayout'tur. JFrame'in içerik bölmesi BorderLayout kullanır.
• Point'in x ve y alanları public int'tir; getX() ve getY() double döndürür. translate göreli, setLocation mutlak taşır.
• Color RGB üçlüsüyle (0–255) oluşturulur; değiştirilemezdir. darker() bileşenleri 0,7 ile çarpar, brighter() 0,7'ye böler; ikisi de sonucu tam sayıya keser ve birbirinin tam tersi değildir.
• Font(ad, stil, punto); stil sabitleri bit bayraklarıdır: BOLD | ITALIC = 3. deriveFont(float) boyutu, deriveFont(int) stili değiştirir.
• Yerleşim yöneticisi bileşenlerin konum ve boyutunu kurala göre hesaplar. add yalnız listeye ekler; yerleşim düzen hesaplanınca yapılır.
• FlowLayout satır satır, ortalı ve 5 piksel boşlukla dizer. BorderLayout beş bölgeye yerleştirir: her bölgede tek bileşen, son eklenen kazanır, merkez kalanı alır. GridLayout eşit hücrelere böler. BoxLayout tek satır ya da tek sütun kurar.
• Dinleyici arayüzü bir olayın metotlarını tanımlar; dinleyici add…Listener ile kaydedilir. MouseListener basma, bırakma, tıklama, giriş ve çıkışı; MouseMotionListener hareket ve sürüklemeyi bildirir. Kayıt arayüze göre yapılır.
• Adaptör sınıfı (MouseAdapter) bütün metotları boş gövdeyle uygular; alt sınıf yalnız gerekeni yazar. Anonim iç sınıf tek kullanımlık dinleyici için uygundur.
• Bir tıklama pressed → released → clicked üretir. MouseEvent konumu bileşene göre verir; getButton() düğmeyi (BUTTON3 sağ) söyler.
• Swing tek iş parçacıklıdır: bileşenler yalnız EDT'de kurulur ve değiştirilir. invokeLater işi kuyruğa koyar ve döner; invokeAndWait iş bitene kadar bekler ve EDT içinden çağrılırsa Error fırlatır. Kuyruk sıralıdır.
• Dinleyici ekrana çizmez; veriyi günceller ve repaint() ister. repaint() bir istektir; Swing uygun anda paintComponent'i çağırır.
• ActionListener tek metotlu, fonksiyonel bir arayüzdür ve lambda ile yazılabilir. Lambda içinden yerel değişken değiştirilemez; değişen değerler alan olur.
• JLabel metin gösterir, JTextField tek satır, JTextArea çok satır metin alır, JScrollPane kaydırır. getLineCount() satır sonu sayısının bir fazlasıdır.
• toUpperCase() yerel ayara bağlıdır; Türkçede i → İ. Sonucu sabitlemek için yerel ayar açıkça verilir.
• Metin bileşenlerinde model (Document) ile görünüm ayrıdır. DocumentListener her ekleme ve silmede çağrılır; setText dolu alanda iki olay üretir.
• İyi uygulamalar: yerleşim yöneticisi kullanmak, anlamlı adlar seçmek, iş mantığını arayüzden ayırmak, arayüzü EDT'de kurmak ve EDT'yi uzun işlerle meşgul etmemek.

9.15Kavram listesi

• grafik kullanıcı arayüzü (GUI) graphical user interface
• bileşen component
• kapsayıcı container
• yerleşim yöneticisi layout manager
• olay event
• olay dinleyici event listener
• olay iş parçacığı (EDT) Event Dispatch Thread
• iş parçacığı thread
• arka plan iş parçacığı daemon thread
• iş parçacığı güvenliği thread safety
• anonim sınıf anonymous class
• iç sınıf inner class
• lambda ifadesi lambda expression
• fonksiyonel arayüz functional interface
• geçersiz kılma method overriding
• uygulamak (arayüzü) implement (an interface)
• değiştirilemez immutable
• yerel ayar locale
• olay güdümlü programlama event-driven programming
• ekran koordinatları screen coordinates
• sınırlayıcı dikdörtgen bounding rectangle
• tuval canvas
• içerik bölmesi content pane
• adaptör sınıfı adapter class
• RGB rengi RGB color
• kırpma clipping
• model-görünüm-denetleyici Model-View-Controller (MVC)
• gözlemci deseni Observer pattern
• başsız kip headless mode

9.16Kendini Dene

1. g.drawRect(10, 20, 30, 40) ve g.fillRect(10, 20, 30, 40) çağrılarının boyadığı en sağ alttaki piksel hangisidir?

   Cevap

   drawRect için (40, 60), fillRect için (39, 59). Çerçeve, sınırlayıcı dikdörtgenin sağ ve alt kenarını da çizer ve en + 1 piksel geniş olur. Dolu dikdörtgen tam en × boy piksel boyar. İki değer de bir resim üzerinde boyalı pikseller sayılarak bulundu.

2. new Color(10, 20, 30).brighter() hangi bileşenleri verir?

   Cevap

   (14, 28, 42). Her bileşen 0,7'ye bölünüp kesilir: 10 / 0,7 = 14,28 → 14; 20 / 0,7 = 28,57 → 28; 30 / 0,7 = 42,85 → 42. Hiçbir bileşen 255'e ulaşmadığı için sınır devreye girmez.

3. 300 × 200 piksellik bir panel new BorderLayout(5, 5) kullanıyor. Kuzeye 30, güneye 20 piksel yüksekliği; batıya 60, doğuya 40 piksel genişliği tercih eden bileşenler ve merkeze bir bileşen ekleniyor. Merkez bileşeninin sınırları nedir?

   Cevap

   (65, 35, 190, 140). Merkez, batının sağından 5 piksel boşlukla başlar: x = 60 + 5. Kuzeyin altından 5 piksel boşlukla başlar: y = 30 + 5. Genişlik 300 − 60 − 40 − 2 × 5 = 190, yükseklik 200 − 30 − 20 − 2 × 5 = 140'tır. Batı ve doğu da aynı yükseklikte ve y = 35'tedir.

4. Giriş yasak işaretinin paintComponent metodu 300 × 300 piksellik bir panelde çalışıyor. r, r2, bw ve bh kaçtır?

   Cevap

   r = min(150, 150) − 5 = 145. r2 = (int) 130,5 = 130. bw = (int) (130 × 1,4) = 182. bh = (int) (130 × 0,35) = (int) 45,5 = 45. Kesme yarımı da atar; yuvarlama olsaydı 46 bulunurdu.

5. Para üstü programına 41 yazılınca rapordaki adetler nelerdir?

   Cevap

   0 × 50, 1 × 25, 1 × 10, 1 × 5, 1 × 1. 41 / 50 = 0 (kalan 41), 41 / 25 = 1 (kalan 16), 16 / 10 = 1 (kalan 6), 6 / 5 = 1 (kalan 1), 1 / 1 = 1. Toplam dört madeni para.

6. Aşağıdaki kod derlenir mi?

   String ad = " Ayşe ";
   ad = ad.trim();
   JButton b = new JButton("x");
   b.addActionListener(e -> System.out.println(ad));

   Cevap

   Derlenmez: local variables referenced from a lambda expression must be final or effectively final. Lambda ad'ı yalnız okuyor, ama ad ikinci satırda yeniden atandığı için fiilen final değildir. Çözüm, kırpılmış değeri yeni bir değişkene almaktır: String temiz = ad.trim(); ve lambda içinde temiz.

7. Yalnız mouseClicked'ı geçersiz kılan bir MouseAdapter nesnesi panele addMouseMotionListener ile kaydediliyor. Panele tıklanınca metot çalışır mı?

   Cevap

   Çalışmaz. MouseAdapter üç arayüzü birden uyguladığı için kayıt derlenir, ama panel bu nesneyi yalnız hareket dinleyicisi olarak tanır. Tıklama olayları yalnız addMouseListener ile kaydedilen dinleyicilere gider. Panele bir tıklama olayı gönderildiğinde metot 0 kez çağrıldı.

8. Metni "a\n\nb\n" olan bir JTextArea'da getLineCount() kaç döndürür?

   Cevap

   4. Metinde üç satır sonu vardır: “a”, boş satır, “b” ve son satır sonundan sonraki boş satır. Satır sayısı, satır sonu sayısının bir fazlasıdır.

9.17İleri okuma

• Oracle, The Java Tutorials, “Creating a GUI With Swing”: bileşenlerin, yerleşim yöneticilerinin ve olay dinleyicilerinin resmî ve ücretsiz anlatımıdır. “Concurrency in Swing” dersi olay iş parçacığını ayrıntılı açıklar.
• Oracle, The Java Tutorials, “Performing Custom Painting”: paintComponent, repaint ve kırpmanın nasıl birlikte çalıştığını adım adım bir örnekle gösterir.
• C. S. Horstmann, Core Java, Volume I: Fundamentals (12. baskı), Bölüm 10–11: grafik programlama, olay işleme ve Swing bileşenlerini MVC bakışıyla işler.
• E. Gamma, R. Helm, R. Johnson ve J. Vlissides, Design Patterns: Gözlemci deseninin kaynak anlatımıdır; Swing dinleyicilerinin neden böyle tasarlandığını açıklar.

9.18Kaynaklar

1. Oracle, The Java Tutorials: Creating a GUI With Swing; Performing Custom Painting; Laying Out Components Within a Container; Writing Event Listeners; Concurrency in Swing.
2. Oracle, Java SE 21 API Documentation: java.awt.Graphics, java.awt.Color, javax.swing.JFrame, javax.swing.SwingUtilities.
3. P. Deitel ve H. Deitel, Java: How to Program, 11. baskı, Pearson (çevrim içi bölümler: Swing GUI Components; Graphics and Java 2D).
4. K. Sierra, B. Bates ve T. Gee, Head First Java, 3. baskı, O'Reilly (Bölüm 14–15: GUI, Swing ve olaylar).
5. C. S. Horstmann, Core Java, Volume I: Fundamentals, 12. baskı, Pearson (Bölüm 10–11: grafik programlama, olay işleme, Swing).
6. A. B. Downey ve C. Mayfield, Think Java, 2. baskı, O'Reilly (Ek C: Graphics).
7. E. Gamma, R. Helm, R. Johnson ve J. Vlissides, Design Patterns: Elements of Reusable Object-Oriented Software, Addison-Wesley, 1994.

İlgili sayfalar: Bölüm 9 sunumu · Çalışma soruları · Swing Yerleşim Yöneticileri simülatörü · Terim sözlüğü · © Sercan Külcü. Tüm hakları saklıdır.