Design der grafischen Java-Schnittstelle

Im Interface-Design müssen viele Komponenten in einem Container platziert werden. Der Schönheit halber werden die Komponenten an der Position des Containers angeordnet. In java.awt sind mehrere Layoutklassen definiert, und jede Layoutklasse entspricht einer Layoutstrategie. Die folgenden Layoutklassen werden häufig verwendet:

•FlowLayout, das Komponenten in der Reihenfolge platziert.
•BoarderLayout platziert Komponenten am Rand.
•CardLayout stapelt Komponenten wie Spielkarten, und es kann jeweils nur eine Komponente angezeigt werden.
•GridLayout unterteilt den Anzeigebereich durch Zeilen und Spalten in gleiche Raster und fügt der Reihe nach Komponenten in diese Raster ein.
•GridBagLayout unterteilt den Anzeigebereich in viele kleine rechteckige Einheiten, und jede Komponente kann eine oder mehrere kleine Einheiten belegen.

Unter diesen kann GridBagLayout eine feine Positionssteuerung durchführen und ist auch die komplexeste. In diesem Tutorial wird diese Layout-Strategie vorerst nicht behandelt und in einem speziellen Artikel ausführlich erläutert.

Jeder Container verfügt über einen Layout-Manager, der bestimmt, wie die im Container platzierten Komponenten angeordnet werden. Ein Layout-Manager ist eine Klasse, die die LayoutManager-Schnittstelle implementiert.

1. FlowLayout-Layout (Standardlayout von JApplet, JPanel, JScrollPane)

FlowLayout-Layout ordnet die Komponenten von links nach rechts in der Reihenfolge an, in der sie hinzugefügt werden Die Zeilen werden von links nach rechts fortgesetzt, wobei die Komponenten in jeder Zeile zentriert sind. Dies ist die einfachste Layoutstrategie und wird im Allgemeinen verwendet, wenn nicht viele Komponenten vorhanden sind. Wenn viele Komponenten vorhanden sind, erscheinen die Komponenten im Container ungleichmäßig, da jede Zeile unterschiedlich lang ist.

FlowLayout ist das Standardlayout für kleine Anwendungen und Panels. Die Konstruktionsmethoden des FlowLayout-Layouts sind:

1.FlowLayout() generiert ein Standard-FlowLayout-Layout. Standardmäßig ist die Komponente mit einem Abstand von 5 Pixeln zentriert.
2.FlowLayout(intalignment), legt die Ausrichtung jeder Komponente fest. Der Ausrichtungswert kann FlowLayout.LEFT, FlowLayout.CENTER, FlowLayout.RIGHT sein.
3.FlowLayout(int alignment, int horz, int vert), legen Sie die Ausrichtung fest und legen Sie den horizontalen Abstand horz und den vertikalen Abstand vert der Komponente fest. Verwenden Sie die setLayout()-Methode der Superklasse Container, um das Layout festzulegen für den Behälter. Beispielsweise legt der Code setLayout(new FlowLayout()) das FlowLayout-Layout für den Container fest. Die Methode zum Hinzufügen einer Komponente zum Container ist add(Komponentenname).

2. BorderLayout-Layout (Standardlayout von JWindow, JFrame, JDialog)

Die BorderLayout-Layoutstrategie besteht darin, den Raum im Container einfach in Ost „Ost“, West „West“ und Süd zu unterteilen „Es gibt fünf Bereiche: „Süd“, „Nord“ und „Mitte“. Beim Hinzufügen einer Komponente sollten Sie den Bereich angeben, in dem die Komponente platziert werden soll. Platzieren Sie eine Komponente an einer Position. Wenn mehrere Komponenten an einem bestimmten Ort hinzugefügt werden sollen, sollten die an diesem Ort hinzuzufügenden Komponenten zuerst in einen anderen Container gelegt werden, und dann wird der Container an diesem Ort hinzugefügt.

Die Konstruktionsmethoden des BorderLayout-Layouts sind:
(1) BorderLayout(), das ein Standard-BorderLayout-Layout generiert. Standardmäßig gibt es keine Lücke.
(2) BorderLayout(int horz,int vert), legt den horizontalen und vertikalen Abstand zwischen Komponenten fest.

Die Einstellungsmethode der BorderLayout-Layoutstrategie ist setLayout(new BorderLayout()). Die Methode zum Hinzufügen einer Komponente zu einem Container lautet add(Komponentenname, Position). Wenn beim Hinzufügen einer Komponente keine Position angegeben wird, ist die Standardposition „Mitte“.

Das BorderLayout-Layout ist das Standardlayout von JWindow, JFrame und JDialog.
【Beispiel 11-5】Die Anwendung verfügt über fünf Beschriftungen, die im östlichen, westlichen, südlichen, nördlichen und mittleren Bereich des Fensters platziert werden.

import javax.swing.*;import java.awt.*;
public class J505{
  public static void main(String[]args){
    JLabel label1,label2,label3,label4,label5;
    JFrame mw=new JFrame("我是一个窗口");//创建一个窗口容器对象
    mw.setSize(250,200);
    Container con=mw.getContentPane();
    con.setLayout(new BorderLayout());
    label1=new JLabel("东标签");//默认左对齐
    label2=new JLabel("南标签",JLabel.CENTER);
    label3=new JLabel("西标签");
    label4=new JLabel("北标签",JLabel.CENTER);
    label5=new JLabel("中标签",JLabel.CENTER);
    con.add(label1,"East");
    con.add(label2,"South");
    con.add(label3,"West");
    con.add(label4,"North");
    con.add(label5,"Center");
    mw.setVisible(true);
  }
}

3. GridLayout

Das GridLayout-Layout unterteilt den Container in ein Raster aus Zeilen und Spalten. Die Anzahl der Zeilen und Spalten wird vom Programm gesteuert und die Komponenten werden darauf platziert Raster. Im kleinen Raster. Das GridLayout-Layout zeichnet sich durch eine relativ präzise Komponentenpositionierung aus. Da jedes Gitter im GridLayout-Layout die gleiche Form und Größe hat, sollten auch die im Container platzierten Komponenten gleich groß bleiben.

Die Konstruktionsmethoden des GridLayout-Layouts sind:
(1) GridLayout(), das ein einspaltiges GridLayout-Layout generiert. Standardmäßig gibt es keine Lücke.
(2) GridLayout(int row, int col), legt ein GridLayout-Layout mit Zeilenzeile und Spaltenspalte fest.
(3) GridLayout(int row,int col,int horz,int vert) legt die Anzahl der Zeilen und Spalten des Layouts sowie den horizontalen und vertikalen Abstand der Komponenten fest.

Das GridLayout-Layout basiert auf Zeilen. Wenn die Anzahl der platzierten Komponenten den Grenzwert überschreitet, werden umgekehrt automatisch Spalten hinzugefügt bleibt unverändert und die Komponenten werden in der Reihenfolge der Zeilenpriorität angeordnet (je nach Komponente. Spalten automatisch vergrößern oder verkleinern). Jedes Raster im GridLayout-Layout muss mit Komponenten gefüllt sein. Wenn Sie möchten, dass ein Raster leer ist, können Sie es durch eine leere Beschriftung ersetzen (add(new Label())).

[Beispiel 11-6] Das Applet fügt zunächst mehrere Schaltflächen und Beschriftungen in ein JPanel ein, fügt dann das JPanel in ein JScrollPane ein und fügt schließlich das JScrollPane in das Fenster des Applets ein Die horizontalen und vertikalen Bildlaufleisten sind kleiner als die tatsächlichen Anforderungen des Bedienfelds. Sie können den Schieberegler der Bildlaufleiste verschieben, um den Bereich des Bedienfelds anzuzeigen, der ursprünglich nicht im sichtbaren Bereich lag.

import java.applet.*;
import javax.swing.*;
import java.awt.*;
class MyWindow extends JFrame{
  public MyWindow(int w,int h){
    setTitle("滚动面板实例");
    Container con=getContentPane();
    con.setPreferredSize(new Dimension(w,h));
    con.setLayout(new BorderLayout());
    JPanel p=new JPanel();
    p.setLayout(new GridLayout(6,6));
    for (int i=0;i<6;i++){
      p.add(new JLabel());
      for(int j=1;j<=2;j++){
        p.add(new JButton("按钮"+(2*i+j)));
        p.add(new JLabel("标签"+(2*i+j)));
      }
      p.add(new JLabel());
    }
    p.setBackground(Color.blue);
    p.setPreferredSize(new Dimension(w+60,h+60));
    JScrollPane ScrollPane=new JScrollPane(p);
    ScrollPane.setPreferredSize(new Dimension(w-60,h-60));
    add(ScrollPane,BorderLayout.CENTER);//小程序添加滚动面板
    setVisible(true); pack();
  }
}
class ScrollPane extends JScrollPane{
  public ScrollPane(Component p){
    super(p);
    setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);
    setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
  }
}
public class J506 extends Applet{
  MyWindow myWindow;
  public void init(){
    myWindow=new MyWindow(400,350);
  }
}

GridLayout布局要求所有组件的大小保持一致，这可能会使用界面外观不够美观。一个补救的办法是让一些小组件合并放在一个容器中，然后把这个容器作为组件，再放入到GridLayout布局中。这就是前面所说的容器嵌套。例如，容器A使用GridLayout布局，将容器均分为网格；另有容器B和C各放入若干组件后，把B和C分别作为组件添加到容器A中。容器B和C也可以设置为GridLayout布局，把自己分为若干网格，也可以设置成其他布局。这样，从外观来看，各组件的大小就有了差异。

四.CardLayout布局

采用CardLayout布局的容器虽可容纳多个组件，但是多个组件拥有同一个显示空间，某一时刻只能显示一个组件。就像一叠扑克牌每次只能显示最上面的一张一样，这个显示的组件将占据容器的全部空间。CardLayout布局设计步骤如下：
先创建CardLayout布局对象。然后，使用setLayout()方法为容器设置布局。最的，调用容器的add()方法将组件加入容器。CardLayout布局策略加入组件的方法是：
    add(组件代号，组件);
其中组件代号是字符串，是另给的，与组件名无关。

例如，以下代码为一个JPanel容器设定CardLayout布局：

CardLayout myCard = new CardLayout();//创建CardLayout布局对象
JPanel p = new JPanel();//创建Panel对象
p.setLayout(myCard);

用CardLayout类提供的方法显示某一组件的方式有两种：
(1) 使用show(容器名，组件代号)形式的代码，指定某个容器中的某个组件显示。例如，以下代码指定容器p的组件代号k，显示这个组件：
    myCard.show(p,k);
(2) 按组件加入容器的顺序显示组件。

first(容器)：例如，代码myCard.first(p);
last(容器)：例如 ， myCard.last(p);
next(容器)：例如，myCard.next(p);
previous(容器):myCard.previous(p);

【例11-7】小应用程序使用CardLayout布局，面板容器p使用CardLayout布局策略设置10个标签组件。窗口设有4个按钮，分别负责显示p的第一个组件、最后一个组件、当前组件的前一个组件和当前的组件的最后一个组件。

import java.applet.*;import java.awt.*;
import java.awt.event.*;import javax.swing.*;
class MyPanel extends JPanel{
  int x;JLabel label1;
  MyPanel(int a){
    x=a;getSize();
    label1=new JLabel("我是第"+x+"个标签");add(label1);
  }
  public Dimension getPreferredSize(){
    return new Dimension(200,50);
  }
}
public class J507 extends Applet implements ActionListener{
  CardLayout mycard;MyPanel myPanel[];JPanel p;
  private void addButton(JPanel pan,String butName,ActionListener listener){
    JButton aButton=new JButton(butName);
    aButton.addActionListener(listener);
    pan.add(aButton);
  }
  public void init(){
    setLayout(new BorderLayout());//小程序的布局是边界布局
    mycard=new CardLayout();
    this.setSize(400,150);
    p=new JPanel();p.setLayout(mycard);//p的布局设置为卡片式布局
    myPanel=new MyPanel[10];
    for(int i=0;i<10;i++){
      myPanel[i]=new MyPanel(i+1);
      p.add("A"+i,myPanel[i]);
    }
    JPanel p2=new JPanel();
    addButton(p2,"第一个",this);
    addButton(p2,"最后一个",this);
    addButton(p2,"前一个",this);
    addButton(p2,"后一个",this);
    add(p,"Center"); add(p2,"South");
  }
  public void actionPerformed(ActionEvent e){
    if (e.getActionCommand().equals("第一个"))mycard.first(p);
    else if(e.getActionCommand().equals("最后一个"))mycard.last(p);
    else if(e.getActionCommand().equals("前一个"))mycard.previous(p);
    else if(e.getActionCommand().equals("后一个"))mycard.next(p);
  }
}

五.null布局与setBounds方法

 空布局就是把一个容器的布局设置为null布局。空布局采用setBounds()方法设置组件本身的大小和在容器中的位置：
    setBounds(int x,int y,int width,int height)
组件所占区域是一个矩形，参数x,y是组件的左上角在容器中的位置坐标；参数weight,height是组件的宽和高。空布局安置组件的办法分两个步骤：先使用add()方法身容器添加组件。然后调用setBounds()方法设置组件在容器中的位置和组件本身的大小。与组件相关的其他方法：

1.getSize().width,
2.getSize().height
3.setVgap(ing vgap)
4.setHgap(int hgap);

更多java图形界面之布局设计相关文章请关注PHP中文网！