Grafik arayüz denilen şey aslında arka planda çalışan programların daha anlaşılır olabilmesi amacıyla, ön tarafta
kullanıcıya sunulan ortamdır. Aslında bu tür ortamlarla zaten günlük bilgisayar kullanımında sıklıkla karşılaşırsınız.
Örneğin internette gezinebilmek amacıyla kullandığımız Netscape ya da Mozilla gibi web tarayıcılar birer grafik
araryüzdür. Gerçekte bilgisayarımız web siteleriyle, arka tarafta çeşitli protokoller ve özel komutlar yardımıyla
iletişim kurar ve sayfaları alır ya da gönderir. Ancak ön planda çeşitli text alanları, düğmeler ve menüler yardımıyla
bu işlemleri daha anlaşılır şekilde yapabiliriz.
Artık masaüstü kullanılan işletim sistemlerinin tamamı grafik arayüzleri ile donatılmıştır. Bir programın giriş çıkış
bilgilerine ilişkin teknik detayların kullanıcıdan soyutlanması ve ona daha anlaşılır bir etkileşim ortamının sunulması
gerekir. Bu nedenle, yazılan programlar en son aşamada bir grafik arayüzü ile desteklenir ve böylece daha kullanışlı
hale gelir.
Java’da grafik arayüz geliştirmek önceden yazılmış birtakım sınıfların kullanılması ile sağlanır. Bu sınıflar en genel
anlamda javax.swing ve java.awt paketleri içerisinde toplanmıştır.
Öncelikli olarak bilinmesi gereken birtakım temel kavramlar incelendikten sonra sayısız grafik arayüz nesnesine
ilişkin örnekler göreceğiz. Bu örneklerin tamamında temel kavramları kullanacağız.
JFrame Kavramı:
Geliştireceğimiz tüm grafik arayüz uygulamaları (GUI) aslında JFrame sınıfından türetilmiş uygulamalar olacaktır.
JFrame sınıfı aslında işletim sisteminden en temel pencere fonksiyonlarını alacak şekilde oluşturulmuştur.
Kullandığınız işletim sistemine göre bu fonksiyonlar ve bunların ekrana getirilmesi işlemleri farklılık göstereceğinden
siz sadece JFrame sınıfını türeterek kendinizi bu farklılıktan soyutlarsınız. Zaten ilk derslerimizde de bahsettiğimiz bu
teknik nesne yönelimli program geliştirmenin avantajlarından birisi olarak karşımıza çıkmaktadır. Aşağıdaki örnekte
çok basit bir JFrame nesnesi ile grafik uygulamalarına başlayabiliriz.
import javax.swing.*;
import java.awt.*;
public class Cerceve extends JFrame {

public Cerceve() {

super(“Benim ilk uygulamam”);

this.setDefaultCloseOperation(this.EXIT_ON_CLOSE);
this.setSize(300, 400);
this.setResizable(false);
this.show();
}

public void paint(Graphics g) {

g.setColor(new Color(200, 20, 208));
g.drawString(“Merhaba “, 150, 200);
g.drawLine(0, 0, 300, 300);
g.setColor(Color.BLACK);
g.drawRect(149, 188, 50, 20);
g.setColor(Color.CYAN);
g.drawOval(30, 30, 100, 150);
g.fillOval(30, 30, 80, 120);

}
102
public static void main(String[] args) {

new Cerceve();
}
}
Yukarıdaki örnekte oldukça basit bir GUI uygulaması görmekteyiz. Daha önce de söylediğimiz gibi bu uygulama
önceden hazır olan JFrame sınıfının türetilmesi ile elde edilmektedir. Şimdi bu uygulamayı detaylı olarak ele alalım
ve örnek üzerinde temel kavramlara değinelim.
Türetilen sınıfımızın başlangıç fonksiyonu içerisinde kullandığımız “super” metodu önceden hatırlayacağımız gibi
temel sınıfın başlangıç metodunu çağırmaktadır. Bu metod kendisine gönderilen bir string ifadeyi ekranda çalışan
frame in başlığı haline getirmektedir.
JFrame Metodları:
JFrame nesnesinden türeyen bir sınıf JFrame’e ait olan hazır metodları kullanabilir. Yine uygulamamızın başlangıç
metodunda kullandığımız “setSize”, “setResizable” ve “show” metodları bu tür metodlardandır. “setSize” metodu
ekrana gelecek olan arayüzün satır ve sütün uzunluğunu oluşturur. Bu bilgiler piksel olarak metoda verilmektedir.
“setResizable” metodu ekrana gelen arayüzün fare yardımıyla genişletilip genişletilemeyeceğini belirlemek için
kullanılır. Parametre olarak verilen “false” değeri arayüzün sınırlarını sabit hale getirmektedir. En son satırda
kullanılan “show” metodu arayüzümüzün çalıştıktan sonra ekranda görünür olmasını sağlar.
32 satırda uygulamamız türünden bir nesne yarattığımızda başlangıç fonksiyonu otomatik olarak çağrılacak ve
gerekli boyut, listener ve diğer ayarlar yapıldıktan sonra show metodu sayesinde çerçevemiz ekranda görünür halde
olacaktır.
24. satırda tanıtılmış olan paint metodu çerçevemiz oluşturulurken otomatik olarak çağrılan bir metoddur. Bu metod
her zaman bir “Graphics” nesnesini parametre olarak alır. Graphics nesnesine ait olan metodlar sayesinde
uygulamamız üzerine birtakım çizimler ve yazılar yerleştirebiliriz. 26. satırdaki metod sayesinde çizilecek ya da
yazılacak bilgilerin hangi renkte olacağı belirlenir. Bu renk belirleme işlemi aslında setColor isimli metoda gönderilen
bir “Color” nesnesi ile belirlenir. Hemen o anda yarattığımız Color nesnesinin başlangıç metodunda da 3 tane tam
sayı girlmektedir. Bu sayılar sırasıyla kırmızı yeşil ve mavi bileşenlerini temsil eder. Her bileşen 0-255 arasında bir
değer alır ve istedğimiz renk bu 3 bileşenin karışımından elde edilir. 27. satırdaki “drawString” metodu ile
uygulamamız üzerine istenilen bir yazıyı yazabiliriz. drawString metoduna verilen diğer 2 parametre ise bu yazının
hangi piksellerden başlayarak yazılacağını belirler.
Swing ve AWT
Java’da GUI nesnelerinin geliştirebilmek için kullanılan paketler swing ve awt paketleridir. Aslında swing paketi
awt’den daha sonra geliştirilmiş ve nesneler swing paketi içerisinde hem artmış hem de daha küçülmüştür Yani awt
paketinin geliştirilmiş hali swing paketididir. Ancak yine de event handling mekanizmasi için awt paketi hala
kullanılmaktadır.
GUI Uygulamalarına Detaylı Bir Bakış
Önceki dersimizde hazırlamış olduğumuz “JavaGui” örneğinde, GUI üzerinde yapılan bir takım hareketlerin listener
nesneleri tarafından yakalandığından bahsetmiştik. Hatta GUI uygulamamızda pencerenin “çarpı” düğmesine
bastığımızda uygulamanın gerçek anlamda sonlanması, bu hareketin yakalanması ve bizim istediğimiz şekilde ele
alınması sonucunda mümkün olmuştu.
Listener Kavramı
GUI uygulamalarında “listener” kavramı çok önemli bir yer tutar. Bu önemi GUI uygulamalarının yazılış nedenine
bakarak rahatlıkla anlayabiliriz. Öyle ki; bir GUI uygulaması yazılmış bir programın kullanıcı tarafından daha rahat 103
kullanılabilmesi amacı ile yazılmaktadır. O halde kullanıcının hizmetine sunulan bir GUI uygulaması kullanıcının
isteklerini de algıyabilmelidir.
GUI uygulamaları, genel olarak bir takım hazır nesnelerin (Düğme, ScrollBar, Text Alanları v.b.) uygulama üzerine
yerleştirilmesi şeklinde hazırlanır. İşte bu uygulmaların ikinci kısmını da bu nesneler üzerinde yapılan hareketlerin
algılanması oluşturur.
Aşağıdaki örneğimizde basit bir GUI çerçevesi üzerinde bir Jbutton nesnesi eklenmekte ve bu nesnenin harektleri
takip edilecek şekilde uygulama tasarlanmaktadır:
import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
import javax.swing.event.*;
public class SwingOrnek1 extends JFrame {
Container c;
JButton dugme;
Dinleyici dinleyici;

public SwingOrnek1() {

super(“GUI Nesneleri”);

c = this.getContentPane();
dinleyici = new Dinleyici();

dugme = new JButton(“Mesaji Goster”);
dugme.addActionListener(dinleyici);

c.add(dugme);

this.addWindowListener(new WindowAdapter() {
public void WindowClosing(WindowEvent e) {
System.exit(0);
}
});

this.setSize(300, 300);
this.show();
}
}
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;
public class Dinleyici implements ActionListener {
public void actionPerformed(ActionEvent e) {
if(e.getActionCommand() == “Mesaji Goster”) {
JOptionPane.showMessageDialog(null, “Dugmeye Basildi.”);
}
}
}
public class Monitor {
public static void main(String[] args) {
new SwingOrnek1();
} 104
}
Örneğimiz 3 dosyadan oluşmaktadır. Bu dosyalardan “Monitor.java” dosyası aslında kendi başına bir işlevi olmayan
ve genel olarak tüm uygulamayı çalıştırmaya yönelik bir sınıf olarak yazılmıştır.
“Dinleyici.java” sınıfı aslında orjinal adıyla “listener” olarak isimlendirilen ve ActionListener arayüzünü implement
eden bir sınıftır. Bu sınıf kendisine atanan nesneleri sürekli dinleyen ve ilgili nesneye yapılan her hareketi takip eden
bir sınıftır. Bu sınıf içerisinde yer alan “actionPerformed” isimli metod, bu sınıfın dinlediği herhangi bir nesneye
müdahele olduğu zaman otomatik olarak çağrılmaktadır.
Aslında daha teknik olarak ifade etmek gerekirse, herhangi bir nesneye yapılan müdahele sonucunda Java’da
“ActionEvent” yaratılmaktadır. Yaratılan bu “ActionEvent” ise ilgili nesneyi dinleyen listener sınıfının
“actionPerformed” metoduna parametre olarak gönderilmektedir. O halde bizim örneğimizde “SwingOrnek1.java”
dosyasının 20. satırında dinlenmek üzere eklenen “JButton” nesnesine dokunulduğunda bir action yaratılmakta ve
bu nesneyi dinelyen “dinleyici” isimli sınıfa gönderilmektedir. Bu metoda gelen eventin hangi nesneye ait oldugu
“ActionEvent” nesnesinin “getActionCommand” metoduyla anlaşılmaktadır. Bu metodun geri dönüş değeri
ActionEvent halinde gelen nesnenin üzerinde yazan etikettir. O halde şunu da belirtmek gerekir ki listener tipindeki
bir sınıf aynı anda birden fazla nesneyi dinleyebilir. Ya da bir başka deyişle, birbirinden farklı birden fazla nesne,
aynı listener sınıfının dinlenme listesine eklenebilir. Bizim örneğimizdeki “dugme” isimli JButton nesnesi,
SwingOrnek1.java dosyasında 20. satırda dinleyici sınıfının dinlenecek nesnelerinden birisi olarak eklenmektedir.
Dinleyici degişkeni de yine aynı dosyadaki 10. satırda “Dinleyici” sınıfı türünden yaratılmıştır. Dinleyici sınıfı da
“ActionListener” arayüzünden türetildiğine göre, bu sınıfın dinleme yeteneği vardır.
Action Nesneleri Hakkında
Genelde belirli bir menu nesnesi tarafından tetiklenen bazı komutlar bazı başka nesneler tarfından da tetiklenebilir.
Mesela bir menu nesnesinde tanmlı olan bir komut bir toolbar nesnesi içerisinde de tetiklenebilir.
Kullanıcı belirli bir nesne için belirli bir fonksiyon atayabilir. Bu nesne bir menu nesnesi, bir dugme ya da bir toolbar
nesnesi olabilir.
Mesela adı blueAction olan bir nesne ColorAction nesnesinde türemiş bir nesne olsun. ColorAction nesnesi de
ActionListener’ı implement eden bir nesne olsun. O halde yaratılan bir düğmenin dinleyicisi olarak blueAction
nesnesi kullanılabilir ve bu nesne de sadece arka plan rengini maviye dönüştürecek şekilde yazılmış olabilir.
O halde artık bu nesne birden fazla nesne tarafında listener olarak kullanılabilir. 105
Swing paketleri içerisinde Action denilen bir arayüz sayesinde yukarıda bahsettiğimiz bu mekanizma çok verimli bir
şekilde ele alınabilir. Bu arayüz birçok listener arayüzünde tetiklenen metoduları içerir:
interface Action {
void actionPerformed(ActionEvent e);
void setEnabled(boolean b);
boolean isEnabled();
void putValue(String key, Object value);
Object getValue(Sting key);
void addPropertyChangeListener(PropertyChangeListener listener);
void removePropertyChangeListener(PropertyChangeListener listener);
}
putValue ve getValue metodları action nesnesi içerisinde anahtar değer ikililerinin tutmaya olanak verir. Bunun için
Action sınıfı içerisinde tanımlı bazı sabitlerden yararlanırız.
NAME, SMALL_ICON, SHORT_DESCRIPTION, LONG_DESCRIPTION, MNEMONIC_KEY, ACCELERATOR_KEY,
ACTION_COMMAND_KEY gibi…
Eğer action bir menu ya da toolbar nesnesine eklendiği zaman NAME ve SMALL_ICON otomatik olarak nesne bu
değerler için ayarlanır. SHORT_DESCRIPTION değeri de nesne de tooltip olarak set edilir.
Action, bir arayüz olduğu için daha kolay bir kullanımı sağlayan AbstractAction sınıfı kullnılabilir. Bu sınıf içerisinde
tüm metodlar gerektiği şekilde implement edilmiştir. Ancak sadece actionPerformed metodu soyut olarak
bırakılmıştır.
Mesela yeni bir action tanımlamlayalım:
public class ColorAction extends AbstractAction {
public ColorAction(String name, Icon icon, Color c) {
putValue(Action.NAME, name);
putValue(Action.SMALL_ICON, icon);
putValue(“color”, c);
putValue(Action.SHORT_DESCRIPTION, “Set panel color to ” +
name.toLowerCase);
}
public void actionPerformed(ActionEvent e) {
Color c = (Color)getValue(“color”);
setBackground(c);
}
}
Bundan sonra bu action istenilen nesneler için kullanılabilir:
Action blueAction = new ColorAction(“Blue”, new ImageIcon(“blue.gif”), Color.BLUE);
JButton blueButton = new JButton(blueAction);
Container Kavramı
Şu ana kadar aslında bir GUI nesnesinin nasıl dinlendiğini öğrendik. Peki ama bir GUI nesnesi nasıl çerçeve içerisine
eklenebilir? Bu işlem örneğimizin 16. satırında gerçekleşmektedir. GUI nesnelerinin bazıları diğer nesneleri üzerinde
taşıma yeteneğine sahiptir. Bu yeteneğe sahip olan nesnelerden birtanesinin JFrame olduğunu görmekteyiz. Öyle ki
bizim örneğimiz temelde bir JFrame nesnesidir. Bu sayede üzerine bir JButton nesnesi ekleyebiliyoruz. Ancak
JFrame nesnesine bu eklemeyi yapmadan önce 8. satırda olduğu gibi “Container” sınıfı türünden bir değişken
yaratmaktayız. Bu değişken nesneleri tutabilen bir yapı haline gelmektedir. 16. satırdaki “getContentPane” isimli
metod yazmış olduğumuz JFrame nesnesinin panelini bu taşıyıcıya atadığından, container nesnesine eklenen her 106
nesne dolayısı ile JFrame nesnesi üzerine eklenmiş olacaktır. Bu da bizim uygulamamızın (SwingOrnek1 sınıfı)
kendisidir.
Container ve JFrame arasındaki ilişkiyi aşağıdaki şekilde irdeleyebiliriz.
NOT: Bizim uygulamamız JFrame nesnesidir. Çünkü uygulamamızı JFrame nesnesinden türetmekteyiz. Önceki
dersleri hatırlayınız.
Layout Kavramı
Genel olarak bakıldığında uygulamamızda bir sorun görmekteyiz. Öyle ki “dugme” adıyla eklemiş olduğumuz
JButton nesnesi bütün çerçeveyi kaplamaktadır. Bu görüntü alışılmış bir düğme görüntüsünden farklıdır. Bunun
sebebi bu tür nesneleri taşımak üzere yarattığımız Container nesnesinin “layout” modelini belirtmemiş olmamızdır.
Layout denilen kavram taşıyıcı görevi üstlenen bir nesnenin kendisine eklenen diğer nesneleri hangi düzende
yerleştireceğinin belirleyen bir kavramdır.
Layout modellerinden ilki olarak FlowLayout modelini inceleyebiliriz. Bu taşıyıcı nesneye (yani container nesnesine)
eklenen her nesne (JButton ve daha sonra öğreneceğimiz diğer Swing nesneleri gibi) arka arkaya ve satır satır
eklenmektedir. Çerçeve üzerinde bir satır bittikten sonra eklemeye alt satırdan devam edilir.
Aşağıdaki örnekte FlowLayout modeli kullanılarak nesneler eklenmektedir. Ayrıca bu örnekte listener sınıfı için yeni
ve ayrı bir sınıf yaratmak yerine çerçevenin kendisi aynı zamanda Listener olarak kullanılmaktadır. Bu nedenle
addActionListener metoduna eklenecek sınıf olarak “this” yani sınıfın kendisi verilmektedir.

import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
import javax.swing.event.*;
public class LayoutDeneme1 extends JFrame implements ActionListener { 107
Container c;
JButton dugmeler[] = new JButton[10];

public LayoutDeneme1() {

c = 0this.getContentPane();
c.setLayout(new FlowLayout(FlowLayout.LEFT));

for(int i = 0; i < dugmeler.length; i++) {
dugmeler[i] = new JButton(“dugme_”+i);
dugmeler[i].setSize(10,15);
dugmeler[i].addActionListener(this);
c.add(dugmeler[i]);
}

this.setDefaultCloseOperation(this.EXIT_ON_CLOSE);
this.setSize(300, 300);
this.show();
}

public void actionPerformed(ActionEvent e) {

for(int i = 0; i < dugmeler.length; i++)
if(e.getSource() == dugmeler[i]) {
JOptionPane.showMessageDialog(this, i + ” Nolu Dugmeye Basildi”);
}
}

public static void main(String arg[]) {
new LayoutDeneme1();

}
}
“LayoutDeneme1” sınıfı, bildiriminden de anlaşıldığı gibi hem bir JFrame nesnesi, hem bir listener hem de kendi
başına çalışabilen bir uygulama olarak tasarlanmıştır. Uygulama üzerine yerleştirilecek JButton nesneleri bir JButton
dizisi içerisinde saklanmaktadır. Bu dizi 9. satırda yaratılmaktadır. 17 satırda ise for döngüsünün her adımında
dizinin ilgili elemanı JButton nesnesi olarak yaratılmakta ve yaratılırken de otomatik bir isim verilmektedir.
18. satırda JButton nesnesine ait olan “setSize” isimli bir metod sayesinde her JButton nesnesi sabit bir büyüklükte
yaratılmakta ve böylece daha doğal bir görüntü sağlanmaktadır. Aynı döngü içerisinde ilgili nesne yaratılır 108
yaratılmaz ActionListener görevini üstlenen sınıfa, yani bu örnekte sınıfın kendisine eklenmektedir. Sınıfın kendisi
ActionListener olduğu için de sınıf içerisine ActionListener arayüzüne sahip olan “actionPerformed” metodunun
mutlaka yazılması gerekir
(Arayüzlerde belirtilen metod prototiplerinin, bu arayüzleri implement eden sınıflarda yazılmak zorunda olduğunu
hatırlayınız).
Bu işlem 32. satırda yapılmaktadır.
20. satırda yaratılan her JButton nesnesi Container olarak yaratılan c nesnesine eklenmektedir. Ancak 14. satırda
görüldüğü gibi c nesnesinin layout yapısı “FlowLayout” olduğundan eklenen her JButton nesnesi sırayla ve arka
arkaya eklenmekltedir. Bu sonuç, program çalıştırıldığında yukarıda şekilde olduğu gibi açıkça görülmektedir. Ayrıca
FlowLayout bildirimi yapılırken kullanılan LEFT sabit değişkeni ekleme sırasının her satır için soldan sağa doğru
olacağını belirler. Bunun dışında RIGHT ya da CENTER da kullanılabilir.
Bu örnekte birden fazla aynı türe ilişkin nesnelerin bir dizi içerisinde otomatik olarak nasıl yaratıldığını 16. satırda
görmekteyiz. Genel olarak bu sıra şu şekilde listelenebilir:
Dizinin her adımı için:
a) Nesneyi yarat
b) Nesneyi özelleştir (Boyut, renk vb.)
c) Nesneyi listener sınıfına kaydet
d) Nesneyi conatiner nesnesine ekle.
32. satırda da bu şekilde dizide saklanan nesnelerin nasıl kullanıldığını görmekteyiz. Döngünün her adımında ilgili
nesnenin otomatik olarak verilmiş adı yardımıyla mesaj penceresi hazırlanmaktadır. Ancak bu sefer üzerinde işlem
yapılan nesne, nesnenin üzerindeki isme bakılarak değil, gerçekten kendisine bakılarak tespit edilmektedir. Bunu
sağlayan metod ActionEvent sınıfının “getSource” isimli metodudur. Demek ki bir ActionEvent yaratıldığında bu
nesnenin hangi nesne olduğunu ya “getActionCommand“ yardımıyla nesne üzerindeki isime bakarak, ya da
“getSource” metodu yardımıyla nesnenin kendisine bakarak anlayabiliriz.
Bir başka layout modeli de BorderLayout’dur. Bu modele göre taşıyıcı nesne üzerinde kuzey, güney, doğu ve batı
olarak 5 tane alan vardır ve nesneler bu alanlardan birisine yerleştirilir. Aslında contenPane içerisindeki öntanımlı
layout modeli de zaten budur. Eğer yukarıdaki örnekte layout modeli BorderLayout olarak değiştirilirse nesneler
buna göre istenen bölgeye yerleştirilebilir. Gerekli değişiklerle birlikte az önceki örneğin yeni hali aşağıdadır:
import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
import javax.swing.event.*;
public class LayoutDeneme2 extends JFrame implements ActionListener {
Container c;
JButton dugmeler[] = {new JButton(“dugme_0″), new JButton(“dugme_1″),
new JButton(“dugme_2″), new JButton(“dugme_3″),
new JButton(“dugme_4″)};

public LayoutDeneme2() {

c = getContentPane();
c.add(dugmeler[0], BorderLayout.WEST);
c.add(dugmeler[1], BorderLayout.EAST);
c.add(dugmeler[2], BorderLayout.SOUTH);
c.add(dugmeler[3], BorderLayout.NORTH);
c.add(dugmeler[4], BorderLayout.CENTER);

for(int i = 0; i < dugmeler.length; i++)
dugmeler[i].addActionListener(this);
109
this.addWindowListener(new WindowAdapter() {
public void WindowClosing(WindowEvent e) {
System.exit(0);
}
});
this.setSize(300, 300);
this.show();
}

public void actionPerformed(ActionEvent e) {

for(int i = 0; i < dugmeler.length; i++)
if(e.getSource() == dugmeler[i]) {
JOptionPane.showMessageDialog(this, i + ” Nolu Dugmeye Basildi”);
}
}

public static void main(String arg[]) {
new LayoutDeneme2();
}
}
Bu örnekte görüldüğü gibi ekleme işleminde kullandığımız add metoduna bir de eklemenin hangi bölüme yapılacağı
bilgisi de verilmelidir. Buraya kadar sadece en temel kavramları vermek amacıyla Container, Layout ve Swing
nesnelerini en az özellikleriyle inceledik.
Şu anda amacımız genel yapıyı ve hiyerarşiyi kavramak olduğundan bu nesnelerin kendi içindeki detaylara şimdi
girmiyoruz. Böylece en azından örneklerimizi anlayacak kadar temel bilgileri edinmiş oluyoruz. İlerleyen konularda
bu temel kavramların herbirini kendi içinde daha detaylı inceleyeceğiz.
JPanel Nesnesi
Artık genel anlamda bir JFrame nesnesi yaratmayı, bu nesneye başka nesneler eklemeyi ve eklenen bu nesneleri de
takip etmeyi öğrendik. Nesnelerin JFrame üzerine eklenmesi için bir Container kullandık. Ancak bazen nesneleri
direk JFrame üzerine eklemek kullanışlı olmayabilir. Bu nedenle önce bazı nesneleri kendi içinde gruplayıp tek bir
nesne haline getirip bu ana nesneyi JFrame container üzerine eklemek daha anlaşılır ve daha düzenli olabilir.
JPanel kendi başına üzerinde nesne tutabilen bir yapıdır. Yani JFrame’de olduğu gibi, bir JPanel nesnesi üzerine
başka bir nesne eklemek için contentPane oluşturmaya gerek yoktur. Doğrudan JPanel üzerine nesneler eklenir ve
bu nesnelerin listener işlemleri tamamlanır. Daha sonra bu JPanel nesnesi artık içerisinde başka nesneleri tutan tek
bir nesne gibi kullanılabilir. Aslında bu işlemleri yaparken de gerçek anlamda nesne yönelimli programcılık
yaptığımızı özellikle belirtmek isterim.
Aşağıdaki örnekte bir text alanı içerisindeki yazı üzerinde renk ve boyut düzenlemeleri yapan bir uygulama
geliştirilmektedir. Ancak bu düzenleme opsiyonları ayrı gruplar halinde paneller üzerinde tasarlanıp daha sonra
çerçeve üzerine eklenmektedir. Uygulama çalıştıktan sonra aşağıdaki gibi bir GUI ekrana gelmektedir:
RESIM:
RESIM ADI: JpanelOrnek1Cikis.png
ALT BAŞLIK: JPanelOrnek1 Uygulamasının Çalışması
import javax.swing.*;
import javax.swing.event.*;
import java.awt.*;
import java.awt.event.*;
public class JPanelOrnek1 extends JFrame implements ActionListener {
JPanel colorPanel, sizePanel, editPanel, southPanel;
JTextArea text; 110
JButton yellowButton, redButton, blueButton;
JRadioButton editable, noneditable;
ButtonGroup group;
Container c;

public JPanelOrnek1() {

c = this.getContentPane();
c.setLayout(new BorderLayout());

southPanel = new JPanel();
southPanel.setLayout(new BorderLayout());

colorPanel = new JPanel(new FlowLayout());
yellowButton = new JButton(“Sari”);
yellowButton.addActionListener(this);
colorPanel.add(yellowButton);
redButton = new JButton(“Kirmizi”);
redButton.addActionListener(this);
colorPanel.add(redButton);
blueButton = new JButton(“Mavi”);
blueButton.addActionListener(this);
colorPanel.add(blueButton);

yellowButton.setBackground(Color.BLACK);
yellowButton.setForeground(Color.WHITE);
redButton.setBackground(Color.BLACK);
redButton.setForeground(Color.WHITE);
blueButton.setBackground(Color.BLACK);
blueButton.setForeground(Color.WHITE);

southPanel.add(colorPanel, BorderLayout.SOUTH);

editPanel = new JPanel(new FlowLayout());
group = new ButtonGroup();
editable = new JRadioButton(“Duzenlenebilir”, false);
group.add(editable);
editable.addActionListener(this);
editPanel.add(editable);
noneditable = new JRadioButton(“Duzenlenemez”, true);
group.add(noneditable);
noneditable.addActionListener(this);
editPanel.add(noneditable);

southPanel.add(editPanel, BorderLayout.NORTH);

text = new JTextArea();
text.setText(“Deneme Yazisi”);
text.setEditable(true);
c.add(text, BorderLayout.CENTER);
c.add(southPanel, BorderLayout.SOUTH);

this.setDefaultCloseOperation(this.EXIT_ON_CLOSE);
this.setSize(300, 300);
this.show();
}

public void actionPerformed(ActionEvent e) {

if(e.getSource() == yellowButton) {
text.setBackground(Color.YELLOW); 111
yellowButton.setBackground(Color.YELLOW);
redButton.setBackground(Color.BLACK);
blueButton.setBackground(Color.BLACK);
}
else if(e.getSource() == redButton) {
text.setBackground(Color.RED);
yellowButton.setBackground(Color.BLACK);
redButton.setBackground(Color.RED);
blueButton.setBackground(Color.BLACK);
}
else if(e.getSource() == blueButton) {
text.setBackground(Color.BLUE);
yellowButton.setBackground(Color.BLACK);
redButton.setBackground(Color.BLACK);
blueButton.setBackground(Color.BLUE);
}

if(e.getSource() == editable)
text.setEditable(true);
else if(e.getSource() == noneditable)
text.setEditable(false);

repaint();
}

public static void main(String[] args) {
new JPanelOrnek1();
}

}
Şimdi bu örneğimizi biraz daha derinlemesine inceleyelim. Öncekilerde olduğu gibi bu sınıf da, yine bir JFrame
uygulaması ve aynı zamanda ActionListener olarak yaratılmaktadır.
Ancak bu sefer birtakım nesneler doğrudan JFrame’in Container nesnesi üzerine yerleştirilmek yerine, önce bazı
paneller üzerine yerleştirilmiş ve daha sonra bu paneller JFrame üzerine eklenerek uygulama tamamlanmıştır.
Örneğimizde tüm nesneleri kendi üzerinde taşıyan JFrame nesnesinin Container’ı 18. satırda yaratılmaktadır. Daha
sonra sadece renk opsiyonlarının ayarlanacağı düğmeleri barındıracak olan “colorPanel” isimli bir JPanel nesnesi
yaratılmış ve 24. satır ile 33. satırlar arasında bu panelin tutacağı nesneler de tek tek yaratılarak panel üzerine
eklenmiştir.
Benzer şekilde ekrana gelen text alanına yazmayı sağlayan ya da yazma opsiyonunu kaldıran seçenekleri barındıran
“editPanel” isimli bir başka JPanel nesnesi ve onun tutacağı nesneler de 37. ve 46. satırlar arasında yaratılmaktadır.
En son olarak üzerinde editPanel ve colorPanel panellerini tutacak olan bir başka JPanel nesnesi “southPanel” adıyla
22. satırda yaratılmış ve JFrame’in c isimli Container nesnesinin SOUTH bölgesine 54. satırda yerleştirilmiştir.
c isimli Container’ın CENTER bölgesine ise JTextArea isimli nesne 53. satırda olduğu gibi doğrudan yerleştirlmiştir.
Bunun dışında aslında uygulama genel olarak diğer nesnelerin yaratılması ve bazı özelliklerinin set edilmesi şeklinde
tamamlanmaktadır. Burada karşımıza JTextArea ve JRadioButton isimli iki yeni GUI nesnesi gelmektedir.
Aslında adından da anlaşılabileceği gibi JTextArea isimli nesne bize içerisine yazı yazabileceğimiz bir text alanı
sunmaktadır. Yine birçok hazır metodu sayesinde bu nesnenin bazı özelliklerini değiştirmek mümkündür.
JRadioButton nesneleri de benzer şekilde seçim düğmeleri yaratmamızı sağlar. Ancak bu nesneler yaratıldıktan
sonra bir de 12. satırda yaratılan “ButtonGroup” adında bir nesne içerisine eklenmektedir. Bu ekleme, bir
RadioButton seçili iken diğerinin otomatik olarak seçilmemesini sağlamaktadır. Eğer birden fazla radio button
nesnesini ButtonGroup içerisine eklemezseniz, aynı anda birden fazla seçim yapabilirsiniz. 112
Böylece genel anlamda bir GUI uygulmasında ilk olarak hiyerarşiyi belirlemek gerektiğini ve daha sonra da bu
hiyerarşiye uyarak gerekli olan GUI nesnelerini birtakım özellikleriyle yaratarak paneller üzerine eklemek gerektiğini
görmekteyiz.
Seçim yapmak üzere üzerine basılan ya da seçim yapılan bu nesnelerin her biri bir ActionEvent üretmektedir.
Listener’a eklenen tüm nesneler için bu ActionEvent’ler de doğrudan actionPerformed metoduna göderilmektedir.
Buna göre gönderilen her ActionEvent için JTextArea nesnesinin bir özelliği değiştirilmektedir. Böylece kullanıcı asıl
olarak kullandığı text alanını seçimlere göre değiştirebilme olanağına sahip olur. Bu değişimler 66. satırdaki
actionPerformed metodunda ele alınmıştır.
GUI derslerimizin bundan sonra devam edecek olan kısımlarında öncelikle yukarıda bahsedilen temel kavramların
kendi içinde detaylarına değinecek ve daha sonra da birçok GUI nesnesini tek tek ele alarak inceleyeceğiz. Daha
sonra kapsamlı bir GUI uygulaması geliştirerek GUI derslerimizi geride bırakacağız.
Bu derste anlatılan temel bilgileri kendiniz de deneyerek test etmeli ve kavramları iyice irdelemelisiniz.
ARAŞTIRMA ÖDEVİ
Uygulama olarak; yukarıda verilen son örneğimize bir de yazı fontunun rengini değiştiren opsiyonların yeraldığı bir
panelin nasıl ekleneceğini araştırabilirsiniz. Bunun için ipucu olarak JTextArea nesnesinin bir metodunu (setFont)
kullanabilirsiniz. Ama ondan önce bu metodu tetikleyecek birtakım seçim düğmeleri yaratmalı ve bu düğmeleri bir
panel üzerine yerleştirerek uygulamaya dahil etmelisiniz. Bu da iyi bir tekrar ve yeni araştırma gerektirmektedir.
Şimdiden kolay gelsin ☺