Conception de la mise en page de l'interface graphique Java

Dans la conception d'interface, un conteneur doit placer de nombreux composants. Pour des raisons de beauté, les composants sont disposés dans la position du conteneur. Il existe plusieurs classes de mise en page définies dans java.awt, et chaque classe de mise en page correspond à une stratégie de mise en page. Les classes de mise en page suivantes sont couramment utilisées :

•FlowLayout, qui place les composants en séquence.
•BoarderLayout, place les composants sur la bordure.
•CardLayout, empile des composants comme des cartes à jouer, et un seul composant peut être affiché à la fois.
•GridLayout divise la zone d'affichage en grilles égales par lignes et colonnes, et place les composants dans ces grilles à tour de rôle.
•GridBagLayout, divise la zone d'affichage en plusieurs petites unités rectangulaires, et chaque composant peut occuper une ou plusieurs petites unités.

Parmi eux, GridBagLayout peut effectuer un contrôle de position fin et est également le plus complexe. Ce tutoriel ne discutera pas de cette stratégie de mise en page pour le moment et sera expliqué en détail dans l'article spécial.

Chaque conteneur dispose d'un gestionnaire de disposition, qui détermine comment organiser les composants placés dans le conteneur. Un gestionnaire de mise en page est une classe qui implémente l'interface LayoutManager.

1. Disposition FlowLayout (disposition par défaut de JApplet, JPanel, JScrollPane)

La disposition FlowLayout organise les composants de gauche à droite dans l'ordre dans lequel ils sont ajoutés. Lorsqu'une ligne est pleine, tournez-vous vers. Les rangées continuent de gauche à droite, les composants de chaque rangée étant centrés. Il s'agit de la stratégie de présentation la plus simple et elle est généralement utilisée lorsqu'il n'y a pas beaucoup de composants. Lorsqu'il y a beaucoup de composants, les composants dans le conteneur apparaîtront inégaux, chaque ligne étant de longueurs différentes.

FlowLayout est la mise en page par défaut des petites applications et panneaux. Les méthodes de construction de la mise en page FlowLayout sont :

1.FlowLayout(), génère une mise en page FlowLayout par défaut. Par défaut, le composant est centré avec un écart de 5 pixels.
2.FlowLayout(int align), définit l'alignement de chaque composant. La valeur d'alignement peut être FlowLayout.LEFT, FlowLayout.CENTER, FlowLayout.RIGHT.
3.FlowLayout (int aligment, int horz, int vert), définissez l'alignement et définissez l'espacement horizontal horz et l'espacement vertical vert du composant. Utilisez la méthode setLayout() de la super classe Container pour définir la mise en page. pour le conteneur. Par exemple, le code setLayout(new FlowLayout()) définit la disposition FlowLayout pour le conteneur. La méthode pour ajouter un composant au conteneur est add(nom du composant).

2. Disposition BorderLayout (disposition par défaut de JWindow, JFrame, JDialog)

La stratégie de disposition BorderLayout consiste simplement à diviser l'espace dans le conteneur en Est "Est", Ouest "Ouest" et Sud. " Il existe cinq zones : « Sud », « Nord » et « Centre ». Lors de l'ajout d'un composant, vous devez spécifier la zone dans laquelle le composant doit être placé. Placez un composant dans une position. Si plusieurs composants doivent être ajoutés à un certain emplacement, les composants à ajouter à cet emplacement doivent d'abord être placés dans un autre conteneur, puis le conteneur est ajouté à cet emplacement.

Les méthodes de construction de la mise en page BorderLayout sont :
(1) BorderLayout(), qui génère une mise en page BorderLayout par défaut. Par défaut, il n'y a aucun écart.
(2) BorderLayout(int horz,int vert), définit l'espacement horizontal et vertical entre les composants.

La méthode de définition de la stratégie de mise en page BorderLayout est setLayout(new BorderLayout()). La méthode d'ajout d'un composant à un conteneur est add(nom du composant, position). Si aucune position n'est spécifiée lors de l'ajout d'un composant, la position par défaut est "milieu".

La disposition BorderLayout est la disposition par défaut de JWindow, JFrame et JDialog.
【Exemple 11-5】L'application comporte cinq étiquettes, qui sont placées dans les zones est, ouest, sud, nord et centre de la fenêtre.

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

La disposition GridLayout divise le conteneur en une grille de lignes et de colonnes. Le nombre de lignes et de colonnes est contrôlé par le programme et les composants sont placés sur le. grille. Dans la petite grille. La disposition GridLayout se caractérise par un positionnement des composants relativement précis. Étant donné que chaque grille de la disposition GridLayout a la même forme et la même taille, les composants placés dans le conteneur doivent également conserver la même taille.

Les méthodes de construction de la mise en page GridLayout sont :
(1) GridLayout(), qui génère une mise en page GridLayout à une seule colonne. Par défaut, il n'y a aucun écart.
(2) GridLayout(int row, int col), définit une disposition GridLayout avec ligne ligne et colonne colonne.
(3) GridLayout(int row,int col,int horz,int vert), définit le nombre de lignes et de colonnes de la mise en page, ainsi que l'espacement horizontal et vertical des composants.

La disposition GridLayout est basée sur des lignes. Lorsque le nombre de composants placés dépasse la limite, des colonnes seront automatiquement ajoutées ; à l'inverse, s'il y a trop peu de composants, les colonnes seront automatiquement réduites. reste inchangé et les composants sont classés par ordre de priorité des lignes (selon le composant Augmenter ou diminuer automatiquement les colonnes). Chaque grille de la mise en page GridLayout doit être remplie de composants. Si vous souhaitez qu'une grille soit vide, vous pouvez la remplacer par une étiquette vierge (add(new Label())).

[Exemple 11-6] L'applet place d'abord plusieurs boutons et étiquettes dans un JPanel, puis place le JPanel dans un JScrollPane, et enfin, place le JScrollPane dans la fenêtre de l'applet. Le JScrollPane créé a toujours. barres de défilement horizontales et verticales. La plage visible du panneau de défilement est inférieure aux exigences réelles du panneau. Vous pouvez déplacer le curseur de la barre de défilement pour afficher la zone du panneau qui n'était pas initialement dans la plage visible.

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中文网！