5. Grafik arayüzler
Burada, JAVA ile grafik arayüzlerin nasıl oluşturulacağını göstermeyi amaçlıyoruz. Öncelikle, bir grafik arayüz oluşturmamızı sağlayan temel sınıfların hangileri olduğuna bakacağız. İlk etapta herhangi bir otomatik oluşturma aracı kullanmayacağız. Daha sonra, Java uygulamalarının geliştirilmesini ve özellikle grafik arayüzlerin oluşturulmasını kolaylaştıran bir Borland/Inprise geliştirme aracı olan JBuilder'i kullanacağız.
5.1. Grafik kullanıcı arayüzlerinin temelleri
5.1.1. Basit bir pencere
Aşağıdaki kodu ele alalım:
// ithal edilen sınıflar
import javax.swing.*;
import java.awt.*;
// form sınıfı
public class form1 extends JFrame {
// oluşturucu
public form1() {
// pencere başlığı
this.setTitle("Mon premier formulaire");
// pencere boyutları
this.setSize(new Dimension(300,100));
}//oluşturucu
// test işlevi
public static void main(String[] args) {
// form görüntülenir
new form1().setVisible(true);
}
}//sınıf
Yukarıdaki kodun çalıştırılmasıyla aşağıdaki pencere görüntülenir:
Bir grafik arayüz genellikle JFrame temel sınıfından türetilir:
public class form1 extends JFrame {
JFrame temel sınıfı, kapatma, büyütme/küçültme düğmeleri, ayarlanabilir boyut vb. özelliklere sahip bir temel pencere tanımlar ve bu grafik nesneler üzerindeki olayları yönetir. Burada, temel sınıfa bir başlık, genişlik (300 piksel) ve yükseklik (100 piksel) atayarak onu özelleştiriyoruz. Bu işlem, sınıfın oluşturucusunda gerçekleştirilir:
// oluşturucu
public form1() {
// pencere başlığı
this.setTitle("Mon premier formulaire");
// pencere boyutları
this.setSize(new Dimension(300,100));
}//oluşturucu
Pencerenin başlığı setTitle yöntemi ile, boyutları ise setSize yöntemi ile belirlenir. Bu yöntem, parametre olarak bir Dimension(largeur,hauteur) nesnesini kabul eder; burada largeur ve hauteur, pencerenin piksel cinsinden genişliği ve yüksekliğidir.
main yöntemi, grafik uygulamasını şu şekilde başlatır:
new form1().setVisible(true);
Bunun üzerine form1 türünde bir form oluşturulur (new form1()) ve görüntülenir (setVisible(true)), ardından uygulama formda meydana gelen olayları (tıklamalar, fare hareketleri, ...) ve formun yönettiği olayları yürütür. Burada, formumuz JFrame temel sınıfı tarafından yönetilenler (kapatma düğmelerine tıklamalar, büyütme/küçültme, pencere boyutunu değiştirme, pencereyi taşıma, ...) dışında başka olayları yönetmez.
Bu programı bir DOS penceresinden şu komutla çalıştırarak test ettiğimizde:
komutuyla form1.class dosyasını çalıştırdığımızda, görüntülenen pencereyi kapattığımızda DOS penceresinde "kontrolün geri gelmediğini", sanki program henüz bitmemiş gibi görüyoruz. Durum gerçekten de böyledir. Programın çalışması şu şekilde gerçekleşir:
- başlangıçta, main yöntemini çalıştırmak üzere ilk bir yürütme iş parçacığı başlatılır
- bu yöntem formu oluşturup görüntülediğinde, özellikle formla ilgili olayları yönetmek üzere ikinci bir iş parçacığı oluşturulur
- bu oluşturma işleminden sonra ve örneğimizde, main yöntemine ait iş parçacığı sona erer ve geriye yalnızca grafik kullanıcı arayüzünün yürütme iş parçacığı kalır.
- Pencere kapatıldığında, pencere kaybolur ancak içinde çalışmakta olduğu iş parçacığını durdurmaz
- Şu an için, programın çalıştırılmasının başlatıldığı DOS penceresinde Ctrl-C tuşlarına basarak bu iş parçacığını durdurmak zorundayız.
İki ayrı iş parçacığının varlığını kontrol edelim; biri main yöntemini çalıştıran, diğeri ise grafik pencereyi çalıştıran iş parçacığı:
// ithal edilen sınıflar
import javax.swing.*;
import java.awt.*;
import java.io.*;
// form sınıfı
public class form1 extends JFrame {
// oluşturucu
public form1() {
// pencere başlığı
this.setTitle("Mon premier formulaire");
// pencere boyutları
this.setSize(new Dimension(300,100));
}//oluşturucu
// test işlevi
public static void main(String[] args) {
// izleme
System.out.println("Début du thread main");
// form görüntülenir
new form1().setVisible(true);
// takip
System.out.println("Fin du thread main");
}//ana
}//sınıf
Çalıştırıldığında şu sonuçlar elde edilir:
main iş parçacığının, pencere hala görüntülenirken sona erdiği görülebilir. Pencereyi kapatmak, pencerenin çalıştığı iş parçacığını sonlandırmaz. Bu iş parçacığını durdurmak için DOS penceresinde tekrar Ctrl-C tuşlarına basılır.
Bu örneği tamamlamak için, içe aktarılan paketleri not edelim:
- javax.swing, JFrame sınıfı için
- java.awt, Dimension sınıfı için
5.1.2. Bir olayı yönetme
Önceki örnekte, pencerenin kapanışını kendimiz yönetmemiz gerekir; böylece bu olay gerçekleştiğinde uygulamayı durdurabiliriz, ancak şu anda bu yapılmamaktadır. Bunun için, pencerede meydana gelen olayları "dinleyen" ve "pencerenin kapanması" olayını algılayan bir nesne oluşturmamız gerekir. Bu nesneye "dinleyici" veya olay yöneticisi denir. Bir grafik arayüzün bileşenlerinde meydana gelebilecek farklı olaylar için farklı türde dinleyiciler mevcuttur. JFrame bileşeni için dinleyicinin adı WindowListener'tir ve aşağıdaki yöntemleri tanımlayan bir arayüzdür (bkz. Java belgeleri)
Yöntem Özeti | ||
void | windowActivated(WindowEvent e) Pencere, etkin pencere haline gelir | |
void | windowClosed(WindowEvent e) Pencere kapatıldı | |
void | windowClosing(WindowEvent e) Kullanıcı veya program pencerenin kapatılmasını talep etti | |
void | windowDeactivated(WindowEvent e) Pencere artık etkin pencere değil | |
void | windowDeiconified(WindowEvent e) Pencere, küçültülmüş durumdan normal duruma geçer | |
void | windowIconified(WindowEvent e) Pencere, normal durumdan simge durumuna geçer | |
void | windowOpened(WindowEvent e) Pencere ilk kez görünür hale gelir | |
Dolayısıyla yönetilebilecek yedi olay vardır. İşleyicilerin tümü, şimdilik göz ardı edeceğimiz WindowEvent türünde bir nesneyi parametre olarak alır. Burada bizi ilgilendiren olay, pencerenin kapanmasıdır; bu olay, windowClosing yöntemi tarafından işlenmelidir. Bu olayı işlemek için, aşağıdaki gibi anonim bir sınıf kullanarak bir Windowlistener nesnesi oluşturabiliriz:
// bir olay yöneticisi oluşturma
WindowListener win=new WindowListener(){
public void windowActivated(WindowEvent e){}
public void windowClosed(WindowEvent e){}
public void windowClosing(WindowEvent e){System.exit(0);}
public void windowDeactivated(WindowEvent e){}
public void windowDeiconified(WindowEvent e){}
public void windowIconified(WindowEvent e){}
public void windowOpened(WindowEvent e){}
};//win tanımı
WindowListener arayüzünü uygulayan olay yöneticimiz, bu arayüzün yedi yöntemini tanımlamalıdır. Yalnızca pencerenin kapatılmasını yönetmek istediğimizden, yalnızca windowClosing yöntemi için kod yazıyoruz. Diğer olaylar meydana geldiğinde, bunlar hakkında bilgilendirileceğiz ancak herhangi bir işlem yapmayacağız. Pencerenin kapatılmakta olduğu konusunda bilgilendirildiğimizde (windowClosing) ne yapacağız? Uygulamayı durduracağız:
public void windowClosing(WindowEvent e){System.exit(0);}
Elimizde genel olarak bir pencerenin olaylarını yönetebilen bir nesne var. Bunu belirli bir pencereye nasıl bağlayacağız? JFrame sınıfında, belirli bir pencereye bir "pencere" olay işleyicisi atamaya olanak tanıyan addWindowListener(WindowListener win) adlı bir yöntem bulunmaktadır. Dolayısıyla burada, pencerenin oluşturucusunda şunu yazacağız:
// bir olay yöneticisinin oluşturulması
WindowListener win=new WindowListener(){
public void windowActivated(WindowEvent e){}
public void windowClosed(WindowEvent e){}
public void windowClosing(WindowEvent e){System.exit(0);}
public void windowDeactivated(WindowEvent e){}
public void windowDeiconified(WindowEvent e){}
public void windowIconified(WindowEvent e){}
public void windowOpened(WindowEvent e){}
};//win tanımı
// bu olay yöneticisi, geçerli penceredeki olayları yönetecek
this.addWindowListener(win);
Programın tamamı şu şekildedir:
// ithal edilen sınıflar
import javax.swing.*;
import java.awt.*;
import java.io.*;
import java.awt.event.*;
// form sınıfı
public class form2 extends JFrame {
// oluşturucu
public form2() {
// pencerenin başlığı
this.setTitle("Mon premier formulaire");
// pencerenin boyutları
this.setSize(new Dimension(300,100));
// bir olay işleyicinin oluşturulması
WindowListener win=new WindowListener(){
public void windowActivated(WindowEvent e){}
public void windowClosed(WindowEvent e){}
public void windowClosing(WindowEvent e){System.exit(0);}
public void windowDeactivated(WindowEvent e){}
public void windowDeiconified(WindowEvent e){}
public void windowIconified(WindowEvent e){}
public void windowOpened(WindowEvent e){}
};//win tanımı
// bu olay yöneticisi, geçerli pencerenin olaylarını yönetecek
this.addWindowListener(win);
}//oluşturucu
// test fonksiyonu
public static void main(String[] args) {
// form görüntülenir
new form2().setVisible(true);
}//ana işlev
}//sınıf
java.awt.event paketi, WindowListener arayüzünü içerir. Bu programı çalıştırıp açılan pencereyi kapattığımızda, programın başlatıldığı DOS penceresinde, daha önce görülmeyen programın çalışmasının sona erdiği bilgisi görüntülenir.
Programımızda, pencere olaylarını yönetmekle görevli nesnenin oluşturulması, yönetmek istemediğimiz olaylar için bile yöntemler tanımlamak zorunda kalmamız nedeniyle biraz zahmetlidir. Bu durumda, WindowListener arayüzünü kullanmak yerine WindowAdapter sınıfını kullanabiliriz. Bu sınıf, yedi boş yöntem içeren WindowListener arayüzünü uygular. WindowAdapter sınıfını türetip sadece ilgilendiğimiz yöntemleri yeniden tanımlayarak, WindowListener arayüzüyle elde edeceğimiz sonuçla aynı sonuca ulaşırız, ancak ilgilenmediğimiz yöntemleri tanımlamaya gerek kalmaz.
- olay işleyicisinin tanımlanması
- işleyicinin pencereye bağlanması
sırası, örneğimizde şu şekilde gerçekleştirilebilir:
// olay yöneticisi oluşturma
WindowAdapter win=new WindowAdapter(){
public void windowClosing(WindowEvent e){System.exit(0);}
};//win tanımı
// bu olay yöneticisi, geçerli penceredeki olayları yönetecek
this.addWindowListener(win);
Burada, WindowAdapter sınıfından türetilen ve windowClosing yöntemini yeniden tanımlayan isimsiz bir sınıf kullanıyoruz. Program şu şekilde olur:
// ithal edilen sınıflar
import javax.swing.*;
import java.awt.*;
import java.io.*;
import java.awt.event.*;
// form sınıfı
public class form2 extends JFrame {
// oluşturucu
public form2() {
// pencerenin başlığı
this.setTitle("Mon premier formulaire");
// pencerenin boyutları
this.setSize(new Dimension(300,100));
// bir olay işleyicisinin oluşturulması
WindowAdapter win=new WindowAdapter(){
public void windowClosing(WindowEvent e){System.exit(0);}
};//win tanımı
// bu olay yöneticisi, geçerli pencerenin olaylarını yönetecek
this.addWindowListener(win); }//oluşturucu
// test fonksiyonu
public static void main(String[] args) {
// form görüntülenir
new form2().setVisible(true);
}//ana işlev
}//sınıf
Bu program, önceki programla aynı sonuçları verir ancak yazımı daha basittir.
5.1.3. Düğmeli bir form
Şimdi penceremize bir düğme ekleyelim:
// ithal edilen sınıflar
import javax.swing.*;
import java.awt.*;
import java.io.*;
import java.awt.event.*;
// form sınıfı
public class form3 extends JFrame {
// bir düğme
JButton btnTest=null;
Container conteneur=null;
// oluşturucu
public form3() {
// pencere başlığı
this.setTitle("Formulaire avec bouton");
// pencere boyutları
this.setSize(new Dimension(300,100));
// bir olay işleyicinin oluşturulması
WindowAdapter win=new WindowAdapter(){
public void windowClosing(WindowEvent e){System.exit(0);}
};//win tanımı
// bu olay yöneticisi, geçerli pencerenin olaylarını yönetecek
this.addWindowListener(win);
// pencerenin konteynerini alıyoruz
conteneur=this.getContentPane();
// bu konteyner içindeki bileşenlerin biçimlendirme yöneticisi seçiliyor
conteneur.setLayout(new FlowLayout());
// bir düğme oluşturulur
btnTest=new JButton();
// düğmenin etiketini belirliyoruz
btnTest.setText("Test");
// düğmeyi kapsayıcıya eklenir
conteneur.add(btnTest);
}//oluşturucu
// test fonksiyonu
public static void main(String[] args) {
// form görüntülenir
new form3().setVisible(true);
}//ana işlev
}//sınıf
JFrame penceresi, grafik bileşenlerinin (düğme, onay kutuları, açılır listeler vb.) yerleştirilebileceği bir kapsayıcıya sahiptir. Bu kapsayıcı, JFrame sınıfının getContentPane yöntemi aracılığıyla kullanılabilir:
Container conteneur=null;
..........
// pencerenin konteynerini al
conteneur=this.getContentPane();
Her bileşen, Container sınıfının add yöntemi ile konteynere yerleştirilir. Dolayısıyla, C bileşenini önceki conteneur nesnesine yerleştirmek için şu kod yazılır:
Bu bileşen konteynerin neresine yerleştirilir? XXXLayout adını taşıyan çeşitli bileşen düzenleyiciler mevcuttur; örneğin, XXX, Border, Flow ile aynıdır, ... Her düzenleyicinin kendine özgü özellikleri vardır. Örneğin, FlowLayout düzenleyicisi, bileşenleri formun üstünden başlayarak satır halinde düzenler. Bir satır doldurulduğunda, bileşenler bir sonraki satıra yerleştirilir. Bir düzen yöneticisini JFrame penceresine atamak için, JFrame sınıfındaki setLayout yöntemi şu şekilde kullanılır:
Dolayısıyla örneğimizde, FlowLayout türünde bir işleyiciyi pencereye atamak için şunu yazdık:
// bu konteynerdeki bileşenlerin biçimlendirme yöneticisi seçiliyor
conteneur.setLayout(new FlowLayout());
Düzen yöneticisi kullanmayıp şu şekilde yazabiliriz:
Bu durumda, bileşenin konteyner içindeki kesin koordinatlarını (x,y,genişlik,yükseklik) biçiminde belirtmemiz gerekir; burada (x,y), bileşenin konteyner içindeki sol üst köşesinin koordinatlarıdır. Bundan sonra en sık bu yöntemi kullanacağız.
Artık bileşenlerin konteynere (add) nasıl yerleştirildiğini ve (setLayout) konumunu biliyoruz. Geriye,
bir konteynere hangi bileşenlerin yerleştirilebileceğini öğrenmemiz gerekiyor. Burada, javax.swing.JButton sınıfıyla modellenen bir düğme yerleştiriyoruz:
JButton btnTest=null;
..........
// bir düğme oluşturulur
btnTest=new JButton();
// düğmenin etiketini belirleriz
btnTest.setText("Test");
// düğmeyi konteynere eklenir
conteneur.add(btnTest);
Bu programı test ettiğimizde aşağıdaki pencere açılır:
Yukarıdaki formun boyutunu değiştirirsek, bileşenleri yeniden yerleştirmek için konteyner düzen yöneticisi otomatik olarak çağrılır:
Düzen yöneticilerinin en önemli avantajı, konteynerin boyutundaki değişiklikler sırasında bile bileşenlerin tutarlı bir düzenini korumaktır. Farkı görmek için null düzen yöneticisini kullanalım. Düğme artık aşağıdaki talimatlarla konteyner içine yerleştirilmiştir:
// bu kapsayıcıda bir bileşen biçimlendirme yöneticisi seçilir
conteneur.setLayout(null);
// bir düğme oluşturulur
btnTest=new JButton();
// düzenini ayarlıyoruz
btnTest.setText("Test");
// konumunu ve boyutlarını belirleriz
btnTest.setBounds(10,20,100,20);
// düğmeyi kapsayıcıya eklenir
conteneur.add(btnTest);
Burada, düğmeyi formun (10,20) noktasına açıkça yerleştiriyoruz ve boyutlarını genişlik için 100 piksel, yükseklik için 20 piksel olarak belirliyoruz. Yeni pencere şu şekilde oluyor:
Pencerenin boyutunu değiştirirsek, düğme aynı yerde kalır.
Test düğmesine tıklandığında hiçbir şey olmaz. Aslında, düğmeye henüz bir olay işleyicisi atamamışız. Belirli bir bileşen için kullanılabilir olay işleyicilerinin türlerini öğrenmek için, sınıf tanımında bileşene bir olay işleyicisi atamaya olanak tanıyan addXXXListener yöntemlerini arayabilirsiniz. javax.swing.JButton sınıfı, javax.swing.AbstractButton sınıfından türetilmiştir ve bu sınıfta aşağıdaki yöntemler bulunur:
Yöntem Özeti | ||
void | addActionListener(ActionListener l) | |
void | addChangeListener(ChangeListener l) | |
void | addItemListener(ItemListener l) | |
Burada, düğmeye tıklamayı hangi olay işleyicisinin yönettiğini öğrenmek için belgelere bakmak gerekir. Bu, ActionListener arayüzüdür. Bu arayüz yalnızca bir yöntem tanımlar:
Yöntem Özeti | ||
void | actionPerformed(ActionEvent e) | |
Yöntem, şimdilik göz ardı edeceğimiz bir ActionEvent parametresi alır. Programımızdaki btntest düğmesine yapılan tıklamayı yönetmek için önce ona bir olay işleyicisi atarız:
btnTest.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt){
btnTest_clic(evt);
}
}//anonim sınıf
);//olay işleyicisi
Burada, actionPerformed yöntemi, aşağıdaki şekilde tanımladığımız btnTest_clic yöntemine başvurur:
public void btnTest_clic(ActionEvent evt){
// konsol izleme
System.out.println("clic sur bouton");
}//btnTest_click
Kullanıcı Test düğmesine her tıkladığında, konsola bir mesaj yazılır. Aşağıdaki çalıştırma bunu göstermektedir:
Programın tamamı şöyledir:
// ithal edilen sınıflar
import javax.swing.*;
import java.awt.*;
import java.io.*;
import java.awt.event.*;
// form sınıfı
public class form4 extends JFrame {
// bir düğme
JButton btnTest=null;
Container conteneur=null;
// oluşturucu
public form4() {
// pencere başlığı
this.setTitle("Formulaire avec bouton");
// pencere boyutları
this.setSize(new Dimension(300,100));
// bir olay işleyicisinin oluşturulması
WindowAdapter win=new WindowAdapter(){
public void windowClosing(WindowEvent e){System.exit(0);}
};//win tanımı
// bu olay yöneticisi, geçerli pencerenin olaylarını yönetecek
this.addWindowListener(win);
// pencerenin konteynerini alıyoruz
conteneur=this.getContentPane();
// bu konteyner içindeki bileşenlerin biçimlendirme yöneticisi seçiliyor
conteneur.setLayout(null);
// bir düğme oluşturulur
btnTest=new JButton();
// düğmenin etiketini belirliyoruz
btnTest.setText("Test");
// konumunu ve boyutlarını belirleriz
btnTest.setBounds(10,20,100,20);
// buna bir olay işleyicisi atanır
btnTest.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt){
btnTest_clic(evt);
}
}//anonim sınıf
);//olay işleyicisi
// düğme, kapsayıcıya eklenir
conteneur.add(btnTest);
}//oluşturucu
public void btnTest_clic(ActionEvent evt){
// konsol takibi
System.out.println("clic sur bouton");
}//btnTest_click
// test işlevi
public static void main(String[] args) {
// form görüntüleniyor
new form4().setVisible(true);
}//ana
}//sınıf
5.1.4. Olay Yöneticileri
Tanıtacağımız başlıca Swing bileşenleri şunlardır: pencereler (JFrame), düğmeler (JButton), onay kutuları (JCheckBox), radyo düğmeleri (JButtonRadio), açılır menüler (JComboBox), listeler (JList), kaydırma çubukları (JScrollBar), etiketler (JLabel), tek satırlı (JTextField) veya çok satırlı (JTextArea) giriş kutuları, menüler (JMenuBar), menü öğeleri (JMenuItem).
Aşağıdaki tablolarda bazı olay yöneticileri ve bunlarla ilişkili olayların bir listesi verilmiştir.
İşlemci | Bileşen(ler) | Kaydetme yöntemi | Olay |
ActionListener | JButton, JCheckbox, JButtonRadio, JMenuItem | public void addActionListener(ActionListener) | düğmeye, onay kutusuna, radyo düğmesine veya menü öğesine tıklama |
JTextField | |||
ItemListener | JComboBox, JList | public void addItemListener(ItemListener) | Seçilen öğe değişti |
InputMethodListener | JTextField, JTextArea | public void addMethodInputListener(InputMethodListener) | giriş alanındaki metin değişti veya giriş imlecinin konumu değişti |
CaretListener | JTextField, JTextArea | public void addcaretListener(CaretListener) | Giriş imlecinin konumu değişti |
AdjustmentListener | JScrollBar | public void addAdjustmentListener(AdjustmentListener) | sürücü değeri değişti |
MouseMotionListener | public void addMouseMotionListener(MouseMotionListener) | fare hareket etti | |
WindowListener | JFrame | public void addWindowlistener(WindowListener) | pencere olayı |
MouseListener | public void addMouselistener(MouseListener) | fare olayları (tıklama, bileşen alanına giriş/çıkış, düğmeye basma, bırakma) | |
FocusListener | public void addFocuslistener(FocusListener) | odak olayı (kazanıldı, kaybedildi) | |
KeyListener | public void addKeylistener(KeyListener) | klavye olayı (tuşa basıldı, basılı tutuldu, bırakıldı) |
Bileşen | Olay işleyicilerini kaydetme yöntemi |
JButton | public void addActionListener(ActionListener) |
JCheckbox | public void addItemListener(ItemListener) |
JCheckboxMenuItem | public void addItemListener(ItemListener) |
JComboBox | public void addItemListener(ItemListener) public void addActionListener(ActionListener) |
Container | public void addContainerListener(ContainerListener) |
JComponent | public void addComponentListener(ComponentListener) public void addFocusListener(FocusListener) public void addKeyListener(KeyListener) public void addMouseListener(MouseListener) public void addMouseMotionListener(MouseMotionListener) |
JFrame | public void addWindowlistener(WindowListener) |
JList | public void addItemListener(ItemListener) |
JMenuItem | public void addActionListener(ActionListener) |
JPanel | Container olarak |
JScrollPane | Container olarak |
JScrollBar | public void addAdjustmentListener(AdjustmentListener) |
JTextComponent | public void addInputMethodListener(InputMethodListener) public void addCaretListener(CaretListener) |
JTextArea | comme JTextComponent |
JTextField | JTextComponent gibi public void addActionListener(ActionListener) |
TextXXX türündeki bileşenler hariç, JComponent sınıfından türetilen tüm bileşenler, bu sınıfa ait yöntemlere de sahiptir.
5.1.5. Olay işleyicilerinin yöntemleri
Aşağıdaki tabloda, çeşitli olay işleyicilerinin uygulaması gereken yöntemler listelenmiştir.
Arayüz | Yöntemler |
ActionListener | public void actionPerformed(ActionEvent) |
AdjustmentListener | public void adjustmentValueChanged(AdjustmentEvent) |
ComponentListener | public void componentHidden(ComponentEvent) public void componentMoved(ComponentEvent) public void componentResized(ComponentEvent) public void componentShown(ComponentEvent) |
ContainerListener | public void componentAdded(ContainerEvent) public void componentRemoved(ContainerEvent) |
FocusListener | public void focusGained(FocusEvent) public void focusLost(FocusEvent) |
ItemListener | public void itemStateChanged(ItemEvent) |
KeyListener | public void keyPressed(KeyEvent) public void keyReleased(KeyEvent) public void keyTyped(KeyEvent) |
MouseListener | public void mouseClicked(MouseEvent) public void mouseEntered(MouseEvent) public void mouseExited(MouseEvent) public void mousePressed(MouseEvent) public void mouseReleased(MouseEvent) |
MouseMotionListener | public void mouseDragged(MouseEvent) public void mouseMoved(MouseEvent) |
TextListener | public void textValueChanged(TextEvent) |
InputmethodListener | public void InputMethodTextChanged(InputMethodEvent) public void caretPositionChanged(InputMethodEvent) |
CaretLisetner | public void caretUpdate(CaretEvent) |
WindowListener | public void windowActivated(WindowEvent) public void windowClosed(WindowEvent) public void windowClosing(WindowEvent) public void windowDeactivated(WindowEvent) public void windowDeiconified(WindowEvent) public void windowIconified(WindowEvent) public void windowOpened(WindowEvent) |
5.1.6. Adaptör sınıfları
WindowListener arayüzünde gördüğümüz gibi, XXXListener arayüzlerini boş yöntemlerle uygulayan XXXAdapter adlı sınıflar mevcuttur. XXXAdapter sınıfından türetilen bir olay işleyicisi, XXXListener arayüzündeki yöntemlerin yalnızca bir kısmını, yani uygulamanın ihtiyaç duyduğu yöntemleri uygulayabilir.
Örneğin, f1 adlı bir Frame bileşenindeki fare tıklamalarını yönetmek istediğimizi varsayalım. Buna bir olay işleyicisi şu şekilde atanabilir:
ve şöyle yazabiliriz:
public class gestionnaireSouris implements MouseListener{
// QZXW2HTML arayüzünün 5 yöntemini yazıyoruz CTW91c2VMaXN0ZW5lcgZQX
// mouseClicked, ..., mouseReleased)
}// sınıf sonu
Ancak, sadece fare tıklamalarını yönetmek istediğimiz için, şu şekilde yazmak daha uygun olur:
public class gestionnaireSouris extends MouseAdapter{
// tek bir yöntem yazıyoruz, o da fare tıklamalarını yöneten yöntem
public void mouseClicked(MouseEvent evt){
…
}
}// sınıf sonu
Aşağıdaki tablo, çeşitli olay yöneticilerinin adaptör sınıflarını göstermektedir:
Olay Yöneticisi | Adaptör |
ComponentListener | ComponentAdapter |
ContainerListener | ContainerAdapter |
FocusListener | FocusAdapter |
KeyListener | KeyAdapter |
MouseListener | MouseAdapter |
MouseMotionListener | MouseMotionAdapter |
WindowListener | WindowAdapter |
5.1.7. Sonuç
Az önce Java'da grafik kullanıcı arayüzü oluşturmanın temel kavramlarını ele aldık:
- pencere oluşturma
- bileşenlerin oluşturulması
- bileşenlerin bir düzen yöneticisi aracılığıyla pencereye eklenmesi
- bileşenlere olay işleyicilerinin eklenmesi
Şimdi, az önce yaptığımız gibi grafik kullanıcı arayüzlerini "elle" oluşturmak yerine, Borland/Inprise'ın Java geliştirme aracı olan JBuilder'ın 4. sürümünü kullanacağız ve Java'nın yaratıcısı Sun tarafından şu anda önerilen supérieure.Nous kütüphanesindeki bileşenleri kullanacağız.
5.2. JBuilder ile bir grafik arayüz oluşturma
5.2.1. İlk JBuilder projemiz
JBuilder'a alışmak için çok basit bir uygulama oluşturalım: boş bir pencere.
- Jbuilder'ı başlatın ve Dosya/Yeni Proje seçeneğini seçin. Ardından sihirbazın ilk sayfası görüntülenir:
- Aşağıdaki alanları doldurun:
Proje adı | Başlangıç Bu işlem, "Proje Klasör Adı" alanında belirtilen klasörün altına début.jpr adlı bir proje dosyası oluşturulmasını sağlayacaktır |
Kök yol | Oluşturacağınız proje klasörünün yer alacağı klasörü belirtin. |
Proje dizini adı | Projenin tüm dosyalarının yerleştirileceği klasörün adını belirtin. Bu klasör, "Kök yol" alanında belirtilen dizin altında oluşturulacaktır |
Kaynak dosyalar (.java, .html, ...), hedef dosyalar (.class, ...) ve yedekleme dosyaları farklı dizinlere yerleştirilebilir. İlgili alanlar boş bırakılırsa, bu dosyalar projeyle aynı dizine yerleştirilecektir.
[suivant]'i yapın
- Bir ekran, önceki adımda yapılan seçimleri onaylar
[suivant]'i seçin
- Yeni bir ekran, projenizi tanımlamanızı ister:
[terminer]'i seçin
- Voir/projet seçeneğinin işaretli olduğunu kontrol edin. Sol pencerede projenizin yapısını görmelisiniz.
- Şimdi bu projede bir grafik arayüz oluşturalım. Fichier/Nouveau/Application seçeneğini seçin:
classe alanına, oluşturulacak sınıfın adını girin. Burada projeyle aynı adı kullandık.
[suivant]'i seçin
- Aşağıdaki ekran görüntülenir:
Sınıf | interfaceDébut Bu, oluşturulacak pencereye karşılık gelen sınıfın adıdır |
Başlık | Pencerenin başlık çubuğunda görünecek metindir |
Yukarıda, uygulamanın başlatılmasıyla pencerenin ekranın ortasına yerleştirilmesini talep ettiğimizi unutmayın.
[Terminer] yazın
- İşte şimdi JBuilder işimize yarıyor.
- Uygulamanın sınıfı ve grafik arayüz sınıfı olmak üzere, isimlerini verdiğimiz iki sınıfın .java kaynak dosyalarını oluşturur. Bu iki dosya, sol pencerede proje yapısı içinde görünür
- Her iki sınıf için oluşturulan koda erişmek için ilgili .java dosyasına çift tıklamanız yeterlidir. Oluşturulan koda daha sonra tekrar döneceğiz.
- Voir/Structure seçeneğinin işaretli olduğunu kontrol edin. Bu seçenek, o anda seçili olan sınıfın yapısını görüntülemenizi sağlar (.java dosyasına çift tıklayın). Örneğin, début sınıfının yapısı şöyledir:
Burada şunları öğreniyoruz:
-
içe aktarılan kütüphaneler (imports)
-
début() adlı bir yapıcı olduğunu
-
main() adlı bir statik yöntem olduğu
-
packFrame adlı bir öznitelik olduğu
Bir sınıfın yapısına erişebilmenin ne gibi bir faydası vardır?
-
Sınıfın genel bir görünümünü elde edersiniz. Sınıfınız karmaşıksa bu yararlıdır.
-
Sınıf yapısı penceresinde bir yöntemin üzerine tıklayarak o yöntemin koduna erişebilirsiniz. Yine, sınıfınız yüzlerce satırdan oluşuyorsa bu yararlıdır. Aradığınız kodu bulmak için tüm satırları tek tek gözden geçirmek zorunda kalmazsınız.
JBuilder tarafından oluşturulan kod zaten kullanılabilir durumdadır. "Çalıştır/Projeyi Çalıştır" veya "F9" komutunu uyguladığınızda, istediğiniz pencere açılacaktır:
Ayrıca, pencerenin kapatma düğmesine tıklandığında pencere düzgün bir şekilde kapanır. Az önce ilk grafik kullanıcı arayüzümüzü oluşturduk. Dosya/Projeleri Kapat seçeneğiyle projemizi kaydedebiliriz:
Tous tuşuna basıldığında, yukarıdaki pencerede bulunan tüm projeler işaretlenecektir. OK tuşuna basıldığında ise bu projeler kapatılacaktır. Merak edersek, Windows Gezgini ile projemizin klasörüne (proje yapılandırmasının başında sihirbaza belirtilen klasör) gidersek, orada şu dosyaları buluruz:
Örneğimizde, tüm dosyaların (.java kaynak dosyası, .class hedef dosyası, .jpr~ yedek dosyası) .jpr projesiyle aynı klasörde olmasını istemiştik.
5.2.2. JBuilder tarafından bir grafik kullanıcı arayüzü için oluşturulan dosyalar
Şimdi JBuilder'ın hangi .java kaynak dosyalarını oluşturduğuna bir göz atalım. Çoğu zaman oluşturulan kodlara eklemeler yapmamız gerektiğinden, oluşturulan dosyaları okumayı bilmek önemlidir. Öncelikle projemizi açalım: Dosya/Proje Aç seçeneğine tıklayıp début.jpr projesini seçelim. Daha önce oluşturduğumuz projeyi görüyoruz.
5.2.2.1. Ana sınıf
Proje dosyalarının listelendiği pencerede début.java sınıfının adına çift tıklayarak bu sınıfı inceleyelim. Aşağıdaki kodu görüyoruz:
import javax.swing.UIManager;
import java.awt.*;
public class début {
boolean packFrame = false;
/**Uygulamayı oluşturma*/
public début() {
interfaceDébut frame = new interfaceDébut();
//Önceden tanımlanmış boyutlara sahip çerçeveleri doğrulayın
//Tercih edilen boyut bilgilerine sahip çerçeveleri sıkıştırın - örn. düzenlerinden
if (packFrame) {
frame.pack();
}
else {
frame.validate();
}
//Pencereyi ortala
Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
Dimension frameSize = frame.getSize();
if (frameSize.height > screenSize.height) {
frameSize.height = screenSize.height;
}
if (frameSize.width > screenSize.width) {
frameSize.width = screenSize.width;
}
frame.setLocation((screenSize.width - frameSize.width) / 2, (screenSize.height - frameSize.height) / 2);
frame.setVisible(true);
}
/**Ana yöntem*/
public static void main(String[] args) {
try {
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
}
catch(Exception e) {
e.printStackTrace();
}
new début();
}
}
Oluşturulan kodu inceleyelim:
- main işlevi, pencerenin (setLookAndFeel) görünümünü belirler ve début sınıfının bir örneğini oluşturur.
- Ardından début() oluşturucu işlevi çalıştırılır. Bu işlev, pencere sınıfından bir frame örneği oluşturur (new interfaceDébut()). Bu örnek oluşturulur ancak görüntülenmez.
- Ardından pencere, pencerenin her bir bileşeni (frame.validate) için mevcut bilgilere göre boyutlandırılır. Daha sonra görüntülenerek ve kullanıcının taleplerine yanıt vererek bağımsız varlığını sürdürmeye başlar.
- Pencere, sihirbazla pencereyi yapılandırırken bu şekilde ayarlandığı için ekranın ortasına yerleştirilir.
Bölümün başında yaptığımız gibi, début.java kodunu en basit haline indirgersek ne olacağını görelim. Yeni bir sınıf oluşturalım. Dosya/Yeni Sınıf seçeneğini seçin:
Yeni sınıfa début2 adını verin ve [Terminer]'i oluşturun. Projede yeni bir dosya belirir:
début2.java dosyası en basit haline indirgenmiştir:
Sınıfı şu şekilde tamamlayalım:
public class début2 {
// ana işlev
public static void main(String args[]){
// pencereyi oluşturur
new interfaceDébut().show(); // veya new interfaceDébut.setVisible(true);
}//ana
}//début2 sınıfı
main işlevi, interfaceDébut penceresinin bir örneğini oluşturur ve bunu görüntüler (show). Projemizi çalıştırmadan önce, çalıştırılacak main işlevini içeren sınıfın artık début2 sınıfı olduğunu belirtmeliyiz. début.jpr projesine sağ tıklayın ve propriétés seçeneğini, ardından Exécution sekmesini seçin:
21
Burada, ana sınıfın début (1) olduğu belirtilmiştir. Başka bir ana sınıf seçmek için (2) düğmesine basın:
début2'i seçin ve [OK]'i oluşturun.
Bu seçimi onaylamak için [OK]'i girin, ardından Çalıştır/Projeyi Çalıştır veya F9 komutuyla projenin çalıştırılmasını isteyin. début sınıfında olduğu gibi aynı pencereyi elde edersiniz, ancak burada bu talep edilmediğinden pencere ortalanmamıştır. Bundan sonra, JBuilder tarafından oluşturulan ana sınıfı artık göstermeyeceğiz çünkü her zaman aynı şeyi yapar: bir pencere oluşturur. Bundan sonra, bu pencerenin sınıfına odaklanacağız.
5.2.2.2. Pencere sınıfı
Şimdi interfaceDébut sınıfı için oluşturulan koda bir göz atalım:
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class interfaceDébut extends JFrame {
JPanel contentPane;
BorderLayout borderLayout1 = new BorderLayout();
/**Çerçeveyi oluştur*/
public interfaceDébut() {
enableEvents(AWTEvent.WINDOW_EVENT_MASK);
try {
jbInit();
}
catch(Exception e) {
e.printStackTrace();
}
}
/**Bileşeni başlat*/
private void jbInit() throws Exception {
contentPane = (JPanel) this.getContentPane();
contentPane.setLayout(borderLayout1);
this.setSize(new Dimension(400, 300));
this.setTitle("Ma première interface graphique avec Jbuilder");
}
/**Değiştirildi, böylece pencere kapatıldığında çıkabiliriz*/
protected void processWindowEvent(WindowEvent e) {
super.processWindowEvent(e);
if (e.getID() == WindowEvent.WINDOW_CLOSING) {
System.exit(0);
}
}
}
5.2.2.2.1. İçe aktarılan kütüphaneler
Bunlar, java.awt, java.awt.event ve javax.swing kütüphaneleridir. İlk iki kütüphane, Java'nın ilk sürümleriyle grafik arayüzler oluşturmak için kullanılabilen tek kütüphanelerdi. javax.swing kütüphanesi daha yenidir. Burada, kullanılan JFrame tipi pencere için bu kütüphane gereklidir.
5.2.2.2.2. Özellikler
JPanel, bileşenlerin yerleştirilebileceği bir konteyner türüdür. BorderLayout ise bileşenleri konteynere yerleştirmek için kullanılabilen biçimlendirme yöneticisi türlerinden biridir. Tüm örneklerimizde, biçimlendirme yöneticisi kullanmayacağız ve bileşenleri konteynerin belirli bir yerine kendimiz yerleştireceğiz. Bunun için null biçimlendirme yöneticisini kullanacağız.
5.2.2.2.3. Pencere oluşturucu
/**Çerçeveyi oluştur*/
public interfaceDébut() {
enableEvents(AWTEvent.WINDOW_EVENT_MASK);
try {
jbInit();
}
catch(Exception e) {
e.printStackTrace();
}
}
/**Bileşeni başlat*/
private void jbInit() throws Exception {
contentPane = (JPanel) this.getContentPane();
contentPane.setLayout(borderLayout1);
this.setSize(new Dimension(400, 300));
this.setTitle("Ma première interface graphique avec Jbuilder");
}
- Geliştirici, önce (enableEvents) penceresindeki olayları yöneteceğini belirtir, ardından jbInit yöntemini çalıştırır.
- Pencerenin (JFrame) kapsayıcısı (JPanel) alınır (getContentPane)
- Biçimlendirme yöneticisi belirlenir (setLayout)
- Pencerenin boyutu belirlenir (setSize)
- Pencerenin başlığı belirlenir (setTitle)
5.2.2.2.4. Olay yöneticisi
/**Değiştirildi; böylece pencere kapatıldığında çıkabiliriz*/
protected void processWindowEvent(WindowEvent e) {
super.processWindowEvent(e);
if (e.getID() == WindowEvent.WINDOW_CLOSING) {
System.exit(0);
}
Üretici, sınıfın pencere olaylarını işleyeceğini belirtmişti. Bu işi yapan yöntem processWindowEvent'tir. Öncelikle, alınan WindowEvent olayını üst sınıfına (JFrame) iletir; ardından bu olay, pencerenin kapatma düğmesine tıklanmasıyla tetiklenen WINDOW_CLOSING olayı ise uygulama sonlandırılır.
5.2.2.2.5. Sonuç
Pencere sınıfının kodu, bölümün başındaki örnekte sunulan koddan farklıdır. JBuilder dışında başka bir Java kod oluşturma aracı kullanmış olsaydık, muhtemelen yine farklı bir kod elde ederdik. Uygulamada, yalnızca grafik kullanıcı arayüzünün olay işleyicilerini yazmaya odaklanabilmek için, pencereyi oluşturmak üzere JBuilder tarafından üretilen kodu kabul edeceğiz.
5.2.3. Bir grafik kullanıcı arayüzü çizmek
5.2.3.1. Bir örnek
Önceki örnekte, pencereye herhangi bir bileşen eklememiştik. Şimdi bir düğme, bir etiket ve bir giriş alanı içeren bir pencere oluşturalım:
Alanlar şunlardır:
no | ad | tür | rol |
1 | lblSaisie | JLabel | bir açıklama |
2 | txtSaisie | JTextField | bir giriş alanı |
3 | cmdAfficher | JButton | giriş alanının içeriğini bir iletişim kutusunda görüntülemek için txtSaisie |
Önceki projede olduğu gibi, şimdilik pencereye herhangi bir bileşen eklemeden interface2.jpr projesini oluşturun.
Yukarıdaki pencerede, pencerenin interface2.java sınıfını seçin. Bu pencerenin sağında, sekmeli bir klasör bulunur:
Source sekmesi, interface2.java sınıfının kaynak koduna erişim sağlar. Conception sekmesi, pencereyi görsel olarak oluşturmanıza olanak tanır. Bu sekmeyi seçin. Karşınızda, üzerine yerleştireceğiniz bileşenleri barındıracak pencere konteyneri bulunmaktadır. Şu anda boştur. Soldaki pencerede sınıfın yapısı gösterilmektedir:
this | pencereyi temsil eder |
contentPane | bileşenlerin yerleştirileceği konteyner ve bu bileşenlerin konteyner içinde düzenlenme şekli (varsayılan olarak BorderLayout) |
borderLayout1 | bir biçimlendirme yöneticisi örneği |
this nesnesini seçin. Bunun üzerine sağ tarafta özellik penceresi açılır:
Bu özelliklerden bazılarına dikkat edilmelidir:
background | pencerenin arka plan rengini belirlemek için |
foreground | penceredeki çizimlerin rengini belirlemek için |
JMenuBar | pencereye bir menü eklemek için |
title | pencereye bir başlık vermek için |
resizable | pencere türünü belirlemek için |
font | penceredeki yazının yazı tipini belirlemek için |
this nesnesi hala seçiliyken, ekranda görüntülenen kapsayıcının etrafındaki bağlantı noktalarını sürükleyerek kapsayıcının boyutunu değiştirebilirsiniz:
Artık yukarıdaki kapsayıcıya bileşenler yerleştirebiliriz. Öncesinde, biçimlendirme yöneticisini değiştireceğiz. Yapı penceresinden contentPane nesnesini seçin:
Ardından bu nesnenin özellikler penceresinde layout özelliğini seçin ve olası değerler arasından null değerini seçin:
Biçimlendirme yöneticisinin olmaması, bileşenleri konteynere serbestçe yerleştirmemizi sağlayacaktır. Şimdi bunları seçme zamanı geldi.
Conception bölmesi seçildiğinde, bileşenler tasarım penceresinin üst kısmındaki sekmeli klasörde görüntülenir:
Grafik kullanıcı arayüzünü oluşturmak için swing (1) ve awt (2) bileşenleri mevcuttur. Burada swing bileşenlerini kullanacağız. Yukarıdaki bileşen çubuğundan bir JLabel (3) bileşeni, bir JTextField (4) bileşeni ve bir JButton (5) bileşeni seçin ve bunları tasarım penceresinin konteynerine yerleştirin.
Şimdi bu 3 bileşenin her birini özelleştirelim:
- etiket (JLabel) jLabel1
Bileşeni seçerek özellikler penceresini açın. Bu pencerede aşağıdaki özellikleri değiştirin: name: lblSaisie, text: Giriş
- giriş alanı (JTextField) jTextfield1
Bileşeni seçerek özellikler penceresini açın. Bu pencerede aşağıdaki özellikleri değiştirin: name: txtSaisie, text: boş bırakın
- düğme (JButton): name: cmdAfficher, text: Görüntüle
Şimdi karşımıza şu pencere çıkıyor:
ve aşağıdaki yapı:
Projemizi (F9) çalıştırarak pencerenin çalışırkenki ilk görünümünü görebiliriz:
Pencereyi kapatın. Şimdi Afficher düğmesine tıklandığında çalışacak yordamı yazmamız gerekiyor. Düğmeyi seçerek özellikler penceresine erişin. Bu pencerede iki sekme bulunur: propriétés ve événements. événements'i seçin.
Pencerenin sol sütununda, düğme üzerinde gerçekleşebilecek olaylar listelenir. Bir düğmeye tıklamak, actionPerformed olayına karşılık gelir. Sağ sütun, ilgili olay gerçekleştiğinde çağrılan yordamın adını içerir. actionPerformed olayının sağındaki hücreye tıklayın:
JBuilder, her olay işleyicisi için nomComposant_nomEvénement biçiminde bir varsayılan ad oluşturur; örneğin, cmdAfficher_actionPerformed. Varsayılan olarak önerilen adı silip başka bir ad girebilirsiniz. cmdAfficher_actionPerformed olay işleyicisinin koduna erişmek için yukarıdaki adına çift tıklamanız yeterlidir. Böylece otomatik olarak, olay işleyicisinin kod iskeletinin bulunduğu sınıfın kaynak bölmesine geçersiniz:
Artık bu kodu tamamlamamız gerekiyor. Burada, içinde txtSaisie alanının içeriğini barındıran bir iletişim kutusu görüntülemek istiyoruz:
void cmdAfficher_actionPerformed(ActionEvent e) {
JOptionPane.showMessageDialog(this, "texte saisi="+txtSaisie.getText(),
"Vérification de la saisie",JOptionPane.INFORMATION_MESSAGE);
}
JOptionPane, javax.swing kütüphanesinin bir sınıfıdır. Bu sınıf, bir simge eşliğinde mesajlar görüntülemek veya kullanıcıdan bilgi istemek için kullanılır. Burada, sınıfın statik bir yöntemini kullanıyoruz:
parentComponent | diyalog kutusunun "üst" konteyner nesnesi: burada this. |
mesaj | görüntülenecek bir nesne. Burada giriş alanının içeriği |
başlık | iletişim kutusunun başlığı |
messageType | görüntülenecek mesajın türü. Mesajın yanındaki kutuda görüntülenecek simgeyi belirler. Olası değerler: INFORMATION_MESSAGE, QUESTION_MESSAGE, ERROR_MESSAGE, WARNING_MESSAGE, PLAIN_MESSAGE |
Uygulamamızı (F9) çalıştıralım:
5.2.3.2. Pencere sınıfının kodu
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.beans.*;
import javax.swing.event.*;
public class interface2 extends JFrame {
JPanel contentPane;
JLabel lblSaisie = new JLabel();
JTextField txtSaisie = new JTextField();
JButton cmdAfficher = new JButton();
/**Çerçeveyi oluştur*/
public interface2() {
enableEvents(AWTEvent.WINDOW_EVENT_MASK);
try {
jbInit();
}
catch(Exception e) {
e.printStackTrace();
}
}
/**Bileşeni başlat*/
private void jbInit() throws Exception {
lblSaisie.setText("Saisie");
lblSaisie.setBounds(new Rectangle(25, 23, 71, 21));
contentPane = (JPanel) this.getContentPane();
contentPane.setLayout(null);
this.setSize(new Dimension(304, 129));
this.setTitle("Saisies & boutons - 1");
txtSaisie.setBounds(new Rectangle(120, 21, 138, 24));
cmdAfficher.setText("Afficher");
cmdAfficher.setBounds(new Rectangle(111, 77, 77, 20));
cmdAfficher.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) {
cmdAfficher_actionPerformed(e);
}
});
contentPane.add(lblSaisie, null);
contentPane.add(txtSaisie, null);
contentPane.add(cmdAfficher, null);
}
/**Değiştirildi; böylece pencere kapatıldığında çıkabiliriz*/
protected void processWindowEvent(WindowEvent e) {
super.processWindowEvent(e);
if (e.getID() == WindowEvent.WINDOW_CLOSING) {
System.exit(0);
}
}
void cmdAfficher_actionPerformed(ActionEvent e) {
JOptionPane.showMessageDialog(this, "texte saisi="+txtSaisie.getText(), "Vérification de la saisie",JOptionPane.INFORMATION_MESSAGE);
}
}
5.2.3.2.1. Özellikler
JPanel contentPane;
JLabel lblSaisie = new JLabel();
JTextField txtSaisie = new JTextField();
JButton cmdAfficher = new JButton();
JPanel tipi bileşenlerin bulunduğu kutu ve üç bileşen bulunmaktadır.
5.2.3.2.2. Üretici
/**Çerçeveyi oluştur*/
public interface2() {
enableEvents(AWTEvent.WINDOW_EVENT_MASK);
try {
jbInit();
}
catch(Exception e) {
e.printStackTrace();
}
}
/**Bileşeni başlat*/
private void jbInit() throws Exception {
lblSaisie.setText("Saisie");
lblSaisie.setBounds(new Rectangle(25, 23, 71, 21));
contentPane = (JPanel) this.getContentPane();
contentPane.setLayout(null);
this.setSize(new Dimension(304, 129));
this.setTitle("Saisies & boutons - 1");
txtSaisie.setBounds(new Rectangle(120, 21, 138, 24));
cmdAfficher.setText("Afficher");
cmdAfficher.setBounds(new Rectangle(111, 77, 77, 20));
cmdAfficher.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) {
cmdAfficher_actionPerformed(e);
}
});
contentPane.add(lblSaisie, null);
contentPane.add(txtSaisie, null);
contentPane.add(cmdAfficher, null);
}
interface2 oluşturucu, daha önce incelenen grafik arayüzün oluşturucusuna benzer. Farklılıklar jbInit yönteminde görülür: pencerenin oluşturma kodu, pencereye yerleştirilen bileşenlere bağlıdır. jbInit kodunu alıp üzerine kendi yorumlarımızı ekleyebiliriz:
private void jbInit() throws Exception {
// pencerenin kendisi (boyut, başlık)
this.setSize(new Dimension(304, 129));
this.setTitle("Saisies & boutons - 1");
// bileşenlerin konteyneri
contentPane = (JPanel) this.getContentPane();
// bu kapsayıcı için biçimlendirme yöneticisi yok
contentPane.setLayout(null);
// lblSaisie etiketi (ad, konum, boyut)
lblSaisie.setText("Saisie");
lblSaisie.setBounds(new Rectangle(25, 23, 71, 21));
// giriş alanı (konum, boyut)
txtSaisie.setBounds(new Rectangle(120, 21, 138, 24));
// Göster düğmesi (etiket, konum, boyut)
cmdAfficher.setText("Afficher");
cmdAfficher.setBounds(new Rectangle(111, 77, 77, 20));
// düğmenin olay işleyicisi
cmdAfficher.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) {
cmdAfficher_actionPerformed(e);
}
});
// 3 bileşenin konteynere eklenmesi
contentPane.add(lblSaisie, null);
contentPane.add(txtSaisie, null);
contentPane.add(cmdAfficher, null);
}//jbInit
İki noktaya dikkat çekmek gerekir:
- Bu kod elle de yazılabilirdi. Bu da, bir grafik arayüz oluşturmak için JBuilder'a gerek olmadığı anlamına gelir.
- cmdAfficher düğmesinin olay işleyicisinin ayarlandığı şekil. cmdAfficher bileşeninin olay işleyicisi, cmdAfficher.addActionListener(new işleyici()) şeklinde tanımlanabilirdi; burada gestionnaire, actionPerformed adlı, Afficher düğmesine yapılan tıklamayı yönetmekle görevli bir public yönteme sahip bir sınıf olurdu. Burada ise JBuilder, işleyici olarak isimsiz bir sınıfın bir örneğini kullanıyor:
new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) {
cmdAfficher_actionPerformed(e);
}
ActionListener arayüzünün yeni bir örneği oluşturulur ve actionPerformed yöntemi de hemen ardından tanımlanır. Bu yöntem, interface2 sınıfındaki bir yöntemi çağırmakla yetinir. Tüm bunlar, pencereyle aynı sınıfta bu penceredeki bileşenlerin olaylarını işleyen prosedürleri tanımlamak için kullanılan bir yöntemdir. Başka bir şekilde de ilerlenebilir:
Bu da actionPerformed yönteminin this içinde, yani pencere sınıfında aranmasına neden olur. Bu ikinci yöntem daha basit görünse de, ilk yöntemin bir avantajı vardır: farklı düğmeler için farklı işleyiciler kullanılmasına olanak tanır; oysa ikinci yöntem bunu mümkün kılmaz. İkinci durumda ise, tek bir actionPeformed yöntemi farklı düğmelere yapılan tıklamaları işlemek zorundadır ve bu nedenle çalışmaya başlamadan önce olayın kaynağını belirlemesi gerekir.
5.2.3.2.3. Olay işleyicileri
Daha önce incelediğimiz olay işleyicileri şunlardır:
/**Değiştirildi, böylece pencere kapatıldığında çıkabiliriz*/
protected void processWindowEvent(WindowEvent e) {
super.processWindowEvent(e);
if (e.getID() == WindowEvent.WINDOW_CLOSING) {
System.exit(0);
}
}
// "Göster" düğmesine tıklama
void cmdAfficher_actionPerformed(ActionEvent e) {
JOptionPane.showMessageDialog(this, "texte saisi="+txtSaisie.getText(), "Vérification de la saisie",JOptionPane.INFORMATION_MESSAGE);
}
5.2.3.3. Conclusion
İncelenen iki projeden, JBuilder ile grafik arayüz oluşturulduktan sonra, geliştiricinin görevi bu grafik arayüz için yönetmek istediği olay işleyicilerini yazmak olduğu sonucuna varabiliriz.
5.2.4. Yardım Arama
Java'da, özellikle mevcut sınıf sayısının çok fazla olması nedeniyle sıklıkla yardıma ihtiyaç duyulur. Burada, bir sınıf hakkında yardım bulmak için birkaç ipucu veriyoruz. Menüden Yardım/Yardım Konuları seçeneğini seçin.
Yardım ekranı genellikle iki pencereden oluşur:
- sol tarafta, aradığımız şeyi belirttiğimiz pencere bulunur. Bu pencerede üç sekme vardır: Sommaire, Index ve Chercher.
- sağdaki pencere ise arama sonucunu gösterir
JBuilder yardımını kullanma konusunda bir yardım metni mevcuttur. JBuilder yardımından "Yardım/Yardımı Kullanma" seçeneğini seçin. Ardından yardımın nasıl kullanılacağı açıklanır. Örneğin, yardım görüntüleyicisinin farklı bileşenleri size gösterilir:
Sommaire ve Index sayfalarını biraz daha yakından inceleyelim.
5.2.4.1. Yardım: İçindekiler
5.2.4.1.1. İçindekiler: Java'ya Giriş
Burada Java'nın temel unsurlarını bulabilirsiniz, ancak bu seçenek kapsamında ele alınan konu listesinden de anlaşılacağı üzere, sadece bunlarla sınırlı değildir:
5.2.4.1.2. İçindekiler: Öğreticiler
Yukarıdaki içindekiler bölümünden "Öğreticiler" seçeneğini seçtiğimizde, sağdaki pencerede mevcut öğreticilerin listesi görüntülenir:
Temel öğreticiler, JBuilder'ı kullanmaya başlamak için özellikle ilgi çekicidir. Yukarıda sunulanların dışında pek çok başka öğretici de mevcuttur ve bir uygulama geliştirmek istediğinizde, size yardımcı olabilecek bir öğretici olup olmadığını önceden kontrol etmek faydalı olabilir.
5.2.4.1.3. İçindekiler: JDK
Java 2 JDK 1.3 seçeneğini seçtiğinizde, JDK'teki tüm kütüphanelere erişebilirsiniz. Genellikle, belirli bir sınıf hakkında bilgiye ihtiyaç duyduğumuzda ve bu sınıfın hangi kütüphanede bulunduğunu bilmediğimizde, aramayı buradan başlatmamalıyız. Bununla birlikte, Java kütüphanelerine genel bir bakış elde etmek istiyorsak bu seçenek faydalı olabilir.
5.2.4.2. Yardım: Dizin
Yardım penceresinin sol tarafındaki Dizin sekmesini seçin. Bu seçenek, örneğin bir sınıf hakkında yardım bulmanızı sağlar. Örneğin, swing ve JTextField giriş alanlarının yöntemlerini öğrenmek istediğinizi varsayalım. Arama metni alanına JTextField yazın:
Yardım, yazdığınız metinle başlayan dizin girişlerini gösterecektir:
Şimdi ilgilendiğiniz girişe, bu örnekte JTextField sınıfına çift tıklamanız yeterlidir. Bu sınıfa ait yardım bilgisi sağdaki pencerede görüntülenir:
Böylece sınıfın tam açıklaması size sunulur.
5.2.5. Bazı Swing bileşenleri
Şimdi, en yaygın olarak kullanılan swing bileşenlerini içeren çeşitli uygulamaları sunarak, bu bileşenlerin temel yöntemlerini ve özelliklerini ele alacağız. Her uygulama için, grafik kullanıcı arayüzünü ve özellikle olay işleyicilerle ilgili kodları tanıtacağız.
5.2.5.1. JLabel ve JTextField bileşenleri
Bu iki bileşene daha önce rastlamıştık. JLabel bir metin bileşenidir ve JTextField bir giriş alanı bileşenidir. Bu bileşenlerin iki ana yöntemi şunlardır:
String getText() | giriş alanının içeriğini veya etiket metnini almak için |
void setText(String unTexte) | yöntemi, unTexte değerini alana veya etikete girmek içindir |
JTextField için genellikle kullanılan olaylar şunlardır:
actionPerformed | kullanıcının girilen metni onayladığını (Enter tuşuna bastığını) bildirir |
caretUpdate | kullanıcının giriş imlecini hareket ettirdiğini belirtir |
inputMethodChanged | kullanıcının giriş alanını değiştirdiğini bildirir |
Aşağıda, bir giriş alanındaki değişiklikleri takip etmek için caretUpdate olayını kullanan bir örnek yer almaktadır:
no | tür | ad | rol |
1 | JTextField | txtSaisie | giriş alanı |
2 | JTextField | txtControle | 1'deki metni gerçek zamanlı olarak görüntüler |
3 | JButton | cmdEffacer | 1 ve 2 numaralı alanları silmek için |
4 | JButton | cmdQuitter | uygulamadan çıkmak için |
Bu uygulamanın ilgili kodu şöyledir:
import java.awt.*;
....
public class Cadre1 extends JFrame {
JPanel contentPane;
JTextField txtSaisie = new JTextField();
JLabel jLabel1 = new JLabel();
JLabel jLabel2 = new JLabel();
JTextField txtControle = new JTextField();
JButton CmdEffacer = new JButton();
JButton CmdQuitter = new JButton();
/**Çerçeveyi oluştur*/
public Cadre1() {
enableEvents(AWTEvent.WINDOW_EVENT_MASK);
try {
jbInit();
}
catch(Exception e) {
e.printStackTrace();
}
}
/**Bileşeni başlat*/
private void jbInit() throws Exception {
....
txtSaisie.addCaretListener(new javax.swing.event.CaretListener() {
public void caretUpdate(CaretEvent e) {
txtSaisie_caretUpdate(e);
}
});
...
CmdEffacer.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) {
CmdEffacer_actionPerformed(e);
}
});
...
CmdQuitter.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) {
CmdQuitter_actionPerformed(e);
}
});
....
}
/**Değiştirildi, böylece pencere kapatıldığında çıkabiliriz*/
protected void processWindowEvent(WindowEvent e) {
...
}
void txtSaisie_caretUpdate(CaretEvent e) {
// giriş imleci hareket etti
txtControle.setText(txtSaisie.getText());
}
void CmdQuitter_actionPerformed(ActionEvent e) {
// uygulamadan çıkılıyor
System.exit(0);
}
void CmdEffacer_actionPerformed(ActionEvent e) {
// giriş alanının içeriği siliniyor
txtSaisie.setText("");
}
}
İşte bir çalışma örneği:
5.2.5.2. JComboBox bileşeni
JComboBox bileşeni, bir giriş alanı ile birlikte açılır bir listedir: kullanıcı ya (2) numaralı listeden bir öğe seçebilir ya da (1) numaralı alana metin girebilir. Varsayılan olarak, JComboBox bileşenleri düzenlenemez. Düzenlenebilir hale getirmek için setEditable(true) yöntemini açıkça çağırmanız gerekir. JComboBox sınıfını incelemek için yardım dizinine JComboBox yazın.
JComboBox nesnesi çeşitli şekillerde oluşturulabilir:
new JComboBox() | boş bir açılır menü oluşturur |
new JComboBox (Object[] items) | bir nesne dizisi içeren bir açılır menü oluşturur |
new JComboBox(Vector items) | aynı şekilde bir nesne vektörü içerir |
Bir kombo kutusunun genellikle karakter dizeleri içerirken nesneler de içerebilmesi şaşırtıcı gelebilir. Görsel olarak durum böyledir. Bir JComboBox, bir obj nesnesi içeriyorsa, obj.toString dizesini görüntüler() dizesi görüntülenir. Her nesnenin, Object sınıfından miras alınan ve nesneyi "temsil eden" bir karakter dizesi döndüren toString yöntemine sahip olduğunu hatırlayalım.
JCombobox sınıfının kullanışlı yöntemleri şunlardır:
void addItem(Object unObjet) | bir nesneyi açılır menüye ekler |
int getItemCount() | kombinasyon listesindeki öğe sayısını verir |
Object getItemAt(int i) | kombinasyon menüsündeki i numaralı nesneyi döndürür |
void insertItemAt(Object unObjet, int i) | unObjet öğesini kombo kutusunun i konumuna ekler |
int getSelectedIndex() | kombinasyon listesinden seçilen öğenin numarasını verir |
Object getSelectedItem() | kombinasyon listesinden seçilen nesneyi döndürür |
void setSelectedIndex(int i) | kombinasyon listesinden i numaralı öğeyi seçer |
void setSelectedItem(Object unObjet) | kombinasyon listesindeki belirtilen nesneyi seçer |
void removeAllItems() | kombinasyon listesini boşaltır |
void removeItemAt(int i) | kombinasyon listesinden i numaralı öğeyi kaldırır |
void removeItem(Object unObjet) | belirtilen nesneyi açılır menüden kaldırır |
void setEditable(boolean val) | kombinasyon listesini düzenlenebilir (val=true) veya düzenlenemez (val=false) hale getirir |
Açılır listeden bir öğe seçildiğinde actionPerformed olayı tetiklenir; bu olay, açılır listedeki seçim değişikliğinden haberdar olmak için kullanılabilir. Aşağıdaki uygulamada, bu olayı kullanarak listeden seçilen öğeyi görüntülüyoruz.
Pencerenin yalnızca ilgili kodunu sunuyoruz.
public class Cadre1 extends JFrame {
JPanel contentPane;
JComboBox jComboBox1 = new JComboBox();
JLabel jLabel1 = new JLabel();
/**Çerçeve oluşturuluyor*/
public Cadre1() {
enableEvents(AWTEvent.WINDOW_EVENT_MASK);
try {
jbInit();
}
catch(Exception e) {
e.printStackTrace();
}
// işlem - açılır menü dolduruluyor
String[] infos={"un","deux","trois","quatre"};
for(int i=0;i<infos.length;i++)
jComboBox1.addItem(infos[i]);
}
/**Bileşeni başlat*/
private void jbInit() throws Exception {
....
jComboBox1.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) {
jComboBox1_actionPerformed(e);
}
});
....
}
void jComboBox1_actionPerformed(ActionEvent e) {
// yeni bir öğe seçildi - görüntülenir
JOptionPane.showMessageDialog(this,jComboBox1.getSelectedItem(),
"actionPerformed",JOptionPane.INFORMATION_MESSAGE);
}
}
5.2.5.3. JList bileşeni
JList swing bileşeni, awt kütüphanesindeki muadili bileşene göre daha karmaşıktır. İki önemli fark vardır:
- Listenin içeriği, listenin kendisinden farklı bir nesne tarafından yönetilir. Burada, Vector gibi kullanılan, ancak içeriği değiştiğinde JList nesnesini uyaran ve böylece listenin görsel görüntüsünün de değişmesini sağlayan bir DefaultListModel nesnesi kullanacağız.
- Liste varsayılan olarak kaydırılabilir değildir. Listenin, kaydırma özelliğini sağlayan bir ScrollPane konteynerine yerleştirilmesi gerekir.
Kaynak kodda, bir listenin tanımı şu şekilde yapılabilir:
// listenin değer vektörü
DefaultlistModel valeurs=new DefaultListModel();
// değer vektörüyle ilişkilendirilen listenin kendisi
JList jList1 = new JList(valeurs);
// kaydırmalı liste elde etmek için listenin yerleştirildiği kaydırmalı konteyner
JScrollPane jScrollPane1 = new JScrollPane(jList1);
jList1 listesini jScrollPane1 konteynerine dahil etmek için, JBuilder tarafından oluşturulan kod farklı bir şekilde işlem yapar:
- pencerenin özelliklerinde kapsayıcının tanımlanması
- ardından jbInit kodunda liste,
Yukarıdaki JList1 listesine değerler eklemek için, bunları valeurs değer vektörüne eklemek yeterlidir:
Böylece aşağıdaki pencere açılır:
Bu arayüz nasıl oluşturulur?
- Bileşenlerin "Swing Konteynerleri" sayfasından JScrollPane bileşenini seçip, istenen boyuta ayarlayarak pencereye sürüklüyoruz
- Bileşenlerin "Swing" sayfasından bir JList bileşeni seçip, onu JScrollPane konteynerine bırakırız; böylece bileşen konteynerin tüm alanını kaplar.
JBuilder tarafından oluşturulan kod, aşağıdaki kodu elde etmek için biraz değiştirilmelidir:
public class interfaceAppli extends JFrame {
JPanel contentPane;
JLabel jLabel1 = new JLabel();
DefaultListModel valeurs=new DefaultListModel();
JList jList1 = new JList(valeurs);
JScrollPane jScrollPane1 = new JScrollPane();
JLabel jLabel2 = new JLabel();
/**Çerçeveyi oluştur*/
public interfaceAppli() {
enableEvents(AWTEvent.WINDOW_EVENT_MASK);
try {
jbInit();
}
catch(Exception e) {
e.printStackTrace();
}
// işleme
// listeyi scrollPane içine ekliyoruz
// liste başlatma
for(int i=0;i<10;i++)
valeurs.addElement(""+i);
}
/**Bileşeni başlat*/
private void jbInit() throws Exception {
....
// jList1 listesi, jcrollPane1 konteynerine atanır
jScrollPane1.getViewport().add(jList1, null);
}
/**Değiştirildi, böylece pencere kapatıldığında çıkabiliriz*/
protected void processWindowEvent(WindowEvent e) {
....
}
}
Şimdi, yardım dizininde JList'i arayarak JList sınıfının temel yöntemlerini inceleyelim. JList nesnesi çeşitli şekillerde oluşturulabilir:
Kullandığımız yöntem basit bir yöntemdir: boş bir DefaultListModel V nesnesi oluşturup, bunu new JList(V) komutuyla oluşturulacak listeyle ilişkilendirmek. Listenin içeriği JList nesnesi tarafından değil, listenin değerlerini içeren nesne tarafından yönetilir. İçerik, Vector sınıfına dayanan bir DefaultListModel nesnesi kullanılarak oluşturulmuşsa, listeye öğe eklemek, araya yerleştirmek ve silmek için Vector sınıfının yöntemleri kullanılabilir. Bir liste, tekli veya çoklu seçimli olabilir. Bu, setSelectionMode yöntemi ile belirlenir:
getSelectionMode ile mevcut seçim modunu öğrenebilirsiniz:
Seçilen öğe veya öğeler aşağıdaki yöntemler aracılığıyla elde edilebilir:
JList(DefaultListModel) oluşturucu ile bir değer vektörünü bir listeye eşleştirebiliriz. Tersine, bir JList listesinden DefaultListModel nesnesini şu şekilde elde edebiliriz:
Şu uygulamayı yazmak için yeterli bilgiye sahibiz:
Bu pencerenin bileşenleri şunlardır:
No | tür | ad | işlev |
1 | JTextField | txtSaisie | giriş alanı |
2 | JList | jList1 | bir kapsayıcıda bulunan liste jScrollPane1 |
3 | JList | jList2 | bir kapsayıcıda bulunan liste jScrollPane2 |
4 | JButton | cmd1To2 | seçilen öğeleri liste 1'den liste 2'ye aktarır |
5 | JButton | cmd2To1 | tersini yapar |
6 | JButton | cmdRaz1 | Liste 1'i boşalt |
7 | JButton | cmdRaz2 | Liste 2'yi boşalt |
Kullanıcı (1) numaralı alana metin girer ve onaylar. Ardından, girilen metni liste 1'e eklemek için kullanılan giriş alanında actionPerformed olayı gerçekleşir. İşte bu ilk işlev için gerekli kod:
public class interfaceAppli extends JFrame {
JPanel contentPane;
JLabel jLabel1 = new JLabel();
JLabel jLabel2 = new JLabel();
JLabel jLabel3 = new JLabel();
JTextField txtSaisie = new JTextField();
JButton cmd1To2 = new JButton();
JButton cmd2To1 = new JButton();
DefaultListModel v1=new DefaultListModel();
DefaultListModel v2=new DefaultListModel();
JList jList1 = new JList(v1);
JList jList2 = new JList(v2);
JScrollPane jScrollPane1 = new JScrollPane();
JScrollPane jScrollPane2 = new JScrollPane();
JButton cmdRaz1 = new JButton();
JButton cmdRaz2 = new JButton();
JLabel jLabel4 = new JLabel();
/**Çerçeveyi oluştur*/
public interfaceAppli() {
enableEvents(AWTEvent.WINDOW_EVENT_MASK);
try {
jbInit();
}
catch(Exception e) {
e.printStackTrace();
}
}//interfaceAppli
/**Bileşeni başlat*/
private void jbInit() throws Exception {
...
txtSaisie.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) {
txtSaisie_actionPerformed(e);
}
});
...
// Jlist1, jScrollPane1 konteynerine yerleştirilir
jScrollPane1.getViewport().add(jList1, null);
// Jlist2, jScrollPane2 konteynerine yerleştirildi
jScrollPane2.getViewport().add(jList2, null);
...
}
/**Değiştirildi, böylece pencere kapatıldığında çıkabiliriz*/
protected void processWindowEvent(WindowEvent e) {
...
}
void txtSaisie_actionPerformed(ActionEvent e) {
// giriş metni onaylandı
// Başlangıç ve bitiş boşlukları temizlenmiş haliyle alınır
String texte=txtSaisie.getText().trim();
// boşsa, kabul edilmez
if(texte.equals("")){
// hata mesajı
JOptionPane.showMessageDialog(this,"Vous devez taper un texte",
"Erreur",JOptionPane.WARNING_MESSAGE);
// son
return;
}//if
// boş değilse, liste 1'deki değerlere eklenir
v1.addElement(texte);
// ve giriş alanını boşalt
txtSaisie.setText("");
}/// txtSaisie_actionperformed
}//sınıf
Bir listeden diğerine seçilen öğeleri aktarmak için kullanılan kod şöyledir:
void cmd1To2_actionPerformed(ActionEvent e) {
// Liste 1'den seçilen öğelerin Liste 2'ye aktarılması
transfert(jList1,jList2);
}//cmd1To2
void cmd2To1_actionPerformed(ActionEvent e) {
// jList2'te seçilen öğelerin jList1'e aktarılması
transfert(jList2,jList1);
}//cmd2TO1
private void transfert(JList L1, JList L2){
// Liste 1'de seçilen öğelerin Liste 2'ye aktarılması
// L1'te seçilen öğelerin indeks tablosu alınır
int[] indices=L1.getSelectedIndices();
// Yapılması gereken bir şey var mı?
if (indices.length==0) return;
// L1'ten değerleri alıyoruz
DefaultListModel v1=(DefaultListModel)L1.getModel();
// ve L2'teki değerler
DefaultListModel v2=(DefaultListModel)L2.getModel();
for(int i=indices.length-1;i>=0;i--){
// L1'te seçilen değerleri L2'e ekliyoruz
v2.addElement(v1.elementAt(indices[i]));
// L1'ten L2'e kopyalanan öğeler, L1'ten silinmelidir
v1.removeElementAt(indices[i]);
}//için
}//aktarım
Raz düğmeleriyle ilişkili kod son derece basittir:
void cmdRaz1_actionPerformed(ActionEvent e) {
// Liste 1'i boşalt
v1.removeAllElements();
}//Raz1 komutu
void cmdRaz2_actionPerformed(ActionEvent e) {
// liste 2'yi boşalt
v2.removeAllElements();
}///cmd Raz2
5.2.5.4. JCheckBox onay kutuları, JButtonRadio radyo düğmeleri
Aşağıdaki uygulamayı yazmayı planlıyoruz:
Pencerenin bileşenleri şunlardır:
No | tür | ad | işlev |
1 | JButtonRadio | jButtonRadio1 jButtonRadio2 jButtonRadio3 | buttonGroup1 grubuna ait 3 radyo düğmesi |
2 | JCheckBox | jCheckBox1 jCheckBox2 jCheckBox3 | 3 onay kutusu |
3 | JList | jList1 | bir konteyner içindeki liste jScrollPane1 |
4 | ButtonGroup | buttonGroup1 | görünmeyen bileşen - 3 radyo düğmesini bir araya getirmek için kullanılır; böylece bunlardan biri yandığında diğerleri söner. |
Bir radyo düğmesi grubu şu şekilde oluşturulabilir:
- radyo düğmelerinin her birini, gruplandırmaya dikkat etmeden yerleştirin
- konteynere bir ButtonGroup swing bileşeni yerleştirilir. Bu bileşen görünmez. Dolayısıyla pencere tasarımcısında görünmez. Ancak yapısında görünür:
Yukarıda, Autre dalında pencerenin görünmez öznitelikleri görülmektedir. Bir radyo düğmesi grubu oluşturulduktan sonra, her bir radyo düğmesini bu gruba atayabiliriz. Bunu yapmak için, radyo düğmesinin özelliklerini seçin:
ve radyo düğmesinin buttonGroup özelliğine, radyo düğmesini eklemek istediğiniz grubun adını girin; burada buttonGroup1. Bu işlemi 3 radyo düğmesi için de tekrarlayın.
Radyo düğmeleri ve onay kutularının ana yöntemi, kutunun veya düğmenin işaretli olup olmadığını belirten isSelected() yöntemidir. Bileşene ait metin, getText() ile öğrenilebilir ve setText(String unTexte) ile belirlenebilir. Onay kutusu/radyo düğmesi, setSelected(boolean value) yöntemi ile işaretlenebilir.
Bir radyo düğmesine veya onay kutusuna tıklandığında, actionPerformed olayı tetiklenir. Aşağıdaki kodda, radyo düğmeleri ve onay kutularındaki değer değişikliklerini takip etmek için bu olayı kullanıyoruz:
public class interfaceAppli extends JFrame {
JPanel contentPane;
JRadioButton jRadioButton1 = new JRadioButton();
JRadioButton jRadioButton2 = new JRadioButton();
JRadioButton jRadioButton3 = new JRadioButton();
JCheckBox jCheckBox1 = new JCheckBox();
JCheckBox jCheckBox2 = new JCheckBox();
JCheckBox jCheckBox3 = new JCheckBox();
ButtonGroup buttonGroup1 = new ButtonGroup();
JScrollPane jScrollPane1 = new JScrollPane();
DefaultListModel valeurs=new DefaultListModel();
JList jList1 = new JList(valeurs);
/**Çerçeveyi oluştur*/
public interfaceAppli() {
enableEvents(AWTEvent.WINDOW_EVENT_MASK);
try {
jbInit();
}
catch(Exception e) {
e.printStackTrace();
}
}
/**Bileşeni başlat*/
private void jbInit() throws Exception {
jRadioButton1.setSelected(true);
jRadioButton1.setText("un");
jRadioButton1.setBounds(new Rectangle(57, 31, 49, 23));
jRadioButton1.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) {
afficheRadioButtons(e);
}
});
jRadioButton2.setBounds(new Rectangle(113, 30, 49, 23));
jRadioButton2.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) {
afficheRadioButtons(e);
}
});
jRadioButton2.setText("deux");
jRadioButton3.setBounds(new Rectangle(168, 30, 49, 23));
jRadioButton3.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) {
afficheRadioButtons(e);
}
});
jRadioButton3.setText("trois");
// radyo düğmeleri gruplandırıldı
buttonGroup1.add(jRadioButton1);
buttonGroup1.add(jRadioButton2);
buttonGroup1.add(jRadioButton3);
// onay kutuları
jCheckBox1.setText("A");
jCheckBox1.setBounds(new Rectangle(58, 69, 32, 17));
jCheckBox1.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) {
afficheCases(e);
}
});
jCheckBox2.setBounds(new Rectangle(112, 69, 40, 17));
jCheckBox2.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) {
afficheCases(e);
}
});
jCheckBox2.setText("B");
jCheckBox3.setText("C");
jCheckBox3.setBounds(new Rectangle(170, 69, 37, 17));
jCheckBox3.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) {
afficheCases(e);
}
});
....
}
/**Değiştirildi, böylece pencere kapatıldığında çıkabiliriz*/
protected void processWindowEvent(WindowEvent e) {
...
}
private void afficheRadioButtons(ActionEvent e){
// 3 radyo düğmesinin değerlerini gösterir
valeurs.addElement("boutons radio=("+jRadioButton1.isSelected()+","+
jRadioButton2.isSelected()+","+jRadioButton3.isSelected()+")");
}//afficheRadioButtons
void afficheCases(ActionEvent e) {
// onay kutularının değerlerini gösterir
valeurs.addElement("cases à cocher=["+jCheckBox1.isSelected()+","+
jCheckBox2.isSelected()+","+jCheckBox3.isSelected()+")");
}//afficheCases
}//sınıflandırır
İşte bir çalışma örneği:
5.2.5.5. JScrollBar bileşeni
Şu uygulamayı oluşturalım:
no | tür | ad | rol |
1 | JScrollBar | jScrollBar1 | bir yatay frekans dönüştürücü |
2 | JScrollBar | jScrollBar2 | bir dikey hız regülatörü |
3 | JTextField | txtvaleurHS | yatay sürücünün değerini gösterir 1 - bu değeri sabitlemek için de kullanılır |
4 | JTextField | txtvaleurVS | dikey 2'nin değerini gösterir - bu değeri sabitlemek için de kullanılır |
- Bir JScrollBar kaydırıcı, kullanıcının, üzerinde bir imleç hareket eden kaydırıcının "şeridi" ile simgelenen tam sayı aralığından bir değer seçmesine olanak tanır.
- Yatay bir kaydırıcıda sol uç aralığın minimum değerini, sağ uç ise maksimum değerini temsil eder; imleç ise seçilen mevcut değeri gösterir. Dikey bir kaydırıcıda ise minimum değer üst uçta, maksimum değer ise alt uçta gösterilir. (min,max) çifti varsayılan olarak (0,100) değerindedir.
- Döner kontrolün uçlarına tıklamak, tıklanan uca göre değeri bir artış (pozitif veya negatif) kadar değiştirir; bu artış, varsayılan olarak 1 olan unitIncrement olarak adlandırılır.
- İmlecin her iki yanına tıklamak, tıklandığı uca göre değeri bir artış (pozitif veya negatif) kadar değiştirir; bu artış, varsayılan değeri 10 olan blockIncrement olarak adlandırılır.
- Bu beş değer (min, max, değer, unitIncrement, blockIncrement) getMinimum(), getMaximum(), getValue(), getUnitIncrement(), getBlockIncrement() yöntemleriyle öğrenilebilir; bu yöntemlerin tümü bir tamsayı döndürür ve setMinimum(int min), setMaximum(int max), setValue(int val), setUnitIncrement(int uInc), setBlockIncrement(int bInc)
JScrollBar bileşenlerinin kullanımında bilinmesi gereken birkaç nokta vardır. Öncelikle, bu bileşen Swing bileşen çubuğunda bulunur:
Bunu konteynere sürükleyip bıraktığınızda, varsayılan olarak dikey konumdadır. Aşağıdaki orientation özelliği ile yatay hale getirebilirsiniz:
Yukarıdaki özellik sayfasında minimum, maximum, value, unitIncrement, blockIncrement özelliklerine erişebildiğimiz görülüyor. Dolayısıyla bunları tasarım aşamasında ayarlayabiliriz. Konteynere bir kaydırma çubuğu yerleştirildiğinde, "değişim aralığı" görünmüyor:
Bu sorunu, bileşene bir kenarlık ekleyerek çözebiliriz. Bu, farklı değerler alabilen border özelliği ile yapılır:
Örneğin, RaisedBevel değeri uygulandığında sonuç şöyle olur:
Dikey bir kaydırıcının üst ucuna tıklandığında, değeri azalır. Bu durum, normalde değerin "artmasını" bekleyen ortalama bir kullanıcıyı şaşırtabilir. Bu sorun, unitIncrement ve blockIncrement özelliklerine negatif bir değer atanarak çözülür.
Bir kaydırma çubuğundaki değişiklikleri nasıl takip edebiliriz? Kaydırma çubuğunun değeri değiştiğinde, adjustmentValueChanged olayı gerçekleşir. Kaydırma çubuğunun değerindeki her değişiklikten haberdar olmak için bu olaya bir prosedür atamak yeterlidir.
Uygulamamızın kod kısmı şu şekildedir:
....
public class cadreAppli extends JFrame {
JPanel contentPane;
JScrollBar jScrollBar1 = new JScrollBar();
Border border1;
JTextField txtValeurHS = new JTextField();
JScrollBar jScrollBar2 = new JScrollBar();
JTextField txtValeurVS = new JTextField();
TitledBorder titledBorder1;
/**Çerçeveyi oluştur*/
public cadreAppli() {
enableEvents(AWTEvent.WINDOW_EVENT_MASK);
try {
jbInit();
}
catch(Exception e) {
e.printStackTrace();
}
}
/**Bileşeni başlat*/
private void jbInit() throws Exception {
...
// kaydırma çubukları için kenarlık
border1 = BorderFactory.createBevelBorder(BevelBorder.RAISED,Color.white,Color.white,new Color(134, 134, 134),new Color(93, 93, 93));
// çerçeve için başlık yok
titledBorder1 = new TitledBorder("");
jScrollBar1.setOrientation(JScrollBar.HORIZONTAL);
jScrollBar1.setBorder(BorderFactory.createRaisedBevelBorder());
jScrollBar1.setAutoscrolls(true);
jScrollBar1.setBounds(new Rectangle(37, 17, 218, 20));
jScrollBar1.addAdjustmentListener(new java.awt.event.AdjustmentListener() {
public void adjustmentValueChanged(AdjustmentEvent e) {
jScrollBar1_adjustmentValueChanged(e);
}
});
txtValeurHS.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) {
txtValeurHS_actionPerformed(e);
}
});
jScrollBar2.setBounds(new Rectangle(39, 51, 30, 27));
jScrollBar2.addAdjustmentListener(new java.awt.event.AdjustmentListener() {
public void adjustmentValueChanged(AdjustmentEvent e) {
jScrollBar2_adjustmentValueChanged(e);
}
});
jScrollBar2.setAutoscrolls(true);
jScrollBar2.setUnitIncrement(-1);
jScrollBar2.setBorder(BorderFactory.createRaisedBevelBorder());
txtValeurVS.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) {
txtValeurVS_actionPerformed(e);
}
});
......
}
/**Değiştirildi, böylece pencere kapatıldığında çıkabiliriz*/
protected void processWindowEvent(WindowEvent e) {
...
}
void jScrollBar1_adjustmentValueChanged(AdjustmentEvent e) {
// kaydırma çubuğu 1'in değeri değişti
txtValeurHS.setText(""+jScrollBar1.getValue());
}
void jScrollBar2_adjustmentValueChanged(AdjustmentEvent e) {
// kaydırma çubuğu 2'nin değeri değişti
txtValeurVS.setText(""+jScrollBar2.getValue());
}
void txtValeurHS_actionPerformed(ActionEvent e) {
// yatay kaydırma çubuğunun değeri sabitleniyor
setValeur(jScrollBar1,txtValeurHS);
}
void txtValeurVS_actionPerformed(ActionEvent e) {
// dikey kaydırma çubuğunun değeri sabitleniyor
setValeur(jScrollBar2,txtValeurVS);
}
private void setValeur(JScrollBar jS, JTextField jT){
// jS kaydırma çubuğunun değeri, jT alanındaki metinle sabitleniyor
int valeur=0;
try{
valeur=Integer.parseInt(jT.getText());
jS.setValue(valeur);
}
catch (Exception e){
// hatayı görüntüler
afficher(""+e);
}//try-catch
}//setValeur
void afficher(String message){
// bir kutuda mesaj görüntüleniyor
JOptionPane.showMessageDialog(this,message,"Menus",JOptionPane.INFORMATION_MESSAGE);
}//görüntüle
}
İşte bir çalışma örneği:
5.2.5.6. JTextArea bileşeni
JTextArea bileşeni, yalnızca bir satır metin girilebilen JTextField bileşeninin aksine, birden fazla satır metin girilebilen bir bileşendir. Bu bileşen kaydırmalı bir kapsayıcıya (JScrollPane) yerleştirilirse, kaydırmalı bir metin giriş alanı elde edilir. Bu tür bir bileşen, örneğin gönderilecek mesajın metninin bir JTextArea bileşenine yazıldığı bir e-posta uygulamasında karşımıza çıkabilir. Yaygın olarak kullanılan yöntemler şunlardır: metin alanının içeriğini öğrenmek için String getText(), setText(String unTexte) metni metin alanına yazmak için, append(String unTexte) ise metin alanında halihazırda bulunan metne unTexte'i eklemek için kullanılır. Aşağıdaki uygulamayı ele alalım:
no | tür | ad | rol |
1 | JTextArea | txtTexte | çok satırlı bir metin alanı |
2 | JButton | cmdAfficher | 1'in içeriğini bir iletişim kutusunda görüntüler |
3 | JButton | cmdEffacer | 1'in içeriğini siler |
4 | JTextField | txtAjout | Enter tuşuyla onaylandığında 1 numaralı metne eklenen metin. |
5 | JScrollPane | jScrollPane1 | Kaydırılabilir metin alanı oluşturmak için metin alanı 1'in yerleştirildiği kaydırılabilir konteyner. |
İlgili kod şöyledir:
.....
public class cadreAppli extends JFrame {
JPanel contentPane;
JLabel jLabel1 = new JLabel();
JButton cmdAfficher = new JButton();
JScrollPane jScrollPane1 = new JScrollPane();
JTextArea txtTexte = new JTextArea();
JLabel jLabel2 = new JLabel();
JTextField txtAjout = new JTextField();
JButton cmdEffacer = new JButton();
/**Çerçeveyi oluştur*/
public cadreAppli() {
enableEvents(AWTEvent.WINDOW_EVENT_MASK);
try {
jbInit();
}
catch(Exception e) {
e.printStackTrace();
}
}
/**Bileşeni başlat*/
private void jbInit() throws Exception {
cmdAfficher.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) {
cmdAfficher_actionPerformed(e);
}
});
txtAjout.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) {
txtAjout_actionPerformed(e);
}
});
cmdEffacer.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) {
cmdEffacer_actionPerformed(e);
}
});
.......
jScrollPane1.getViewport().add(txtTexte, null);
}
/**Değiştirildi, böylece pencere kapatıldığında çıkabiliriz*/
protected void processWindowEvent(WindowEvent e) {
........
}
void cmdAfficher_actionPerformed(ActionEvent e) {
// TextArea'in içeriğini görüntüler
afficher(txtTexte.getText());
}
void afficher(String message){
// bir kutuda bir mesaj görüntüler
JOptionPane.showMessageDialog(this,message,"Suivi",JOptionPane.INFORMATION_MESSAGE);
}// görüntüle
void cmdEffacer_actionPerformed(ActionEvent e) {
txtTexte.setText("");
}//cmdEffacer_actionPerformed
void txtAjout_actionPerformed(ActionEvent e) {
// metin ekleme
txtTexte.append(txtAjout.getText());
// sıfırla ekle
txtAjout.setText("");
}//
}
5.2.6. Fare olayları
Bir kapsayıcıda çizim yaparken, örneğin tıklama sırasında bir nokta görüntülemek için farenin konumunu bilmek önemlidir. Farenin hareketleri, farenin içinde hareket ettiği kapsayıcıda olaylara neden olur. Örneğin, JBuilder tarafından JPanel kapsayıcısı için sunulan olaylar şunlardır:
mouseClicked | fare tıklaması |
mouseDragged | fare hareket ediyor, sol tuş basılı |
mouseEntered | fare, konteynerin alanına yeni girdi |
mouseExited | fare, konteynerin yüzeyinden az önce çıktı |
mouseMoved | fare hareket ediyor |
mousePressed | Farenin sol tuşuna basıldı |
mouseReleased | Farenin sol tuşunun bırakılması |
İşte, farklı fare olaylarının ne zaman gerçekleştiğini daha iyi anlamanıza yardımcı olacak bir program:
no | tür | ad | rol |
1 | JTextField | txtPosition | fare konumunu konteyner içinde görüntülemek için (gerekirse MouseMoved) |
2 | JList | lstAffichage | MouseMoved dışındaki fare olaylarını görüntülemek için |
3 | JButton | cmdEffacer | 2'nin içeriğini silmek için |
Bu programı çalıştırdığımızda, bir tıklama için şu sonuç elde edilir:
Olaylar listede yukarıdan aşağıya doğru sıralanır. Ayrıca yukarıdaki ekran görüntüsü, bir tıklamanın sırasıyla şu üç olayı tetiklediğini göstermektedir:
- MousePressed düğmeye basıldığında
- MouseReleased düğme bırakıldığında
- MouseClicked, önceki iki olayın ardışık olarak gerçekleşmesinin bir tıklama olarak kabul edildiğini gösterir. Bu bir çift tıklama olabilir. Ancak yukarıdaki clickCount=1 bilgisi, bunun tek bir tıklama olduğunu gösterir.
Şimdi düğmeye basıp fareyi hareket ettirdikten sonra düğmeyi bırakırsak:
Burada üç olay görülüyor:
- MousePressed: Düğmeye ilk basıldığında
- MouseDragged: fare hareket ettirilirken, düğme basılıyken
- MouseReleased: düğme bırakıldığında
Yukarıdaki iki örnekte de görüldüğü gibi, bir fare olayı, farenin (x, y) koordinatları gibi çeşitli bilgileri beraberinde getirir; örneğin, yukarıdaki ilk satırda (408,65).
Böyle devam edersek, MouseExited olayının, fare konteynerden çıktığında veya konteynerdeki bileşenlerden birinin üzerine geldiğinde tetiklendiğini görürüz. Bu son durumda, konteyner MouseExited olayını, bileşen ise MouseEntered olayını alır. Fare, bileşenden ayrılıp konteynere geri döndüğünde ise tam tersi gerçekleşir.
Çift tıklama yapıldığında ne olur?
Tek tıklamada olduğu gibi tam olarak aynı olaylar gerçekleşir. Ancak olay, aslında bir çift tıklama yapıldığını belirten clickCount=2 (yukarıya bakın) bilgisini de beraberinde getirir.
Bu uygulamanın ilgili kodu şöyledir:
public class Cadre1 extends JFrame {
JPanel contentPane;
JLabel jLabel1 = new JLabel();
JTextField txtPosition = new JTextField();
JScrollPane jScrollPane1 = new JScrollPane();
DefaultListModel valeurs=new DefaultListModel();
JList lstAffichage = new JList(valeurs);
JButton cmdEffacer = new JButton();
/**Çerçeveyi oluştur*/
public Cadre1() {
enableEvents(AWTEvent.WINDOW_EVENT_MASK);
try {
jbInit();
}
catch(Exception e) {
e.printStackTrace();
}
}
/**Bileşeni başlat*/
private void jbInit() throws Exception {
contentPane.addMouseMotionListener(new java.awt.event.MouseMotionAdapter() {
public void mouseMoved(MouseEvent e) {
contentPane_mouseMoved(e);
}
public void mouseDragged(MouseEvent e) {
contentPane_mouseDragged(e);
}
});
contentPane.addMouseListener(new java.awt.event.MouseAdapter() {
public void mouseEntered(MouseEvent e) {
contentPane_mouseEntered(e);
}
public void mouseExited(MouseEvent e) {
contentPane_mouseExited(e);
}
public void mousePressed(MouseEvent e) {
contentPane_mousePressed(e);
}
public void mouseClicked(MouseEvent e) {
contentPane_mouseClicked(e);
}
public void mouseReleased(MouseEvent e) {
contentPane_mouseReleased(e);
}
});
cmdEffacer.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) {
cmdEffacer_actionPerformed(e);
}
});
jScrollPane1.getViewport().add(lstAffichage, null);
...............
}
/**Değiştirildi, böylece pencere kapatıldığında çıkabiliriz*/
protected void processWindowEvent(WindowEvent e) {
.........
}
void contentPane_mouseMoved(MouseEvent e) {
txtPosition.setText("("+e.getX()+","+e.getY()+")");
}
void contentPane_mouseDragged(MouseEvent e) {
afficher(e);
}
void contentPane_mouseEntered(MouseEvent e) {
afficher(e);
}
void afficher(MouseEvent e){
// olayı listede görüntüler lstAffichage
valeurs.insertElementAt(e,0);
}
void contentPane_mouseExited(MouseEvent e) {
afficher(e);
}
void contentPane_mousePressed(MouseEvent e) {
afficher(e);
}
void contentPane_mouseClicked(MouseEvent e) {
afficher(e);
}
void contentPane_mouseReleased(MouseEvent e) {
afficher(e);
}
void cmdEffacer_actionPerformed(ActionEvent e) {
// listeyi siler
valeurs.removeAllElements();
}
}
5.2.7. Menü içeren bir pencere oluşturma
Şimdi JBuilder ile menülü bir pencereyi nasıl oluşturacağımıza bakalım. Aşağıdaki pencereyi oluşturacağız:
Başlangıçta boş bir pencere içeren yeni bir proje oluşturun. "Swing Konteynerleri" bileşen listesinden JMenuBar bileşenini seçin (aşağıdaki Şekil 1'e bakın) ve bunu tasarlamakta olduğunuz pencereye sürükleyip bırakın.
Tasarım penceresinde hiçbir şey görünmez, ancak JMenuBar bileşeni pencerenizin yapı panelinde görünür:
Yukarıdaki jMenuBar1 öğesine çift tıklayarak tasarım modu menüsüne erişin:
1 | menü öğesi ekleme |
2 | ayırıcı ekle |
3 | iç içe geçmiş menü ekleme |
4 | menü öğesini sil |
5 | bir menü öğesini devre dışı bırakma |
6 | işaretlenebilir menü öğesi |
7 | radyo düğmesini ters çevirme |
İlk menü öğenizi oluşturmak için, yukarıdaki A kutusuna "Seçenekler A" yazın, ardından altına sırasıyla şunu yazın: A1, A2, ayırıcı, A3, A4.
Ardından yanına:
B3'in iç içe geçmiş bir alt menü olduğunu belirtmek için 3 numaralı aracı kullanın.
Menü tasarımı ilerledikçe, penceremizin mantıksal yapısı da değişiyor:
Uygulamamızı şimdi çalıştırırsak, menüsü olmayan boş bir pencere göreceğiz. Oluşturduğumuz menüyü penceremize bağlamamız gerekiyor. Bunun için pencere yapısında this nesnesini seçin:
Böylece this nesnesinin özelliklerine erişebilirsiniz:
Bu özelliklerden biri, pencereye eklenecek menüyü belirlemeye yarayan JMenuBar'tir. JMenuBar'in sağındaki hücreye tıklayın. O zaman oluşturulan tüm menüler size sunulacaktır. Burada sadece jMenuBar1 olacaktır. Bunu seçin.
Uygulamayı (F9) çalıştırın:
Şu anda bir menümüz var, ancak seçenekler şimdilik hiçbir işlev görmüyor. Menü seçenekleri bileşenler gibi işlenir: özellikleri ve olayları vardır. Menü yapısında jMenuItem1 seçeneğini seçin:
Böylece bu seçeneğin özelliklerine ve olaylarına erişebilirsiniz:
Olaylar sayfasını seçin ve actionPerformed olayının sağındaki hücreye tıklayın: bu, bir menü öğesine tıklandığında gerçekleşen olaydır. Varsayılan olarak bir işleme prosedürü sunulur. Koduna erişmek için üzerine çift tıklayın:
Aşağıdaki basit kodu yazacağız:
void jMenuItem1_actionPerformed(ActionEvent e) {
afficher("L'option A1 a été sélectionnée");
}
void afficher(String message){
// bir kutuda mesaj görüntüler
JOptionPane.showMessageDialog(this,message,"Menus",JOptionPane.INFORMATION_MESSAGE);
}//görüntüle
Uygulamayı çalıştırın ve A1 seçeneğini seçin; ardından aşağıdaki mesajı alacaksınız:
Bu uygulamanın kaynak kodu şöyledir:
.....
public class Cadre1 extends JFrame {
JPanel contentPane;
BorderLayout borderLayout1 = new BorderLayout();
JMenuBar jMenuBar1 = new JMenuBar();
JMenu jMenu1 = new JMenu();
JMenuItem jMenuItem1 = new JMenuItem();
JMenuItem jMenuItem2 = new JMenuItem();
JMenuItem jMenuItem3 = new JMenuItem();
JMenuItem jMenuItem4 = new JMenuItem();
JMenu jMenu2 = new JMenu();
JMenuItem jMenuItem5 = new JMenuItem();
JMenuItem jMenuItem6 = new JMenuItem();
JMenu jMenu3 = new JMenu();
JMenuItem jMenuItem7 = new JMenuItem();
JMenuItem jMenuItem8 = new JMenuItem();
JMenuItem jMenuItem9 = new JMenuItem();
/**Çerçeveyi oluştur*/
public Cadre1() {
enableEvents(AWTEvent.WINDOW_EVENT_MASK);
try {
jbInit();
}
catch(Exception e) {
e.printStackTrace();
}
}
/**Bileşeni başlat*/
private void jbInit() throws Exception {
// pencere bir menüye eklenir
this.setJMenuBar(jMenuBar1);
jMenu1.setText("Options A");
jMenuItem1.setText("A1");
jMenuItem1.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) {
jMenuItem1_actionPerformed(e);
}
});
jMenuItem2.setText("A2");
jMenuItem3.setText("A3");
jMenuItem4.setText("A4");
jMenu2.setText("Options B");
jMenuItem5.setText("B1");
jMenuItem6.setText("B2");
jMenu3.setText("B3");
jMenuItem7.setText("B31");
jMenuItem8.setText("B32");
jMenuItem9.setText("B4");
jMenuBar1.add(jMenu1);
jMenuBar1.add(jMenu2);
jMenu1.add(jMenuItem1);
jMenu1.add(jMenuItem2);
jMenu1.addSeparator();
jMenu1.add(jMenuItem3);
jMenu1.add(jMenuItem4);
jMenu2.add(jMenuItem5);
jMenu2.add(jMenuItem6);
jMenu2.add(jMenu3);
jMenu2.add(jMenuItem9);
jMenu3.add(jMenuItem7);
jMenu3.add(jMenuItem8);
}
/**Değiştirildi, böylece pencere kapatıldığında çıkabiliriz*/
protected void processWindowEvent(WindowEvent e) {
....
}
void jMenuItem1_actionPerformed(ActionEvent e) {
afficher("L'option A1 a été sélectionnée");
}
void afficher(String message){
// bir kutuda mesaj görüntüler
JOptionPane.showMessageDialog(this,message,"Menus",JOptionPane.INFORMATION_MESSAGE);
}//görüntüle
}
5.3. Diyalog kutuları
5.3.1. Mesaj kutuları
Mesajları görüntülemek için daha önce JOptionPane sınıfını kullanmıştık. Dolayısıyla aşağıdaki kod:
import javax.swing.*;
public class dialog1 {
public static void main(String arg[]){
JOptionPane.showMessageDialog(null,"Un message","Titre de la boîte",JOptionPane.INFORMATION_MESSAGE);
}
}
aşağıdaki kutuyu görüntüler:
Bu pencere kapatıldığında kaybolur, ancak pencerenin çalıştığı yürütme iş parçacığı durdurulmaz. Bu durum normalde meydana gelmez. Diyalog pencereleri, bir noktada tüm iş parçacıklarını durdurmak için System.exit(n) komutunu kullanan bir uygulama içinde kullanılır. Aynı model üzerine kurulu olacak ilerideki örneklerde bu hususu göz önünde bulunduracağız. DOS ortamında uygulama Ctrl-C tuşlarıyla durdurulabilir. JBuilder ile birlikte, "Programı Çalıştır/Sıfırla" (Ctrl-F2) seçeneği kullanılacaktır. Ayrıca, showMessageDialog komutunun ilk argümanı burada null'tir. Genellikle durum böyle değildir. Genellikle this'tir; burada this, uygulamanın ana penceresini belirtir.
5.3.2. Görünüm ve Hissiyat
Yukarıdaki kutunun görünümü farklı olabilir. Bu görünümü javax.swing.UIManager sınıfı aracılığıyla ayarlamak mümkündür. İlk penceremiz için JBuilder tarafından oluşturulan kodu incelediğimizde, üzerinde durmadığımız bir komutla karşılaştık:
UIManager sınıfındaki (UI=Kullanıcı Arayüzü) setLookAndFeel yöntemi, grafik arayüzlerin görünümünü belirlemeye olanak tanır. UIManager sınıfı, arayüzler için olası “görünümleri” öğrenmeye yarayan bir yönteme sahiptir:
static UIManager.LookAndFeelInfo[] | getInstalledLookAndFeels() |
Bu yöntem, LookAndFeelInfo türünde öğelerden oluşan bir dizi döndürür. Bu sınıfın bir yöntemi vardır:
String | getClassName() |
Bu yöntem, belirli bir görünümü "uygulayan" sınıfın adını verir. Aşağıdaki programı deneyelim:
import javax.swing.*;
public class LookAndFeels {
// kullanılabilir görünüm ve hisleri gösterir
public static void main(String[] args) {
// yüklü görünüm ve hisleri listeler
UIManager.LookAndFeelInfo[] lf=UIManager.getInstalledLookAndFeels();
// görüntüleme
for(int i=0;i<lf.length;i++){
System.out.println(lf[i].getClassName());
}//için
}//ana sayfa
}//sınıflandırma
Aşağıdaki sonuçları verir:
javax.swing.plaf.metal.MetalLookAndFeel
com.sun.java.swing.plaf.motif.MotifLookAndFeel
com.sun.java.swing.plaf.windows.WindowsLookAndFeel
Görünüşe göre üç farklı "görünüm" var. Mesaj görüntüleme programımıza geri dönüp olası farklı görünümleri deneyelim:
import javax.swing.*;
public class LookAndFeel2 {
// kullanılabilir görünüm ve hisleri gösterir
public static void main(String[] args) {
// yüklü görünüm ve hislerin listesi
UIManager.LookAndFeelInfo[] lf=UIManager.getInstalledLookAndFeels();
// görüntüleme
for(int i=0;i<lf.length;i++){
// görünüm yöneticisi
try{
UIManager.setLookAndFeel(lf[i].getClassName());
}catch(Exception ex){
System.err.println(ex.getMessage());
}//yakalama
// mesaj
JOptionPane.showMessageDialog(null,"Un message",lf[i].getClassName(),JOptionPane.INFORMATION_MESSAGE);
}//for
}//ana işlev
}//sınıf
Çalıştırıldığında aşağıdaki çıktılar elde edilir:
 |  |  |
Bunlar sağdan sola sırasıyla Metal, Desen ve Windows "görünümlerine" karşılık gelir.
5.3.3. Onay kutuları
JOptionPane sınıfı, showConfirmDialog yöntemini kullanarak Oui, Non, Annuler düğmeleriyle onay kutularını görüntülemek için bir yöntem içerir. Birkaç showConfirmDialog yöntemi vardır. Bunlardan birini inceleyeceğiz:
static int | showConfirmDialog(Component parentComponent, Object message, String title, int optionType) |
parentComponent | diyalog kutusunun üst bileşeni. Genellikle pencere veya null değeri |
message | görüntülenecek mesaj |
title | kutunun başlığı |
optionType | JOptionPane.YES_NO_OPTION: Evet, Hayır düğmeleri JOptionPane.YES_NO_CANCEL_OPTION: Evet, Hayır, İptal düğmeleri |
Yöntemin döndürdüğü sonuç şudur:
JOptionPane.YES_OPTION | kullanıcı "evet"e tıkladı |
JOptionPane.NO_OPTION | kullanıcı "hayır"a tıkladı |
JOptionPane.CANCEL_OPTION | kullanıcı "İptal"e tıkladı |
JOptionPane.CLOSED_OPTION | kullanıcı kutuyu kapattı |
İşte bir örnek:
import javax.swing.*;
public class confirm1 {
public static void main(String[] args) {
// onay kutularını görüntüler
int réponse;
affiche(JOptionPane.showConfirmDialog(null,"Voulez-vous continuer ?","Confirmation",JOptionPane.YES_NO_OPTION));
affiche(JOptionPane.showConfirmDialog(null,"Voulez-vous continuer ?","Confirmation",JOptionPane.YES_NO_CANCEL_OPTION));
}//ana sayfa
private static void affiche(int réponse){
// hangi türde bir yanıt alındığını gösterir
switch(réponse){
case JOptionPane.YES_OPTION :
System.out.println("Oui");
break;
case JOptionPane.NO_OPTION :
System.out.println("Non");
break;
case JOptionPane.CANCEL_OPTION :
System.out.println("Annuler");
break;
case JOptionPane.CLOSED_OPTION :
System.out.println("Fermeture");
break;
}//anahtarı
}//ekran
}//sınıf
 |  |
Konsolda, Non ve Annuler mesajları görüntülenir.
5.3.4. Giriş alanı
JOptionPane sınıfı, showInputDialog yöntemi ile veri girişi yapma olanağı da sunar. Burada da yine birkaç aşırı yüklenmiş yöntem bulunmaktadır. Bunlardan birini aşağıda sunuyoruz:
static String | showInputDialog(Component parentComponent, Object message, String title, int messageType) |
Bağlamlar, daha önce birkaç kez karşılaştığımız bağlamlardır. Bu yöntem, kullanıcı tarafından girilen karakter dizisini döndürür. İşte bir örnek:
import javax.swing.*;
public class input1 {
public static void main(String[] args) {
// giriş
System.out.println("Chaîne saisie ["+
JOptionPane.showInputDialog(null,"Quel est votre nom","Saisie du nom",JOptionPane.QUESTION_MESSAGE )
+ "]");
}//el
}//sınıf
Giriş kutusunun görüntüsü:
Konsol ekranı:
5.4. Seçim kutuları
Şimdi Java 2'de önceden tanımlanmış bir dizi seçim kutusuna göz atacağız:
JFileChooser | dosya ağacında bir dosya seçmeye yarayan seçim kutusu |
JColorChooser | renk seçmeye yarayan seçim kutusu |
5.4.1. JFileChooser seçim kutusu
Aşağıdaki uygulamayı oluşturacağız:
Kontroller şunlardır:
No | tür | ad | rol |
0 | JScrollPane | jScrollPane1 | Metin kutusu 1 için kayan konteyner |
1 | JTextArea, JScrollPane içinde yer alır | txtTexte | kullanıcı tarafından yazılan veya bir dosyadan yüklenen metin |
2 | JButton | btnSauvegarder | 1'deki metni bir metin dosyasına kaydetmeye olanak tanır |
3 | JButton | btnCharger | bir metin dosyasının içeriğini 1'e yükler |
4 | JButton | btnEffacer | 1'in içeriğini siler |
Görsel olmayan bir kontrol kullanılır: jFileChooser1. Bu kontrol, JBuilder'in Swing konteyner paletinden alınır:
Bileşeni tasarım penceresine, ancak formun dışına yerleştiriyoruz. Bileşen, bileşenler listesinde görünür:
Şimdi genel bir bakış elde etmek için programın ilgili kodunu veriyoruz:
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.filechooser.FileFilter;
import java.io.*;
public class dialogues extends JFrame {
// çerçeve bileşenleri
JPanel contentPane;
JButton btnSauvegarder = new JButton();
JButton btnCharger = new JButton();
JButton btnEffacer = new JButton();
JScrollPane jScrollPane1 = new JScrollPane();
JTextArea txtTexte = new JTextArea();
JFileChooser jFileChooser1 = new JFileChooser();
// dosya filtreleri
javax.swing.filechooser.FileFilter filtreTxt = null;
//Çerçeveyi oluştur
public dialogues() {
enableEvents(AWTEvent.WINDOW_EVENT_MASK);
try {
jbInit();
// diğer başlatma işlemleri
moreInit();
}
catch(Exception e) {
e.printStackTrace();
}
}
// moreInit
private void moreInit(){
// pencere oluşturulurken yapılan ayarlamalar
// *.txt filtresi
filtreTxt = new javax.swing.filechooser.FileFilter(){
public boolean accept(File f){
// f kabul ediliyor mu?
return f.getName().toLowerCase().endsWith(".txt");
}//kabul
public String getDescription(){
// filtre açıklaması
return "Fichiers Texte (*.txt)";
}//getDescription
};
// filtre ekleniyor
jFileChooser1.addChoosableFileFilter(filtreTxt);
// ayrıca tüm dosyalar için filtre de istiyoruz
jFileChooser1.setAcceptAllFileFilterUsed(true);
// FileChooser kutusunun başlangıç dizinini geçerli dizine ayarlıyoruz
jFileChooser1.setCurrentDirectory(new File("."));
}
//Bileşeni başlat
private void jbInit() throws Exception {
.......................
}
//Değiştirildi; böylece pencere kapatıldığında çıkabiliriz
protected void processWindowEvent(WindowEvent e) {
......................
}
}
void btnCharger_actionPerformed(ActionEvent e) {
// JFileChooser nesnesi kullanılarak bir dosya seçilir
// başlangıç filtresini ayarlıyoruz
jFileChooser1.setFileFilter(filtreTxt);
// seçim kutusu görüntüleniyor
int returnVal = jFileChooser1.showOpenDialog(this);
// Kullanıcı bir seçim yaptı mı?
if(returnVal == JFileChooser.APPROVE_OPTION) {
// dosyayı metin alanına yerleştirilir
lireFichier(jFileChooser1.getSelectedFile());
}//if
}//btnCharger_actionPerformed
// lireFichier
private void lireFichier(File fichier){
// "fichier" adlı metin dosyasının içeriğini metin alanına görüntüler
// metin alanı silinir
txtTexte.setText("");
// bazı veriler
BufferedReader IN=null;
String ligne=null;
try{
// dosyayı okuma modunda açar
IN=new BufferedReader(new FileReader(fichier));
// dosyayı satır satır okur
while((ligne=IN.readLine())!=null){
txtTexte.append(ligne+"\n");
}//while
// dosya kapatılıyor
IN.close();
}catch(Exception ex){
// bir hata oluştu
txtTexte.setText(""+ex);
}//catch
}
// sil
void btnEffacer_actionPerformed(ActionEvent e) {
// metin kutusu siliniyor
txtTexte.setText("");
}
// kaydet
void btnSauvegarder_actionPerformed(ActionEvent e) {
// metin kutusunun içeriğini bir dosyaya kaydediyor
// başlangıç filtresini ayarlar
jFileChooser1.setFileFilter(filtreTxt);
// kaydetme seçim kutusu görüntülenir
int returnVal = jFileChooser1.showSaveDialog(this);
// kullanıcı bir seçim yaptı mı?
if(returnVal == JFileChooser.APPROVE_OPTION) {
// metin kutusunun içeriği dosyaya yazılır
écrireFichier(jFileChooser1.getSelectedFile());
}//if
}
// lireFichier
private void écrireFichier(File fichier){
// metin kutusunun içeriğini dosyaya yazıyor
// bazı veriler
PrintWriter PRN=null;
try{
// dosyayı yazma modunda açar
PRN=new PrintWriter(new FileWriter(fichier));
// metin kutusunun içeriği yazılır
PRN.print(txtTexte.getText());
// dosyayı kapatır
PRN.close();
}catch(Exception ex){
// bir hata oluştu
txtTexte.setText(""+ex);
}//hata yakalama
}
btnEffacer_Click, lireFichier ve écrireFichier yöntemlerinin kodları hakkında yorum yapmayacağız, çünkü bunlar daha önce görmediğimiz hiçbir şey getirmiyor. JFileChooser sınıfı ve kullanımına odaklanacağız. Bu sınıf, "aşırı karmaşık" türden bir yapıya sahiptir. Burada yalnızca aşağıdaki yöntemleri kullanacağız:
addChoosableFilter(FileFilter) | seçim için sunulan dosya türlerini belirler |
setAcceptAllFileFilterUsed(boolean) | "Tüm dosyalar" türünün seçim için sunulup sunulmayacağını belirler |
File getSelectedFile() | kullanıcı tarafından seçilen dosya (File) |
int showSaveDialog() | kaydetme seçim kutusunu görüntüleyen yöntem. int türünde bir sonuç döndürür. jFileChooser.APPROVE_OPTION değeri, kullanıcının geçerli bir seçim yaptığını gösterir. Aksi takdirde, kullanıcı seçimi iptal etmiş ya da bir hata meydana gelmiştir. |
setCurrentDirectory | kullanıcının dosya sistemini taramaya başlayacağı başlangıç dizinini belirlemek için |
setFileFilter(FileFilter) | etkin filtreyi ayarlamak için |
showSaveDialog yöntemi, aşağıdakine benzer bir seçim kutusu görüntüler:
1 | addChoosableFilter yöntemi ile oluşturulan bir açılır liste. Bu liste, FileFilter sınıfı ile temsil edilen seçim filtrelerini içerir. Bu filtreleri tanımlamak ve listeye eklemek geliştiricinin sorumluluğundadır 1. |
2 | Geçerli klasör; bu yöntem kullanılmışsa setCurrentDirectory yöntemi ile belirlenir, aksi takdirde geçerli dizin Windows'ta "Belgelerim" klasörü veya Unix'te ana dizin olacaktır. |
3 | Kullanıcı tarafından seçilen veya doğrudan girilen dosya adı. getSelectedFile() yöntemi ile kullanılabilir olacaktır. |
4 | Kaydet/İptal düğmeleri. Enregistrer düğmesi kullanılırsa, showSaveDialog yöntemi jFileChooser.APPROVE_OPTION sonucunu döndürür |
Açılır liste 1'deki dosya filtreleri nasıl oluşturulur? Filtreler, şu yöntem kullanılarak liste 1'e eklenir:
addChoosableFilter(FileFilter) | , JFileChooser sınıfının |
JFileChooser sınıfı. Geriye FileFilter sınıfını tanımak kalıyor. Aslında bu, javax.swing.filechooser.FileFilter sınıfıdır; bu da c.a.d adlı soyut bir sınıftır. Bu sınıfın örneği oluşturulamaz, yalnızca bu sınıftan türetilebilir. Şu şekilde tanımlanmıştır:
FileFilter() | yapıcı |
boolean accept(File) | f dosyasının filtreye ait olup olmadığını belirtir |
String getDescription() | filtrenin açıklama dizesi |
Bir örnek verelim. 1 numaralı açılır menünün, "Metin dosyaları (*.txt)" açıklamasına sahip *.txt dosyalarını seçmek için bir filtre sunmasını istiyoruz.
- Bunun için FileFilter sınıfından türetilmiş bir sınıf oluşturmamız gerekiyor
- f dosyasının adı .txt ile bitiyorsa, true değerini döndürmek için boolean accept(File f) yöntemini kullanmalıyız
- "Metin dosyaları (*.txt)" açıklamasını döndürmek için String getDescription() yöntemini kullanmalıyız
Bu filtre, uygulamamızda şu şekilde tanımlanabilir:
javax.swing.filechooser.FileFilter filtreTxt = new javax.swing.filechooser.FileFilter(){
public boolean accept(File f){
// f kabul ediliyor mu?
return f.getName().toLowerCase().endsWith(".txt");
}//kabul
public String getDescription(){
// filtre açıklaması
return "Fichiers Texte (*.txt)";
}//getDescription
};
Bu filtre, aşağıdaki komutla jFileChooser1 nesnesinin filtre listesine eklenecektir:
Tüm bunlar ve birkaç başka başlatma işlemi, pencerenin oluşturulması sırasında yürütülen moreInit yönteminde gerçekleştirilir (yukarıdaki tam programa bakınız). Sauvegarder düğmesinin kodu şöyledir:
void btnSauvegarder_actionPerformed(ActionEvent e) {
// metin kutusunun içeriğini bir dosyaya kaydeder
// başlangıç filtresini sabitler
jFileChooser1.setFileFilter(filtreTxt);
// kaydetme seçim kutusu görüntülenir
int returnVal = jFileChooser1.showSaveDialog(this);
// Kullanıcı bir seçim yaptı mı?
if(returnVal == JFileChooser.APPROVE_OPTION) {
// metin kutusunun içeriğini dosyaya yazıyor
écrireFichier(jFileChooser1.getSelectedFile());
}//if
}
İşlem sırası şu şekildedir:
- Kullanıcının tercihen bu tür dosyaları arayabilmesi için etkin filtre *.txt olarak ayarlanır. "Tüm dosyalar" filtresi de mevcuttur. Bu filtre, moreInit prosedürüne eklenmiştir. Dolayısıyla iki filtre bulunmaktadır.
- kaydetme seçim kutusu görüntülenir. Burada kontrolü kaybederiz; kullanıcı, dosya sisteminden bir dosya seçmek için seçim kutusunu kullanır.
- Seçim kutusundan çıktığında, metin kutusunun kaydedilip kaydedilmeyeceğini belirlemek için dönüş değeri kontrol edilir. Kaydedilecekse, getSelectedFile yöntemi ile elde edilen dosyaya kaydedilmelidir.
"Yükle" düğmesiyle ilgili kod, "Kaydet" düğmesinin koduna çok benzerdir.
void btnCharger_actionPerformed(ActionEvent e) {
// JFileChooser nesnesi kullanılarak bir dosya seçilir
// başlangıç filtresini ayarlıyoruz
jFileChooser1.setFileFilter(filtreTxt);
// seçim kutusu görüntülenir
int returnVal = jFileChooser1.showOpenDialog(this);
// Kullanıcı bir seçim yaptı mı?
if(returnVal == JFileChooser.APPROVE_OPTION) {
// dosyayı metin alanına yerleştirilir
lireFichier(jFileChooser1.getSelectedFile());
}//if
}//btnCharger_actionPerformed
İki fark vardır:
- Dosya seçim kutusunu görüntülemek için showSaveDialog yöntemi yerine showOpenDialog yöntemi kullanılır. Görüntülenen seçim kutusu, showSaveDialog yöntemi ile görüntülenen kutuya benzerdir.
- Kullanıcı bir dosya seçtiyse, écrireFichier yöntemi yerine lireFichier yöntemi çağrılır.
5.4.1.1. JColorChooser ve JFontChooser seçim kutuları
Önceki örneğe iki yeni düğme ekleyerek devam ediyoruz:
No | tür | ad | rol |
6 | JButton | btnCouleur | TextBox karakterlerinin rengini ayarlamak için |
7 | JButton | btnPolice | TextBox'in yazı tipini ayarlamak için |
Renk seçim kutusu görüntülemek için kullanılan JColorChooser bileşeni, JBuilder'in Swing bileşenleri listesinde bulunabilir:
Bu bileşeni tasarım penceresine, ancak formun dışına yerleştiriyoruz. Formda görünmez, ancak pencerenin bileşen listesinde yer alır:
JColorChooser sınıfı oldukça basittir. Renk seçim kutusu, int showDialog yöntemi ile görüntülenir:
static Color | showDialog(Component component, String title, Color initialColor) |
Component component | seçim kutusunun üst bileşeni, genellikle bir pencere JFrame |
String title | seçim kutusunun başlık çubuğundaki başlık |
Renk intialColor | seçim kutusunda başlangıçta seçilen renk |
Kullanıcı bir renk seçerse, yöntem bir renk döndürür; aksi takdirde null değerini döndürür. Couleur düğmesiyle ilişkili kod şöyledir:
void btnCouleur_actionPerformed(ActionEvent e) {
// JColorChooser bileşeni kullanılarak metin rengi seçilir
Color couleur;
if((couleur=jColorChooser1.showDialog(this,"Choix d'une couleur",Color.BLACK))!=null){
// metin kutusundaki karakterlerin rengini belirleme
txtTexte.setForeground(couleur);
}//if
}
Color sınıfı, java.awt.Color içinde tanımlanmıştır. Burada, siyah renk için Color.BLACK dahil olmak üzere çeşitli sabitler tanımlanmıştır. Görüntülenen seçim kutusu şöyledir
Oldukça ilginç bir şekilde, Swing kütüphanesi yazı tipini seçmek için bir sınıf sunmamaktadır. Neyse ki, internetteki Java kaynakları mevcuttur. Böyle bir sınıf için olası bir ad gibi görünen "JFontChooser" anahtar kelimesiyle arama yapıldığında, birkaç tane bulunur. Aşağıdaki örnek, JBuilder'i, ilk yapılandırmasında öngörülmemiş paketleri kullanacak şekilde yapılandırmamıza olanak sağlayacaktır.
Elde edilen paket swingextras.jar adını taşır ve <jdk>\jre\lib\perso klasörüne yerleştirilmiştir; burada <jdk>, JBuilder tarafından kullanılan JDK'nın kurulum dizinini belirtir. Bu paket başka herhangi bir yere de yerleştirilebilirdi.
 |  |
SwingExtras.jar paketinin içeriğine bir göz atalım:
Pakette sunulan bileşenlerin Java kaynak kodu burada yer alıyor. Ayrıca sınıfların kendileri de burada bulunuyor:
Bu arşivden, JFontChooser sınıfının aslında com.lamatek.swingextras.JFontChooser olarak adlandırıldığını not edelim. Tam adını yazmak istemiyorsak, programın başına şunu yazmamız gerekecektir:
Derleyici ve Java sanal makinesi bu yeni paketi nasıl bulacak? JDK'in doğrudan kullanımı durumunda bu konu daha önce açıklanmıştı; okuyucu, Java paketleri ile ilgili paragrafta bu açıklamaları bulabilir. Burada ise JBuilder ile kullanılacak yöntemi ayrıntılı olarak ele alıyoruz. Paketler, Seçenekler/JDK'i Yapılandır menüsünden yapılandırılır:
1 | Modifier (1) düğmesi, JBuilder'e hangi JDK'in kullanılacağını belirtmenizi sağlar. Bu örnekte, JBuilder, JDK 1.3.1 sürümünü beraberinde getirmişti. JDK 1.4 sürümü çıktığında, bu sürüm JBuilder'ten ayrı olarak kuruldu ve Modifier düğmesi kullanılarak JBuilder'eartık JDK 1.4'ü kullanması için, bu sürümün kurulum dizinini belirleyerek |
2 | JBuilder tarafından şu anda kullanılan JDK'in temel dizini |
3 | JBuilder tarafından kullanılan java arşivlerinin (.jar) listesi. Ajouter düğmesi (4) ile bunlara yenileri eklenebilir |
4 | Ajouter (4) düğmesi, JBuilder'in hem programların derlenmesi hem de çalıştırılması için kullanacağı yeni paketleri eklemeye olanak tanır. Burada, SwingExtras.jar (5) paketini eklemek için bu düğme kullanılmıştır |
Artık JBuilder, JFontChooser sınıfını kullanabilecek şekilde doğru bir şekilde yapılandırılmıştır. Ancak, bu sınıfı doğru bir şekilde kullanabilmek için tanımına erişmemiz gerekir. swingextras.jar arşivi, bunları değerlendirmek üzere çıkarabileceğimiz html dosyaları içerir. Buna gerek yok. .jar dosyalarında bulunan Java belgelerine JBuilder üzerinden doğrudan erişilebilir. Bunun için yukarıdaki Documentation (6) sekmesini yapılandırmak gerekir. Aşağıdaki yeni pencere açılır:
Ajouter düğmesi, SwingExtras.jar dosyasının dokümantasyon açısından taranması gerektiğini belirtmemizi sağlar. Bu işlem onaylandıktan sonra, SwingExtras.jar dosyasının dokümantasyonuna gerçekten erişebildiğimizi görebiliriz. Bu, çeşitli kolaylıklar sağlar:
- eğer şu içe aktarma komutunu yazmaya başlarsak
yazmaya başlarsak, JBuilder'in bize bir yardım sunduğunu görebiliriz:
com.lamatek paketi başarıyla bulundu.
- Şimdi şu komuta geçersek:
F1 anahtar kelimesi üzerinde JFontChooser işlemi yapıldığında, bu sınıfla ilgili bir yardım metni elde edilir:
Durum çubuğunda 1, swingextras.jar paketine ait bir HTML dosyasının kullanıldığını görüyoruz. Yukarıda sunulan örnek, uygulamamızdaki Police düğmesinin kodunu yazabilmemiz için yeterince açıklayıcıdır:
void btnPolice_actionPerformed(ActionEvent e) {
// JFontChooser bileşeni kullanılarak metin yazı tipinin seçilmesi
jFontChooser1 = new JFontChooser(new Font("Arial", Font.BOLD, 12));
if (jFontChooser1.showDialog(this, "Choix d'une police") == JFontChooser.ACCEPT_OPTION) {
// metin kutusundaki karakterlerin yazı tipini değiştirme
txtTexte.setFont(jFontChooser1.getSelectedFont());
}//if
}
Yukarıdaki showDialog yöntemi tarafından görüntülenen seçim kutusu şöyledir:
5.5. IMPOTS grafik uygulaması
Daha önce iki kez ele aldığımız IMPOTS uygulamasını tekrar ele alıyoruz. Şimdi buna bir grafik arayüz ekliyoruz:
Kontroller şunlardır
No | tür | ad | rol |
1 | JRadioButton | rdOui | evli ise işaretlenir |
2 | JRadioButton | rdNon | evli değilseniz işaretleyin |
3 | JSpinner | spinEnfants | Vergi mükellefinin çocuk sayısı Minimum=0, Maksimum=20, Artış=1 |
4 | JTextField | txtSalaire | Vergi mükellefinin yıllık maaşı (F cinsinden) |
5 | JLabel | lblImpots | ödenecek vergi tutarı |
6 | JTextField | txtStatus | durum mesajları alanı - değiştirilemez |
Menü şu şekildedir:
ana seçenek | ikincil seçenek | ad | rol |
Vergiler | |||
Başlat | mnuInitialiser | hesaplama için gerekli verileri bir metin dosyasından yükler | |
Hesapla | mnuCalculer | Gerekli tüm veriler mevcut ve doğruysa ödenecek vergiyi hesaplar | |
Sil | mnuEffacer | formu başlangıç durumuna geri getirir | |
Çık | mnuQuitter | uygulamayı sonlandırır |
Çalışma kuralları
- Calculer menüsü, maaş alanında herhangi bir giriş yapılmadığı sürece kapalı kalır
- hesaplama başlatıldığında maaşın yanlış olduğu anlaşılırsa, hata bildirilir:
Program aşağıda verilmiştir. Program, sınıflar bölümünde oluşturulan impots sınıfını kullanır. JBuilder tarafından otomatik olarak üretilen kodun bir kısmı burada yer almamaktadır.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.filechooser.FileFilter;
import java.io.*;
import java.util.*;
import javax.swing.event.*;
public class frmImpots extends JFrame {
// pencerenin bileşenleri
JPanel contentPane;
JMenuBar jMenuBar1 = new JMenuBar();
JMenu jMenu1 = new JMenu();
JMenuItem mnuInitialiser = new JMenuItem();
JMenuItem mnuCalculer = new JMenuItem();
JMenuItem mnuEffacer = new JMenuItem();
JMenuItem mnuQuitter = new JMenuItem();
JLabel jLabel1 = new JLabel();
JFileChooser jFileChooser1 = new JFileChooser();
JTextField txtStatus = new JTextField();
JRadioButton rdOui = new JRadioButton();
JRadioButton rdNon = new JRadioButton();
JLabel jLabel2 = new JLabel();
JLabel jLabel3 = new JLabel();
JTextField txtSalaire = new JTextField();
JLabel jLabel4 = new JLabel();
JLabel jLabel5 = new JLabel();
JLabel lblImpots = new JLabel();
JLabel jLabel7 = new JLabel();
ButtonGroup buttonGroup1 = new ButtonGroup();
JSpinner spinEnfants=null;
FileFilter filtreTxt=null;
// sınıfın öznitelikleri
double[] limites=null;
double[] coeffr=null;
double[] coeffn=null;
impots objImpots=null;
//Çerçeveyi oluştur
public frmImpots() {
enableEvents(AWTEvent.WINDOW_EVENT_MASK);
try {
jbInit();
}
catch(Exception e) {
e.printStackTrace();
}
// diğer başlatma işlemleri
moreInit();
}
// form başlatma
private void moreInit(){
// Hesapla menüsü devre dışı
mnuCalculer.setEnabled(false);
// giriş alanları devre dışı
txtSalaire.setEditable(false);
txtSalaire.setBackground(Color.WHITE);
// durum alanı
txtStatus.setBackground(Color.WHITE);
// Çocuklar döner menüsü - 0 ile 20 arasında çocuk
spinEnfants=new JSpinner(new SpinnerNumberModel(0,0,20,1));
spinEnfants.setBounds(new Rectangle(137,60,40,27));
contentPane.add(spinEnfants);
// seçim kutusu için *.txt filtresi
filtreTxt = new javax.swing.filechooser.FileFilter(){
public boolean accept(File f){
// "f" kabul ediliyor mu?
return f.getName().toLowerCase().endsWith(".txt");
}//kabul
public String getDescription(){
// filtre açıklaması
return "Fichiers Texte (*.txt)";
}//getDescription
};
// *.txt filtresini ekliyoruz
jFileChooser1.addChoosableFileFilter(filtreTxt);
// ayrıca tüm dosyalar için filtre de istiyoruz
jFileChooser1.setAcceptAllFileFilterUsed(true);
// kutu için başlangıç dizini belirlenir FileChooser
jFileChooser1.setCurrentDirectory(new File("."));
}//moreInit
//Bileşeni başlat
private void jbInit() throws Exception {
................
}
//Değiştirildi; böylece pencere kapatıldığında uygulamadan çıkabiliriz
protected void processWindowEvent(WindowEvent e) {
.....................
}
void mnuQuitter_actionPerformed(ActionEvent e) {
// uygulamadan çıkıyoruz
System.exit(0);
}
void mnuInitialiser_actionPerformed(ActionEvent e) {
// veri dosyasını yüklüyoruz
// seçim kutusu ile seçilen JFileChooser1
jFileChooser1.setFileFilter(filtreTxt);
if (jFileChooser1.showOpenDialog(this)!=JFileChooser.APPROVE_OPTION)
return;
// seçilen dosya işleniyor
try{
// verilerin okunması
lireFichier(jFileChooser1.getSelectedFile());
// vergi nesnesinin oluşturulması
objImpots=new impots(limites,coeffr,coeffn);
// onay
txtStatus.setText("Données chargées");
// maaş değiştirilebilir
txtSalaire.setEditable(true);
// artık değişiklik yapılamaz
mnuInitialiser.setEnabled(false);
}catch(Exception ex){
// sorun
txtStatus.setText("Erreur : " + ex.getMessage());
// son
return;
}//yakalama
}
private void lireFichier(File fichier) throws Exception {
// veri tabloları
ArrayList aLimites=new ArrayList();
ArrayList aCoeffR=new ArrayList();
ArrayList aCoeffN=new ArrayList();
String[] champs=null;
// dosyayı okuma modunda açma
BufferedReader IN=new BufferedReader(new FileReader(fichier));
// dosya satır satır okunur
// bunlar "limit coeffr coeffn" biçimindedir
String ligne=null;
int numLigne=0; // geçerli satır numarası
while((ligne=IN.readLine())!=null){
// bir satır daha
numLigne++;
// satırı alanlara ayrıştırıyoruz
champs=ligne.split("\\s+");
// 3 alan mı?
if(champs.length!=3)
throw new Exception("ligne " + numLigne + "erronée dans fichier des données");
// üç alanı alıyoruz
aLimites.add(champs[0]);
aCoeffR.add(champs[1]);
aCoeffN.add(champs[2]);
}//while
// dosyayı kapatma
IN.close();
// verilerin sınırlı dizilere aktarılması
int n=aLimites.size();
limites=new double[n];
coeffr=new double[n];
coeffn=new double[n];
for(int i=0;i<n;i++){
limites[i]=Double.parseDouble((String)aLimites.get(i));
coeffr[i]=Double.parseDouble((String)aCoeffR.get(i));
coeffn[i]=Double.parseDouble((String)aCoeffN.get(i));
}//for
}
void mnuCalculer_actionPerformed(ActionEvent e) {
// vergi hesaplaması
// maaş kontrolü
int salaire=0;
try{
salaire=Integer.parseInt(txtSalaire.getText().trim());
if(salaire<0) throw new Exception();
}catch (Exception ex){
// hata mesajı
txtStatus.setText("Salaire incorrect. Recommencez");
// hatalı alana odaklanma
txtSalaire.requestFocus();
// arayüze geri dönüş
return;
}
// çocuk sayısı
Integer InbEnfants=(Integer)spinEnfants.getValue();
// vergi hesaplama
lblImpots.setText(""+objImpots.calculer(rdOui.isSelected(),InbEnfants.intValue(),salaire));
// durum mesajını sil
txtStatus.setText("");
}
void txtSalaire_caretUpdate(CaretEvent e) {
// maaş değişti - hesapla menüsü güncelleniyor
mnuCalculer.setEnabled(! txtSalaire.getText().trim().equals(""));
}
void mnuEffacer_actionPerformed(ActionEvent e) {
// formun sıfırlanması
rdNon.setSelected(true);
spinEnfants.getModel().setValue(new Integer(0));
txtSalaire.setText("");
mnuCalculer.setEnabled(false);
lblImpots.setText("");
}
}
Burada, yalnızca JDK 1.4 sürümünden itibaren kullanılabilen JSpinner bileşenini kullandık. Bu, kullanıcının çocuk sayısını belirlemesine olanak tanıyan bir artırıcıdır. Bu Swing bileşeni, test için kullanılan JBuilder 6 sürümünün Swing bileşen çubuğunda mevcut değildi. Ancak bu, bileşen çubuğunda bulunan bileşenlere kıyasla işlemlerin biraz daha karmaşık olmasına rağmen, bileşenin kullanılmasını engellemez. Aslında, tasarım aşamasında JSpinner bileşenini forma yerleştirmek mümkün değildir. Bunu çalışma zamanında yapmak gerekir. Bunu gerçekleştiren koda bir göz atalım:
// Çocuklar döner menüsü - 0 ile 20 arasında çocuk girin
spinEnfants=new JSpinner(new SpinnerNumberModel(0,0,20,1));
spinEnfants.setBounds(new Rectangle(137,60,40,27));
contentPane.add(spinEnfants);
İlk satır, JSpinner bileşenini oluşturur. Bu bileşen, burada olduğu gibi sadece tamsayı artırıcı olarak değil, çeşitli amaçlar için kullanılabilir. JSpinner oluşturucusunun argümanı, burada dört parametre (değer, min, max, artış) kabul eden bir sayı artırıcı şablonudur. Bileşen şu şekildedir:
valeur | bileşende görüntülenen başlangıç değeri |
min | bileşende görüntülenebilecek minimum değer |
max | bileşende görüntülenebilecek maksimum değer |
incrément | bileşenin yukarı/aşağı ok tuşları kullanıldığında görüntülenen değerin artış miktarı |
Bileşenin değeri, getValue yöntemiyle elde edilir ve bu yöntem Object türünde bir değer döndürür. Bu nedenle, ihtiyacımız olan tamsayıyı elde etmek için birkaç tür dönüştürme işlemi gerekir:
// çocuk sayısı
Integer InbEnfants=(Integer)spinEnfants.getValue();
// vergi hesaplaması
lblImpots.setText(""+objImpots.calculer(rdOui.isSelected(),
InbEnfants.intValue(),salaire));
JSpinner bileşeni tanımlandıktan sonra, pencereye yerleştirilir:
Her şeyden önce, kullanıcı, Initialiser menü seçeneğini kullanarak, aşağıdaki oluşturucu ile bir impots nesnesi oluşturmalıdır
kullanılarak bir impots nesnesi oluşturmalıdır. Bu nesnenin, sınıflar bölümündeki örnekte tanımlandığını hatırlatırız. Gerekirse bu bölüme başvurulabilir. Oluşturucu için gerekli olan üç tablo, aşağıdaki biçime sahip bir metin dosyasının içeriğinden doldurulur:
12620.0 | 0 | 0 |
13190 | 0,05 | 631 |
15640 | 0,1 | 1290,5 |
24.740 | 0,15 | 2072,5 |
31810 | 0,2 | 3309,5 |
39.970 | 0,25 | 4900 |
48360 | 0,3 | 6898,5 |
55790 | 0,35 | 9316,5 |
92970 | 0,4 | 12106 |
127.860 | 0,45 | 16754,5 |
151250 | 0,50 | 23147,5 |
172.040 | 0,55 | 30710 |
195.000 | 0,60 | 39312 |
0 | 0,65 | 49062 |
Her satır, en az bir boşlukla ayrılmış üç sayıdan oluşur. Bu metin dosyası, kullanıcı tarafından JFileChooser bileşeni kullanılarak seçilir. impots türündeki nesne oluşturulduktan sonra, geriye kalan tek şey kullanıcının gerekli üç bilgiyi (evli olup olmadığı, çocuk sayısı, yıllık maaş) girmesini sağlamak ve impots sınıfının calculer yöntemini çağırmaktır. Bu işlem birkaç kez tekrarlanabilir. impots türündeki nesne ise yalnızca bir kez, Initialiser seçeneği kullanıldığında oluşturulur.
5.6. Applet yazımı
5.6.1. Giriş
Grafik kullanıcı arayüzüne sahip bir uygulama yazıldığında, bunu applet formatına dönüştürmek oldukça kolaydır. A makinesinde depolanan bu uygulama, internet üzerinden B makinesindeki bir web tarayıcısı tarafından indirilebilir. Böylelikle orijinal uygulama birçok kullanıcı arasında paylaşılır ve bir uygulamayı applet'e dönüştürmenin temel faydası da budur. Bununla birlikte, her uygulama bu şekilde dönüştürülemez: tarayıcısında bir applet kullanan kullanıcıya zarar vermemek için applet ortamı belirli kurallara tabidir:
- bir applet, kullanıcının diskinde okuma veya yazma işlemi yapamaz
- yalnızca tarayıcı tarafından indirildiği makineyle iletişim kurabilir.
Bunlar ciddi kısıtlamalardır. Örneğin, bir dosyadan veya veritabanından bilgi okuması gereken bir uygulama, bu bilgileri indirildiği sunucuda bulunan bir ara uygulama aracılığıyla talep etmek zorundadır.
Basit bir web uygulamasının genel yapısı şöyledir:
- İstemci, genellikle bir tarayıcı aracılığıyla web sunucusundan HTML adlı bir belgeyi ister. Bu belge, istemcinin tarayıcısı tarafından görüntülenen HTML belgesinin içinde bağımsız bir grafik uygulama olarak çalışacak bir applet içerebilir.
- Bu applet, verilere erişebilir, ancak yalnızca web sunucusunda bulunan verilere erişebilir. Applet, kendisini çalıştıran istemci makinesinin kaynaklarına veya indirildiği makine dışındaki ağdaki diğer makinelerin kaynaklarına erişemez.
5.6.2. JApplet sınıfı
5.6.2.1. Définition
Bir uygulama, java.applet.Applet sınıfının veya javax.swing.JApplet sınıfının bir örneği ise bir web tarayıcısı tarafından indirilebilir. İkincisi, ilkinden türetilmiştir; ilk sınıf ise Panel sınıfından türetilmiştir ve bu sınıf da Container sınıfından türetilmiştir. Applet veya JApplet türündeki bir örnek, container türünde olduğundan, düğmeler, onay kutuları, listeler gibi bileşenleri (Component) içerebilir. Farklı yöntemlerin işlevleri hakkında birkaç bilgi verelim:
Yöntem | İşlev |
public void destroy(); | Applet örneğini yok eder |
public AppletContext getAppletContext(); | applet'in yürütme bağlamını alır (applet'in bulunduğu HTML belgesi, aynı belgedeki diğer applet'ler, …) |
public String getAppletInfo(); | applet hakkında bilgi veren bir karakter dizesi döndürür |
public AudioClip getAudioClip(URL url); | URL ile belirtilen ses dosyasını yükler |
public AudioClip getAudioClip(URL url, String name); | URL/name ile belirtilen ses dosyasını yükler |
public URL getCodeBase(); | applet'in URL'ini döndürür |
public URL getDocumentBase(); | applet içeren HTML belgesinden URL'i oluşturur |
public Image getImage(URL url); | URL ile belirtilen görüntüyü alır |
public Image getImage(URL url, String name); | URL/name ile belirtilen görüntüyü alır |
public String getParameter(String name); | applet'i içeren HTML belgesinin <applet> etiketinde bulunan name parametresinin değerini alır. |
public void init(); | bu yöntem, applet ilk kez başlatıldığında tarayıcı tarafından çağrılır |
public boolean isActive(); | applet'in durumu |
public void play(URL url); | URL ile belirtilen ses dosyasını çalar |
public void play(URL url, String name); | UR/name ile belirtilen ses dosyasını çalar |
public void resize(Dimension d); | applet çerçevesinin boyutunu ayarlar |
public void resize(int width, int height); | aynı |
public final void setStub(AppletStub stub); | |
public void showStatus(String msg); | applet'in durum çubuğuna bir mesaj ekler |
public void start(); | bu yöntem, applet'i içeren belge her görüntülendiğinde tarayıcı tarafından çağrılır |
public void stop(); | Bu yöntem, applet'i içeren belgeden başka bir belgeye geçildiğinde (kullanıcı tarafından URL değiştirildiğinde) tarayıcı tarafından çağrılır |
JApplet sınıfı, Applet sınıfına bazı iyileştirmeler getirmiştir; bunlardan en önemlisi, JMenuBar ve c.a.d bileşenlerini barındırabilme özelliğidir. Bu, Applet sınıfında mümkün değildi.
5.6.2.2. Bir applet'in çalıştırılması: init, start ve stop yöntemleri
Bir tarayıcı bir applet'i yüklediğinde, bu applet'in üç yöntemini çağırır:
init | Bu yöntem, applet ilk yüklendiğinde çağrılır. Dolayısıyla, uygulamaya gerekli olan başlatma işlemlerini buraya yazacağız. |
start | Bu yöntem, applet'i içeren belge tarayıcının geçerli belgesi haline geldiğinde her seferinde çağrılır. Dolayısıyla, bir kullanıcı bir applet'i yüklediğinde, init ve start yöntemleri bu sırayla yürütülür. Kullanıcı başka bir belgeyi görüntülemek için bu belgeden çıktığında stop yöntemi yürütülür. Daha sonra bu belgeye geri döndüğünde ise start yöntemi yürütülür. |
stop | Bu yöntem, kullanıcı applet'i içeren belgeden her ayrıldığında çağrılır. |
Birçok applet için yalnızca init yöntemi gereklidir. start ve stop yöntemleri, uygulama, genellikle kullanıcının haberi olmadan paralel ve sürekli olarak çalışan görevler (iş parçacıkları) başlatıyorsa gereklidir. Kullanıcı belgeden çıktığında, uygulamanın görünür kısmı kaybolur, ancak bu arka plan görevleri çalışmaya devam eder. Bu genellikle gereksizdir. Bu durumda, tarayıcının stop yöntemini çağırmasından yararlanarak bu iş parçacıklarını durdururuz. Kullanıcı belgeye geri döndüğünde ise, tarayıcının start yöntemini çağırmasından yararlanarak iş parçacıklarını yeniden başlatırız.
Örneğin, grafik arayüzünde bir saat bulunan bir applet ele alalım. Bu saat, bir arka plan görevi (thread) tarafından çalıştırılmaktadır. Kullanıcı tarayıcıda applet sayfasından çıktığında, artık görünmez hale gelen saati çalıştırmaya devam etmenin bir anlamı yoktur: applet’in stop yönteminde, saati yöneten iş parçacığını durdururuz. start yönteminde ise bu iş parçacığını yeniden başlatırız; böylece kullanıcı applet sayfasına geri döndüğünde saati doğru gösteren bir saatle karşılaşır.
5.6.3. Grafik uygulamasının applet'e dönüştürülmesi
Burada bu dönüşümün mümkün olduğunu, yani applet'lerin çalıştırma kısıtlamalarına uygun olduğunu varsayıyoruz. Bir uygulama, sınıflarından birinin main yöntemi ile başlatılır:
Böyle bir uygulama şu şekilde bir applet'e dönüştürülür:
import java.applet.JApplet;
…
public class application extends JApplet{
…
public void init(){
…
}
…
}// sınıf sonu
Aşağıdaki hususlara dikkat edilmelidir:
- application sınıfı artık JApplet sınıfından türetilmektedir
- main yöntemi, init yöntemiyle değiştirilmiştir.
Örnek olarak, daha önce incelediğimiz bir uygulamaya geri dönelim: liste yönetimi.
Bu pencerenin bileşenleri şunlardır:
No | tür | ad | işlev |
1 | JTextField | txtSaisie | giriş alanı |
2 | JList | jList1 | bir kapsayıcıda bulunan liste jScrollPane1 |
3 | JList | jList2 | bir kapsayıcıda bulunan liste jScrollPane2 |
4 | JButton | cmd1To2 | seçilen öğeleri liste 1'den liste 2'ye aktarır |
5 | JButton | cmd2To1 | tersini yapar |
6 | JButton | cmdRaz1 | listeyi boşalt 1 |
7 | JButton | cmdRaz2 | Liste 2'yi boşalt |
Uygulamanın temel yapısı şöyleydi:
public class interfaceAppli extends JFrame {
JPanel contentPane;
JLabel jLabel1 = new JLabel();
JLabel jLabel2 = new JLabel();
JLabel jLabel3 = new JLabel();
JTextField txtSaisie = new JTextField();
JButton cmd1To2 = new JButton();
JButton cmd2To1 = new JButton();
DefaultListModel v1=new DefaultListModel();
DefaultListModel v2=new DefaultListModel();
JList jList1 = new JList(v1);
JList jList2 = new JList(v2);
JScrollPane jScrollPane1 = new JScrollPane();
JScrollPane jScrollPane2 = new JScrollPane();
JButton cmdRaz1 = new JButton();
JButton cmdRaz2 = new JButton();
JLabel jLabel4 = new JLabel();
/**Çerçeveyi oluştur*/
public interfaceAppli() {
enableEvents(AWTEvent.WINDOW_EVENT_MASK);
try {
jbInit();
}
catch(Exception e) {
e.printStackTrace();
}
}//interfaceAppli
/**Bileşeni başlatma*/
private void jbInit() throws Exception {
...
txtSaisie.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) {
txtSaisie_actionPerformed(e);
}
});
...
// Jlist1, jScrollPane1 konteynerine yerleştirilir
jScrollPane1.getViewport().add(jList1, null);
// Jlist2, jScrollPane2 konteynerine yerleştirildi
jScrollPane2.getViewport().add(jList2, null);
...
}
/**Değiştirildi; böylece pencere kapatıldığında çıkabiliriz*/
protected void processWindowEvent(WindowEvent e) {
...
}
void txtSaisie_actionPerformed(ActionEvent e) {
.............
}//sınıfı
void cmdRaz1_actionPerformed(ActionEvent e) {
// liste 1'i boşalt
v1.removeAllElements();
}//Raz1 komutu
void cmdRaz2_actionPerformed(ActionEvent e) {
// liste 2'yi boşalt
v2.removeAllElements();
}///cmd Raz2
appli sınıfını applet'e dönüştürmek için aşağıdaki adımları izleyin:
- önceki interfaceAppli sınıfını, artık JFrame'ten değil, JApplet'ten türetilecek şekilde değiştirin:
- JFrame penceresinin başlığını belirleyen komutu silin. JApplet applet'inde başlık çubuğu yoktur
- yapıcıyı bir yönteme dönüştürün init ve bu yöntem içinde pencere olaylarının yönetimini kaldırın (WindowListener, ...). Bir applet, boyutlandırılamayan veya kapatılamayan bir kapsayıcıdır.
/**Çerçeveyi oluştur*/
public init() {
// enableEvents(AWTEvent.WINDOW_EVENT_MASK);
try {
jbInit();
}
catch(Exception e) {
e.printStackTrace();
}
}//interfaceAppli
- processWindowEvent yöntemi silinmeli veya yorum satırına alınmalıdır
/**Değiştirildi, böylece pencere kapatıldığında çıkabiliriz*/
//protected void processWindowEvent(WindowEvent e) {
// super.processWindowEvent(e);
// if (e.getID() == WindowEvent.WINDOW_CLOSING) {
// System.exit(0);
// }
// }
Örnek olarak, JBuilder tarafından otomatik olarak oluşturulan kısım hariç, applet'in tam kodunu veriyoruz
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class interfaceAppli extends JApplet {
JPanel contentPane;
JLabel jLabel1 = new JLabel();
JLabel jLabel2 = new JLabel();
JLabel jLabel3 = new JLabel();
JTextField txtSaisie = new JTextField();
JButton cmd1To2 = new JButton();
JButton cmd2To1 = new JButton();
DefaultListModel v1=new DefaultListModel();
DefaultListModel v2=new DefaultListModel();
JList jList1 = new JList(v1);
JList jList2 = new JList(v2);
JScrollPane jScrollPane1 = new JScrollPane();
JScrollPane jScrollPane2 = new JScrollPane();
JButton cmdRaz1 = new JButton();
JButton cmdRaz2 = new JButton();
JLabel jLabel4 = new JLabel();
/**Çerçeveyi oluştur*/
public void init() {
// enableEvents(AWTEvent.WINDOW_EVENT_MASK);
try {
jbInit();
}
catch(Exception e) {
e.printStackTrace();
}
}//interfaceAppli
/**Bileşeni başlat*/
private void jbInit() throws Exception {
//setIconImage(Toolkit.getDefaultToolkit().createImage(interfaceAppli.class.getResource("[Votre icône]")));
contentPane = (JPanel) this.getContentPane();
contentPane.setLayout(null);
this.setSize(new Dimension(400, 308));
// this.setTitle("JList");
jScrollPane1.setBounds(new Rectangle(37, 133, 124, 101));
jScrollPane2.setBounds(new Rectangle(232, 132, 124, 101));
.............
}
void txtSaisie_actionPerformed(ActionEvent e) {
// giriş metni onaylandı
// başlangıç ve bitiş boşlukları kaldırılmış hali alınır
String texte=txtSaisie.getText().trim();
// boşsa, kabul edilmez
if(texte.equals("")){
// hata mesajı
JOptionPane.showMessageDialog(this,"Vous devez taper un texte",
"Erreur",JOptionPane.WARNING_MESSAGE);
// son
return;
}//if
// boş değilse, liste 1'deki değerlere eklenir
v1.addElement(texte);
// ve giriş alanı boşaltılır
txtSaisie.setText("");
}
void cmd1To2_actionPerformed(ActionEvent e) {
// seçilen öğeler Liste 1'den Liste 2'ye aktarılır
transfert(jList1,jList2);
}//cmd1To2
private void transfert(JList L1, JList L2){
// Liste 1'de seçilen öğeleri Liste 2'ye aktarın
// L1'te seçilen öğelerin dizin tablosu alınır
int[] indices=L1.getSelectedIndices();
// Yapılması gereken bir şey var mı?
if (indices.length==0) return;
// L1'ten değerleri alıyoruz
DefaultListModel v1=(DefaultListModel)L1.getModel();
// ve L2'teki değerler
DefaultListModel v2=(DefaultListModel)L2.getModel();
for(int i=indices.length-1;i>=0;i--){
// L1'te seçilen değerleri L2'e ekliyoruz
v2.addElement(v1.elementAt(indices[i]));
// L1'ten L2'e kopyalanan öğeler, L1'ten silinmelidir
v1.removeElementAt(indices[i]);
}//için
}//aktarım
private void affiche(String message){
// mesajı görüntüler
JOptionPane.showMessageDialog(this,message,
"Suivi",JOptionPane.INFORMATION_MESSAGE);
}// görüntüler
void cmd2To1_actionPerformed(ActionEvent e) {
// jList2'teki seçili öğeleri jList1'e aktarma
transfert(jList2,jList1);
}//cmd2TO1
void cmdRaz1_actionPerformed(ActionEvent e) {
// Liste 1'i boşalt
v1.removeAllElements();
}//Raz1 komutu
void cmdRaz2_actionPerformed(ActionEvent e) {
// boş liste 2
v2.removeAllElements();
}//Raz2 komutu
}//sınıf
Bu applet'in kaynak kodunu derleyebiliriz. Burada bunu JDK ile yapıyoruz, JBuilder olmadan.
E:\data\serge\Jbuilder\interfaces\JApplets\1>javac.bat interfaceAppli.java
E:\data\serge\Jbuilder\interfaces\JApplets\1>dir
12/06/2002 16:40 6 148 interfaceAppli.java
12/06/2002 16:41 527 interfaceAppli$1.class
12/06/2002 16:41 525 interfaceAppli$2.class
12/06/2002 16:41 525 interfaceAppli$3.class
12/06/2002 16:41 525 interfaceAppli$4.class
12/06/2002 16:41 525 interfaceAppli$5.class
12/06/2002 16:41 4 759 interfaceAppli.class
Uygulama, applet'leri veya bir tarayıcıyı çalıştırmaya olanak tanıyan JDK programındaki AppletViewer ile test edilebilir. Bunun için, içinde aşağıdaki applet'i barındıracak HTML appli.htm belgesini oluşturmanız gerekir:
<html>
<head>
<title>listes swing</title>
</head>
<body>
<applet
code="interfaceAppli.class"
width="400"
height="300">
</applet>
</body>
</html>
Burada, applet etiketinin varlığı dışında klasik bir HTML belgesi bulunmaktadır. Bu etiket üç parametreyle kullanılmıştır:
code="interfaceAppli.class" | applet'i çalıştırmak için yüklenecek derlenmiş JAVA sınıfının adı |
width="400" | belgedeki applet çerçevesinin genişliği |
height="300" | belgedeki applet çerçevesinin yüksekliği |
appli.htm dosyası yazıldıktan sonra, bu dosya JDK içindeki appletviewer programı veya bir tarayıcı ile yüklenebilir. appli.htm dosyasının bulunduğu klasörde bir DOS penceresine aşağıdaki komut yazılır:
appletviewer appli.htm
Burada, appletviewer.exe yürütülebilir dosyasının dizininin DOS penceresindeki PATH içinde olduğu varsayılmaktadır; aksi takdirde, appletviewer.exe yürütülebilir dosyasının tam yolunu belirtmek gerekir. Aşağıdaki pencere açılır:
Applet/Quitter seçeneği ile applet'in çalışmasını durduruyoruz. Şimdi applet'i bir tarayıcıyla test edelim. Tarayıcının Swing bileşenlerini görüntüleyebilmesi için bir Java 2 sanal makinesi kullanması gerekir. Yakın zamana kadar (2001), bu kısıtlama sorun yaratıyordu çünkü Sun, tarayıcı üreticilerinin ancak çok geç bir şekilde uyumlu hale getirebildiği JDK sürümleri üretiyordu. Sonunda Sun, Internet Explorer ve Netscape Navigator tarayıcılarının Sun tarafından üretilen en son JRE sürümlerini (JRE = Java Runtime Environment) kullanabilmesini sağlayan "Java eklentisi" adlı bir uygulamayı kullanıcıların hizmetine sunarak bu engeli ortadan kaldırdı. Aşağıdaki testler, Java 1.4 eklentisiyle donatılmış IE 5.5 sürümüyle gerçekleştirilmiştir.
interfaceAppli.class applet'ini test etmenin ilk yolu, HTML appli.htm dosyasını üzerine çift tıklayarak doğrudan tarayıcıya yüklemektir. Tarayıcı, bir web sunucusuna ihtiyaç duymadan HTML sayfasını ve içindeki applet'i görüntüler:
URL (1) dosyasından, dosyanın doğrudan tarayıcıya yüklendiği anlaşılmaktadır. Aşağıdaki örnekte, appli.htm dosyası, yerel makinenin 81 numaralı bağlantı noktasında çalışan bir Apache web sunucusundan istenmiştir:
5.6.4. HTML belgesindeki <applet> biçimlendirme seçeneği
HTML numaralı bir belgede, applet’in <applet> biçimlendirme komutu (etiket) ile referanslandığını gördük. Bu komutun çeşitli parametreleri olabilir:
<applet
code=
width=
height=
codebase=
align=
hspace=
vspace=
alt=
>
<param name1=nom1 value=val1>
<param name2=nom2 value=val2>
texte
>
</applet>
Parametrelerin anlamları şöyledir:
Parametre | Anlamı |
code | zorunlu - çalıştırılacak .class dosyasının adı |
width | zorunlu - belge içindeki applet'in genişliği |
height | zorunlu - yükseklik … |
codebase | isteğe bağlı - URL çalıştırılacak applet'in bulunduğu dizin. codebase belirtilmezse, applet onu referans alan html belgesinin bulunduğu dizinde aranır |
align | isteğe bağlı - applet'in belge içindeki konumu (LEFT, RiGHT, CENTER) |
hspace | isteğe bağlı - applet'i çevreleyen yatay kenar boşluğu (piksel cinsinden) |
vspace | isteğe bağlı - applet'i çevreleyen dikey kenar boşluğu (piksel cinsinden) |
alt | isteğe bağlı - tarayıcı applet'i yükleyemediğinde onun yerine yazılacak metin |
param | isteğe bağlı - applet'e adı (name) ve değeri (value) belirten parametre. Applet, nom1 parametresinin değerini val1=getParameter("nom1") şeklinde alabilir İstenilen sayıda parametre kullanılabilir |
texte | isteğe bağlı - örneğin Java sanal makinesine sahip olmadığı için applet çalıştıramayan tüm tarayıcılarda görüntülenir. |
Bir applet'e parametre aktarımını açıklamak için bir örnek verelim:
<html>
<head>
<title>paramètres applet</title>
</head>
<body>
<applet code="interfaceParams.class" width="400" height="300">
<param name="param1" value="val1">
<param name="param2" value="val2">
</applet>
</body>
</html>
interfaceParams appletinin Java kodu daha önce belirtildiği gibi oluşturuldu. JBuilder uygulaması oluşturuldu ve ardından yukarıda bahsedilen birkaç değişiklik yapıldı:
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class interfaceParams extends JApplet {
JPanel contentPane;
JScrollPane jScrollPane1 = new JScrollPane();
JLabel jLabel1 = new JLabel();
DefaultListModel params=new DefaultListModel();
JList lstParams = new JList(params);
//Çerçeveyi oluştur
public void init() {
// enableEvents(AWTEvent.WINDOW_EVENT_MASK);
try {
jbInit();
}
catch(Exception e) {
e.printStackTrace();
}
// diğer başlatma işlemleri
moreInit();
}
// başlatma işlemleri
public void moreInit(){
// applet'in parametre değerlerini gösterir
params.addElement("nom=param1 valeur="+getParameter("param1"));
params.addElement("nom=param2 valeur="+getParameter("param2"));
}//daha fazla başlatma
//Bileşeni başlat
private void jbInit() throws Exception {
............
this.setSize(new Dimension(205, 156));
//this.setTitle("Bir applet'in parametreleri");
jScrollPane1.setBounds(new Rectangle(19, 53, 160, 73));
............
}
}
AppletViewer ile çalıştırma:
5.6.5. Bir applet'ten uzak kaynaklara erişim
Birçok uygulama, dosyalarda veya veritabanlarında bulunan bilgileri kullanmak zorundadır. Bir applet'in, üzerinde çalıştığı makinenin kaynaklarına erişimi olmadığını belirtmiştik. Bu, mantıklı bir önlemdir. Aksi takdirde, applet'i yükleyenlerin disklerini "gözetlemek" için bir applet yazmak yeterli olurdu. Bununla birlikte, applet indirildiği sunucudaki kaynaklara, örneğin dosyalara erişebilir. Şimdi bunu inceleyeceğiz.
5.6.5.1. URL sınıfı
Herhangi bir Java uygulaması, java.net.URL sınıfı (URL = Uniform Resource Locator) sayesinde ağdaki bir makinede bulunan bir dosyayı okuyabilir. Bir URL, ağdaki bir kaynağı, kaynağın bulunduğu makineyi ve kaynağı almak için kullanılacak iletişim protokolü ile bağlantı noktasını şu biçimde tanımlar:
protokol:bağlantı noktası//makine/dosya
Böylece, URL http://www.ibm.com/index.html, www.ibm.com makinesindeki index.html dosyasını belirtir. Bu dosyaya http protokolü üzerinden erişilebilir. Bağlantı noktası belirtilmemiştir: tarayıcı, http hizmetinin varsayılan bağlantı noktası olan 80 numaralı bağlantı noktasını kullanacaktır.
URL sınıfının bazı öğelerini ayrıntılı olarak inceleyelim:
public URL(String spec) | "protocol:port//machine/file" biçimindeki bir dizeden URL sınıfının bir örneğini oluşturur; dizenin sözdizimi bir URL ile eşleşmezse bir istisna atar |
public String getFile() | "protokol:bağlantı noktası//makine/dosya" biçimli dizeden URL nesnesinin dosya alanını alır |
public String getHost() | URL'teki "protokol:bağlantı noktası//makine/dosya" dizesinin makine alanını elde etmeyi sağlar |
public String getPort() | URL'teki "protokol:bağlantı noktası//makine/dosya" dizesinin bağlantı noktası alanını elde etmeyi sağlar |
public String getProtocol() | URL'teki "protokol:bağlantı noktası//makine/dosya" dizesinin protokol alanını elde etmeyi sağlar |
public URLConnection openConnection() | getHost() uzaktaki makineyle, getPort() numaralı bağlantı noktası üzerinden, getProtocol() protokolüne göre bağlantı kurar ve getFile() dosyasını okumak için hazırlar. Bağlantı açılamazsa bir istisna oluşturur |
public final InputStream openStream() | openConnection().getInputStream() için kısayol. getFile() dosyasının içeriğinin okunabileceği bir giriş akışı elde etmeyi sağlar. Akış elde edilemezse bir istisna atar |
public String toString() | URL örneğinin kimliğini görüntüler |
Burada ilgimizi çeken iki yöntem vardır:
- public URL(String spec) işlenecek dosyayı belirtmek için
- public final InputStream openStream() dosyayı işlemek için
5.6.5.2. Konsol örneği
Grafik kullanıcı arayüzü içermeyen bir Java programı yazacağız; bu program, parametre olarak verilen bir URL dosyasının içeriğini ekrana görüntüleyecek. Bir çağrı örneği şu şekilde olabilir:
Program nispeten basittir:
import java.net.*; // sınıfı için URL
import java.io.*; // akışlar (stream) için
public class urlcontenu{
// argüman olarak geçirilen URL'in içeriğini görüntüler
// bu içeriğin okunabilir olması için metin olması gerekir
public static void main (String arg[]){
// argümanların doğrulanması
if(arg.length==0){
System.err.println("Syntaxe pg url");
System.exit(0);
}
try{
// URL dosyasının oluşturulması
URL url=new URL(arg[0]);
// içeriğin okunması
try{
// giriş akışının oluşturulması
BufferedReader is=new BufferedReader(new InputStreamReader(url.openStream()));
try{
// giriş akışındaki metin satırlarının okunması
String ligne;
while((ligne=is.readLine())!=null)
System.out.println(ligne);
} catch (Exception e){
System.err.println("Erreur lecture : " +e);
}
finally{
try { is.close(); } catch (Exception e) {}
}
} catch (Exception e){
System.err.println("Erreur openStream : " +e);
}
} catch (Exception e){
System.err.println("Erreur création URL : " +e);
}
}// main'in sonu
}// sınıf sonu
Bir argüman olduğunu doğruladıktan sonra, bu argümanla bir URL oluşturmaya çalışıyoruz:
// URL'in oluşturulması
URL url=new URL(arg[0]);
Argüman, URL protocole:port//machine/fichier sözdizimine uymuyorsa bu oluşturma işlemi başarısız olabilir. Sözdizimi açısından doğru bir URL varsa, metin satırlarını okuyabileceğimiz bir giriş akışı oluşturmaya çalışılır. URL URL.openStream() tarafından sağlanan giriş akışı, karakter odaklı bir akış olan InputStream türünde bir akış sağlar: okuma karakter karakter yapılır ve satırları kendiniz oluşturmanız gerekir. Metin satırlarını okuyabilmek için, BufferedReader veya DataInputStream.On sınıflarının readLine yöntemini kullanmak gerekir; burada BufferedReader seçilmiştir. Geriye kalan tek şey, InputStream akışını URL'ten BufferedReader akışına dönüştürmektir. Bu, InputStreamReader adlı bir ara akış oluşturularak yapılır:
BufferedReader is=new BufferedReader(new InputStreamReader(url.openStream()));
Bu akışın oluşturulması başarısız olabilir. İlgili istisna işlenir. Akış elde edildikten sonra, geriye sadece metin satırlarını okumak ve bunları ekranda görüntülemek kalır.
String ligne;
while((ligne=is.readLine())!=null)
System.out.println(ligne);
Burada da okuma işlemi bir istisna oluşturabilir ve bu istisna yönetilmelidir. Aşağıda, yerel bir URL gerektiren programın çalıştırılmasına ilişkin bir örnek verilmiştir:
E:\data\serge\Jbuilder\interfaces\JApplets\3>java urlcontenu http://localhost
<html>
<head>
<title>Bienvenue dans le Serveur Web personnel</title>
</head>
<body bgcolor="#FFFFFF" link="#0080FF" vlink="#0080FF"
topmargin="0" leftmargin="0">
<table border="0" cellpadding="0" cellspacing="0" width="100%"
bgcolor="#000000">
............
</table>
</center></div></td>
</tr>
</table>
</td>
</tr>
</table>
</body>
</html>
5.6.5.3. Grafik örneği
Grafik arayüz şu şekilde olacaktır:
Numara | Ad | Tür | Rol |
1 | txtURL | JTextField | URL okunmalı |
2 | btnCharger | JButton | URL dosyasının oynatılmasını başlatan düğme |
3 | JScrollPane1 | JScrollPane | kaydırma paneli |
4 | lstURL | JList | istenen URL dosyasının içeriğini gösteren liste |
Çalıştırıldığında, konsol programındakine benzer bir sonuç elde ederiz:
Uygulamanın ilgili kodu şöyledir:
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
import java.net.*;
import java.io.*;
public class interfaceURL extends JFrame {
JPanel contentPane;
JLabel jLabel1 = new JLabel();
JTextField txtURL = new JTextField();
JButton btnCharger = new JButton();
JScrollPane jScrollPane1 = new JScrollPane();
DefaultListModel lignes=new DefaultListModel();
JList lstURL = new JList(lignes);
//Çerçeveyi oluştur
public interfaceURL() {
..............
}
//Bileşeni başlatma
private void jbInit() throws Exception {
..............
}
//Değiştirildi, böylece pencere kapatıldığında çıkabiliriz
protected void processWindowEvent(WindowEvent e) {
...................
}
void txtURL_caretUpdate(CaretEvent e) {
// Yükle düğmesinin durumunu ayarlar
btnCharger.setEnabled(! txtURL.getText().trim().equals(""));
}
void btnCharger_actionPerformed(ActionEvent e) {
// URL'in içeriğini listede görüntüler
try{
afficherURL(txtURL.getText().trim());
}catch(Exception ex){
// hata mesajını görüntüler
JOptionPane.showMessageDialog(this,"Erreur : " + ex.getMessage(),"Erreur",JOptionPane.ERROR_MESSAGE);
}//try-catch
}
private void afficherURL(String strURL) throws Exception {
// URL ve strURL öğelerinin içeriğini listede görüntüler
// Hiçbir istisna özel olarak işlenmez. Sadece istisnalar üst katmana iletilir
// URL'in oluşturulması
URL url=new URL(strURL);
// giriş akışının oluşturulması
BufferedReader IN=new BufferedReader(new InputStreamReader(url.openStream()));
// giriş akışındaki metin satırlarının okunması
String ligne;
while((ligne=IN.readLine())!=null)
lignes.addElement(ligne);
// okuma akışının kapatılması
IN.close();
}
}
5.6.5.4. Bir applet
Daha önce birkaç kez anlatıldığı gibi, önceki grafik uygulaması bir applet'e dönüştürülmüştür. Applet, HTML appliURL.htm belgesine eklenmiştir:
<html>
<head>
<title>Applet lisant une URL</title>
</head>
<body>
<h1>Applet lisant une URL</h1>
<applet
code="appletURL.class"
width="400"
height="300"
>
</applet>
</body>
</html>
Yukarıdaki örnekte, tarayıcı 81 numaralı bağlantı noktasında çalışan bir web sunucusundan URL http://localhost:81/Japplets/2/appliURL.htm adresini talep etmiştir. Ardından, applet tarayıcıda görüntülenmiştir. Bu applet içinde, oluşturduğumuz appliURL.htm dosyasını aldığımızı doğrulamak için URL http://localhost:81/Japplets/2/appliURL.htm adresi yeniden istendi. Şimdi, applet'i oluşturan makineye ait olmayan bir URL dosyasını (burada localhost) yüklemeyi deneyelim:
URL dosyasının yüklenmesi reddedildi. Burada applet'lerle ilgili kısıtlamayla karşılaşıyoruz: applet'ler yalnızca indirildikleri makinenin ağ kaynaklarına erişebilirler. Applet'in bu kısıtlamayı aşmasının bir yolu vardır; bu da ağ isteklerini, indirildiği bilgisayarda bulunan bir sunucu programına devretmektir. Bu program, applet yerine ağ isteklerini gerçekleştirecek ve sonuçları applet'e geri gönderecektir. Buna ara program denir.
5.7. IMPOTS applet'i
Şimdi IMPOTS adlı grafik uygulamasını bir applet'e dönüştüreceğiz. Bunun bir önemi var: uygulama, bir tarayıcıya ve Java 1.4 eklentisine sahip her internet kullanıcısı tarafından kullanılabilir hale gelecektir (JSpinner bileşeni sayesinde). Böylece uygulamamız dünya çapında erişilebilir hale geliyor... Bu değişiklik, artık klasik hale gelen basit “grafik uygulaması → applet” dönüşümünden biraz daha fazlasını gerektirecek. Uygulama, yerel bir dosyanın içeriğini okumayı amaçlayan Initialiser menü seçeneğini kullanıyor. Ancak bir web uygulamasını düşünürsek, bu şemanın artık geçerli olmadığını görürüz:
Vergi tarifelerini tanımlayan verilerin, her bir istemci bilgisayarda değil, web sunucusunda bulunacağı açıktır. Web sunucusunda okunacak dosya, burada applet ile aynı klasöre yerleştirilecek ve Initialiser seçeneği bu dosyayı oradan almalıdır. Önceki örnekler bunun nasıl yapılacağını göstermiştir. Ayrıca, veri dosyasını yerel olarak seçmek için JFileChooser bileşeni kullanılmıştı; ancak bu bileşene artık gerek kalmamıştır.
Applet'i içeren HTML belgesi şu şekilde olacaktır:
<html>
<head>
<title>Applet de calcul d'impôts</title>
</head>
<body>
<h2>Calcul d'impôts</h2>
<applet
code="appletImpots.class"
width="320"
height="270"
>
<param name="data" value="impots.txt">
data parametresinin değeri, vergi tarifesi verilerini içeren dosyanın adıdır. HTML belgesi, appletImpots sınıfı, impots sınıfı ve impots.txt dosyası, web sunucusundaki aynı klasörde bulunmaktadır:
E:\data\serge\web\JApplets\impots>dir
12/06/2002 13:24 247 impots.txt
13/06/2002 10:17 654 appletImpots$2.class
13/06/2002 10:17 653 appletImpots$3.class
13/06/2002 10:17 653 appletImpots$4.class
13/06/2002 10:17 651 appletImpots$5.class
13/06/2002 10:06 651 appletImpots$6.class
13/06/2002 10:17 8 655 appletImpots.class
13/06/2002 10:17 657 appletImpots$1.class
13/06/2002 10:24 286 appletImpots.htm
13/06/2002 10:17 1 305 impots.class
Applet'in kodu şöyledir (sadece grafik uygulamaya göre yapılan değişiklikleri vurguladık):
...........
import java.net.*;
import java.applet.Applet;
public class appletImpots extends JApplet {
// pencerenin bileşenleri
JPanel contentPane;
............................
// sınıfın öznitelikleri
double[] limites=null;
double[] coeffr=null;
double[] coeffn=null;
impots objImpots=null;
String urlDATA=null;
//Çerçeveyi oluşturma
public void init() {
//enableEvents(AWTEvent.WINDOW_EVENT_MASK);
try {
jbInit();
}
catch(Exception e) {
e.printStackTrace();
}
// diğer başlatma işlemleri
moreInit();
}
// form başlatma
private void moreInit(){
// "Hesapla" menüsü devre dışı bırakıldı
mnuCalculer.setEnabled(false);
................
// vergi tarifesi dosyasının adı alınır
String nomFichier=getParameter("data");
// hata mı?
if(nomFichier==null){
// hata mesajı
txtStatus.setText("Le paramètre data de l'applet n'a pas été initialisé");
// "Başlat" seçeneği engelleniyor
mnuInitialiser.setEnabled(false);
// son
return;
}//if
// verilerin URL değeri belirleniyor
urlDATA=getCodeBase()+"/"+nomFichier;
}//moreInit
//Bileşeni başlat
private void jbInit() throws Exception {
...................
}
void mnuQuitter_actionPerformed(ActionEvent e) {
// uygulamadan çıkılıyor
System.exit(0);
}
void mnuInitialiser_actionPerformed(ActionEvent e) {
// veri dosyası yükleniyor
try{
// verileri okuma
lireDATA();
// vergiler nesnesinin oluşturulması
objImpots=new impots(limites,coeffr,coeffn);
................
}
private void lireDATA() throws Exception {
// veri tabloları
ArrayList aLimites=new ArrayList();
ArrayList aCoeffR=new ArrayList();
ArrayList aCoeffN=new ArrayList();
String[] champs=null;
// dosyayı okuma modunda açma
BufferedReader IN=new BufferedReader(new InputStreamReader(new URL(urlDATA).openStream()));
// dosya satır satır okunuyor
....................
}
void mnuCalculer_actionPerformed(ActionEvent e) {
// vergi hesaplama
......................
}
void txtSalaire_caretUpdate(CaretEvent e) {
..........
}
void mnuEffacer_actionPerformed(ActionEvent e) {
...............
}
}
Burada, okunacak veri dosyasının artık yerel bir makinede değil, uzak bir makinede bulunmasından kaynaklanan değişiklikleri ele alacağız:
Okunacak veri dosyasının adı, aşağıdaki kodla elde edilir:
// vergi tarifesi dosyasının adını alma
String nomFichier=getParameter("data");
// hata mı?
if(nomFichier==null){
// hata mesajı
txtStatus.setText("Le paramètre data de l'applet n'a pas été initialisé");
// "Başlat" seçeneği engelleniyor
mnuInitialiser.setEnabled(false);
// son
return;
}//if
// verilerin URL değeri belirleniyor
urlDATA=getCodeBase()+"/"+nomFichier;
"impots.txt" dosya adının, applet'in data parametresine aktarıldığını hatırlayalım:
Yukarıdaki kod, olası bir hatayı yöneterek data parametresinin değerini almayla başlar. Applet'i içeren HTML belgesindeki URL değeri http://localhost:81/JApplets/impots/appletImpots.htm ise, impots.txt dosyasının URL değeri http://localhost:81/JApplets/impots/impots.txt olacaktır. Bu URL dosyasının adını oluşturmamız gerekiyor. Applet'in getCodeBase() yöntemi, applet'i içeren HTML belgesinin alındığı klasörün URL değerini verir, yani örneğimizde http://localhost:81/JApplets/impots. Aşağıdaki komut, veri dosyasının URL değerini oluşturmamızı sağlar:
lireFichier() yönteminde, URL ve urlData dosyalarının içeriğini okuyan, verilerin okunmasını sağlayacak giriş akışının oluşturulması yer almaktadır:
// dosya okuma modunda açılıyor
BufferedReader IN=new BufferedReader(new InputStreamReader(new URL(urlDATA).openStream()));
Bu noktadan itibaren, verilerin yerel bir dosyadan değil de uzak bir dosyadan geldiği artık ayırt edilemez. İşte applet'in çalıştırılmasına ilişkin bir örnek:
5.8. Sonuç
Bu bölümde
- JBuilder ile grafik arayüzlerin oluşturulmasına
- en yaygın Swing bileşenleri
- appletlerin oluşturulması
Unutulmaması gereken nokta şudur:
- JBuilder tarafından üretilen kodun elle de yazılabileceğini unutmayalım. Bu kod bir şekilde elde edildikten sonra, onu çalıştırmak için basit bir JDK yeterlidir ve JBuilder artık gerekli değildir.
- JBuilder gibi bir aracın kullanılması, önemli verimlilik artışları sağlayabilir:
- JBuilder tarafından üretilen kodu elle yazmak mümkün olsa da, bu çok zaman alabilir ve pek bir anlam ifade etmez; zira uygulamanın mantığı genellikle başka yerdedir.
- Oluşturulan kod öğretici olabilir. Bu kodu okumak ve incelemek, ilk kez kullandığımız bileşenlerin bazı yöntemlerini ve özelliklerini keşfetmenin iyi bir yoludur.
- JBuilder çoklu platform desteğine sahiptir. Dolayısıyla, bir platformdan diğerine geçerken edindiğiniz bilgiler kaybolmaz. Hem Windows hem de Linux altında çalışan programlar yazabilmek elbette çok önemli bir verimlilik faktörüdür. Ancak bu, JBuilder'e değil, Java'nın kendisine bağlıdır.
5.9. Linux'ta JBuilder
Yukarıdaki tüm örnekler Windows 98 üzerinde test edilmiştir. Yazılan programların olduğu gibi Linux’a taşınabilir olup olmadığı merak edilebilir. Söz konusu Linux makinesinde çeşitli programlar tarafından kullanılan sınıflar mevcutsa, programlar taşınabilirdir. Örneğin, Linux’a JBuilder’i kurduysanız, gerekli sınıflar zaten makinenizde mevcuttur. İşte örneğin, Linux üzerinde JList bileşeni ile JBuilder 4 kullanılarak programlarımızdan birinin çalıştırılması sonucu ortaya çıkan sonuç:
Aşağıda, JBuilder 4 Foundation'ın bir Linux makinesine kurulumunu anlatıyoruz. Win9x makinesine kurulumu herhangi bir sorun yaratmaz ve şimdi açıklanacak sürece benzerdir. Daha sonraki sürümlerin kurulumu muhtemelen farklı olacaktır, ancak bu belge yine de bazı yararlı bilgiler içerebilir.
JBuilder, Inprise web sitesinde şu adreste mevcuttur: http://www.inprise.com/jbuilder
Bu sayfada özellikle Windows ve Linux için bağlantılar bulunmaktadır. Şimdi, JBuilder grafik arayüzüne sahip bir Linux makinesine KDE'in kurulumunu açıklayacağız.
“Jbuilder 4 for Linux” bağlantısını takip ettiğinizde bir form karşınıza çıkar. Bu formu doldurduktan sonra iki dosya elde edersiniz:
jb4docs_fr.tar.gz: Jbuilder4 belgeleri ve örnekleri
jb4fndlinux_fr.tar.gz: Jbuilder4 Foundation. Bu, ticari Jbuilder4'ün sınırlı bir sürümüdür ancak eğitim amaçlı kullanım için yeterlidir.
Yazılımın etkinleştirme anahtarı size e-posta ile gönderilir. Bu anahtar, Jbuilder4'ü kullanmanızı sağlar ve ilk kullanımda sizden istenecektir. Bu anahtarı kaybederseniz, yukarıdaki URL'ye geri dönüp "get your activation key" bağlantısını takip edebilirsiniz. Bundan sonra, root olduğunuzu ve yukarıdaki iki tar.gz dosyasının bulunduğu dizinde olduğunuzu varsayıyoruz. İki dosyayı da açıyoruz:
[ls -l]
drwxr-xr-x 3 nobody nobody 4096 oct 10 2000 docs
drwxr-xr-x 3 nobody nobody 4096 déc 5 13:00 foundation
[ls -l foundation]
-rw-r--r-- 1 nobody nobody 1128 déc 5 13:00 deploy.txt
-rwxr-xr-x 1 nobody nobody 69035365 déc 5 13:00 fnd_linux_install.bin
drwxr-xr-x 2 nobody nobody 4096 déc 5 13:00 images
-rw-r--r-- 1 nobody nobody 15114 déc 5 13:00 index.html
-rw-r--r-- 1 nobody nobody 23779 déc 5 13:00 license.txt
-rw-r--r-- 1 nobody nobody 75739 déc 5 13:00 release_notes.html
-rw-r--r-- 1 nobody nobody 31902 déc 5 13:00 whatsnew.html
[ls -l docs]
-rw-r--r-- 1 nobody nobody 1128 oct 10 2000 deploy.txt
-rwxr-xr-x 1 nobody nobody 40497874 oct 10 2000 doc_install.bin
drwxr-xr-x 2 nobody nobody 4096 oct 10 2000 images
-rw-r--r-- 1 nobody nobody 9210 oct 10 2000 index.html
-rw-r--r-- 1 nobody nobody 23779 oct 10 2000 license.txt
-rw-r--r-- 1 nobody nobody 75739 oct 10 2000 release_notes.html
-rw-r--r-- 1 nobody nobody 31902 oct 10 2000 whatsnew.html
Oluşturulan iki dizinde, .bin dosyası kurulum dosyasıdır. Ayrıca, bir tarayıcı kullanarak her iki dizindeki index.html dosyasını görüntüleyin. Bu dosyalar, her iki ürünü kurmak için izlenecek adımları gösterir. Önce Jbuilder Foundation'ı kurmaya başlayalım:
Kurulumun ilk ekranı karşınıza çıkacaktır. Ardından birçok ekran daha gelecektir:
Onaylayın. Ardından bir açıklama ekranı gelir:
[suivant] komutunu girin.
Lisans sözleşmesini kabul edin ve [suivant] komutunu girin.
Jbuilder için önerilen konumu kabul edin (bunu not alın, daha sonra ihtiyacınız olacak) ve [suivant] komutunu girin. Kurulum hızlı bir şekilde tamamlanır.
İlk testi yapmaya hazırız. KDE'te dosya yöneticisini başlatarak Jbuilder'ın yürütülebilir dosyalarının bulunduğu dizine gidin: /opt/jbuilder4/bin (eğer Jbuilder'ı /opt/jbuilder4 konumuna kurduysanız):
Yukarıdaki jbuilder simgesine tıklayın. Jbuilder'ı ilk kez kullandığınız için aktivasyon anahtarınızı girmeniz gerekecektir:
Nom ve Société alanlarını doldurun. Etkinleştirme anahtarınızı girmek için [Ajouter]'i seçin. Bu anahtarın size e-posta ile gönderilmiş olması gerektiğini hatırlatırız; eğer kaybettiyseniz, Jbuilder 4'ü indirdiğiniz URL'den (kurulumun başlangıcına bakın) alabilirsiniz. Etkinleştirme anahtarınız kabul edildikten sonra, lisans koşulları size hatırlatılacaktır:
OK komutunu girerek, daha önce gördüğünüz bilgi giriş penceresine geri dönersiniz:
Yalnızca ilk çalıştırmada gerçekleştirilen bu aşamayı tamamlamak için OK komutunu girin. Ardından, Jbuilder geliştirme ortamı görünür:
Şimdi JBuilder'dan çıkın ve belgeleri yükleyin. Bu işlem, JBuilder'ın yardım bölümünde kullanılacak bir dizi dosyayı yükleyecektir; ancak şu anda bu yardım bölümü henüz tamamlanmamıştır. Jbuilder'ın tar.gz dosyalarını açtığınız dizine geri dönün. Yükleyici programı docs dizininde bulunmaktadır. Bu dizine girin:
[cd docs]
[ls -l]
-rw-r--r-- 1 nobody nobody 1128 oct 10 2000 deploy.txt
-rwxr-xr-x 1 nobody nobody 40497874 oct 10 2000 doc_install.bin
drwxr-xr-x 2 nobody nobody 4096 oct 10 2000 images
-rw-r--r-- 1 nobody nobody 9210 oct 10 2000 index.html
-rw-r--r-- 1 nobody nobody 23779 oct 10 2000 license.txt
-rw-r--r-- 1 nobody nobody 75739 oct 10 2000 release_notes.html
-rw-r--r-- 1 nobody nobody 31902 oct 10 2000 whatsnew.html
Kurulum dosyası doc_install.bin'tir, ancak bu dosyayı hemen çalıştıramazsınız. Aksi takdirde, nedeni anlaşılamadan kurulum başarısız olur. Yükleme işleminin ayrıntılı açıklaması için index.html dosyasını bir tarayıcıyla okuyun. Yükleyici, bir Java sanal makinesine ihtiyaç duyar; aslında java adlı bir programa ihtiyaç duyar ve bu program, bilgisayarınızdaki PATH dizininde bulunmalıdır. PATH'in, değeri rep1:rep2:...:repn biçiminde olan ve yürütülebilir dosya aranırken taranması gereken repi dizinlerini belirten bir Unix değişkeni olduğunu hatırlatırız. Burada, yükleyici java adlı bir programın çalıştırılmasını istemektedir. Burada veya başka yerlerde kurduğunuz Java sanal makinelerinin sayısına bağlı olarak bu programın birden fazla sürümü olabilir. Mantıken, Jbuilder4 ile gelen ve /opt/jbuilder4/jdk1.3/bin dizininde bulunan sürümü kullanacağız. Bu dizini PATH değişkenine eklemek için:
[echo $PATH]
/usr/local/sbin:/usr/sbin:/sbin:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin:/usr/X11R6/bin:/root/bin
[export PATH=/opt/jbuilder4/jdk1.3/bin/:$PATH]
[echo $PATH]
/opt/jbuilder4/jdk1.3/bin/:/usr/local/sbin:/usr/sbin:/sbin:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin:/usr/X11R6/bin:/root/bin
Artık belgelerin kurulumunu başlatabiliriz:
Bu, grafiksel bir kurulum olacaktır:
Bu işlem, Jbuilder Foundation'daki kurulumla oldukça benzerdir. Bu nedenle ayrıntılara girmeyeceğiz. Kaçırılmaması gereken bir ekran vardır:
Yükleyici normalde Jbuilder Foundation'ı nereye kurduğunuzu kendiliğinden bulmalıdır. Dolayısıyla, önerilen ayarları değiştirmeyin; tabii ki yanlışsa başka.
Dokümantasyon yüklendikten sonra, Jbuilder'ı yeniden test etmeye hazırız. Uygulamayı yukarıda gösterildiği gibi başlatın. Jbuilder açıldığında, Yardım/Yardım Konusu seçeneğini seçin. Sol taraftaki çerçeve içinde Tutoriels bağlantısına tıklayın:
JBuilder, Java programlamaya başlamanıza yardımcı olacak bir dizi öğretici ile birlikte gelir. Aşağıda, yukarıdaki "Uygulama Oluşturma" öğreticisini takip ettik.
JBuilder'da Dosya/Yeni Proje seçeneğini seçin. Bir sihirbaz size 3 ekran gösterecektir:
"Herkese merhaba" başlıklı basit bir pencere oluşturacağız. Bu projeye coucou adını veriyoruz. Örnek, root tarafından çalıştırılmıştır. JBuilder, tüm projeleri root bağlantı dizinindeki jbproject dizininde bir araya getirmeyi önerir. coucou projesi, jbproject'in coucou dizinine (Proje Dizini Adı alanı) yerleştirilecektir. [suivant]'i oluşturun.
Bu ikinci ekran, projenizdeki çeşitli yolların bir özetidir. Değiştirilecek bir şey yoktur. [suivant]'i seçin.
Üçüncü ekranda projenizi özelleştirmeniz istenir. Gerekli bilgileri girin ve [Terminer] komutunu verin.
Şimdi Fichier/Nouveau komutunu verin:
Application'i seçin ve OK'i yapın. Yeni bir sihirbaz size 2 ekran gösterecektir:
paquet alanı proje adını alır. Sınıf alanı, projenin ana sınıfına verilecek olan nom değerini ister. Yukarıdaki adı alın ve [suivant] olarak girin:
Uygulamamızda uygulama penceresi için ikinci bir Java sınıfı bulunmaktadır. Bu sınıfa bir ad verin. Titre alanı, bu pencereye vermek istediğiniz başlıktır. options çerçevesi, pencereniz için seçenekler sunar. Hepsini seçin ve [Terminer]'i oluşturun. Ardından, projeniz için girdiğiniz bilgilerle zenginleştirilmiş JBuilder ortamına geri dönersiniz:
Sol üst pencerede (1), projenizi oluşturan dosyaların listesi yer almaktadır. Burada özellikle, az önce adını verdiğimiz iki .java sınıfı bulunmaktadır. Sağdaki pencerede (2) ise coucouCadre sınıfının Java kodu yer almaktadır. Sol alt pencerede, projenizin yapısı (sınıflar, yöntemler, öznitelikler) yer almaktadır. Proje çalıştırılmaya hazırdır. Yukarıdaki 4 numaralı düğmeye basın veya Çalıştır/Projeyi Çalıştır seçeneğini seçin ya da F9'i seçin. Aşağıdaki pencere açılmalıdır:
Aide seçeneğine tıkladığınızda, oluşturma sihirbazlarına girdiğiniz bilgileri görmelisiniz. Daha fazla ayrıntıya girmeyeceğiz. Artık öğreticilere dalma zamanı geldi.
Bitirmeden önce, JBuilder ve onun grafik arayüzünü değil, onunla birlikte gelen ve /opt/jbuilder4/jdk1.3 dizinine yerleştirilen JDK’yı kullanabileceğinizi gösterelim. Aşağıdaki essai1.java dosyasını derleyin:
import java.io.*;
public class essai1{
public static void main(String args[]){
System.out.println("coucou");
System.exit(0);
}
}
Bunu derleyip JBuilder'ın JDK'sıyla çalıştıralım: