精华内容
下载资源
问答
  • Applet中的面板类Panel

    千次阅读 2014-04-24 14:07:38
    面板是最简单的容器类,在面板上可以添加包括其他面板在内的任何组件。

       面板是最简单的容器类,在面板上可以添加包括其他面板在内的任何组件。面板本身又是一个组件,可以将其放在其他容器中。

    Applet是容器,假设在其中放置了两个面板,每个面板上又放置一些按钮,按钮便可以按面板分组,

    在同一个面板上的按钮属于同一组,

    在不同面板上的按钮属于不同组。

    案例如下:

    package lay;

    import java.applet.*;
    import java.awt.*;
    public class Panel2 extends Applet{
      Panel pnl1,pnl2;
      Label lab1,lab2;
      Button btn1a,btn1b,btn2a,btn2b,btn;
      public void init(){
        pnl1=new Panel();//面板pnl1
        pnl2=new Panel();
        lab1=new Label("面板1");//标签lab1
        lab2=new Label("面板2");
        btn1a=new Button("按钮1a");//按钮btn1
        btn1b=new Button("按钮1b");
        btn2a=new Button("按钮2a");

        btn2b=new Button("按钮2b");
        btn=new Button("本按钮在两个按钮之外");
        pnl1.setBackground(Color.yellow);//面板pnl1背景色为黄色
        pnl2.setBackground(Color.green); //面板pnl2背景色为绿色
        add(pnl1); add(pnl2); //分别添加面板pnl1、pnl2

        pnl1.add(lab1); pnl1.add(btn1a); pnl1.add(btn1b);//分别添加标签lab1、按钮btnla、按钮btnlb
        pnl2.add(lab2); pnl2.add(btn2a); pnl2.add(btn2b);
      
        add(btn);
     }

    }

     

     -------------------------------------------------------------------------------------------------------------------------------------

    结果如下:

    展开全文
  • java,applet 容器、组件布局管理器

    千次阅读 2012-09-17 09:26:38
    10.2.1 容器  AWT容器分为两类:外部容器和内部容器。其中,外部容器一般会独立存在,例如Frame类;... 其中两个最常用的容器是Frame和Panel。在后面我们还要单独介绍Applet(一种特殊的Panel)。  框架
    10.2.1 容器 
    
      AWT容器分为两类:外部容器和内部容器。其中,外部容器一般会独立存在,例如Frame类;而内部容器则会嵌套在外部容器内部使用,例如Panel类。容器的层次结构如图10-2所示。
      
      
      图10-2 AWT容器的层次结构
      其中两个最常用的容器是Frame和Panel。在后面我们还要单独介绍Applet(一种特殊的Panel)。
      框架(Frame):Frame是顶级窗口,可以显示标题,重置大小。
      面板(Panel):面板提供了建立应用程序的空间。我们可以把图形元件(包括其他面板)放在一个面板上,然后把这个面板作为内部容器放在Frame等外部容器上。
      容器类的常用方法包括:
      add()
      add(Component com)
      add(Component, int index)
      add(Component component, Object constraints)
      add(String name, Component component),
      add(Component component, Object constraints, int index)
      setLayout() and getLayout()
      getComponent()
      getInsets()
      remove and removeAll()
      validate()
      这些方法主要与我们后面讲的步骤,例如布局管理、添加组件有关。
       10.2.2 布局管理
      选择了容器之后,可以通过容器的setLayout()和getLayout()方法来确定布局(Layout),也就是限制容器中各个组件的位置和大小等。
      Java提供了多种布局,如顺序布局(Flow Layout)、边界布局(Border Layout)和网格布局(Grid Layout)等。
       1.顺序布局
      顺序布局(Flow Layout)是最基本的一种布局,面板的默认布局就是顺序布局。顺序布局指的是把图形元件一个接一个地放在面板上。下面是一个顺序布局的例子。
      package sample;
      import java.awt.*;
      import java.awt.event.WindowAdapter;
      import java.awt.event.WindowEvent;
      public class MyFlowLayout {
      private Frame f;
      private Button button1, button2, button3;
      
      public static void main (String args[]) {
      MyFlowLayout mflow = new MyFlowLayout ();
      mflow.go();
      }
      
      public void go() {
      f = new Frame ("FlowLayout演示");
      f.addWindowListener(new WindowAdapter(){
      public void windowClosing(WindowEvent evt) {
      f.setVisible(false);
      f.dispose();
      System.exit(0);
      }
      });
      //f.setLayout(new FlowLayout());
      f.setLayout(new FlowLayout(FlowLayout.LEADING, 20, 20));
      button1 = new Button("确定");
      button2 = new Button("打开");
      button3 = new Button("关闭");
      f.add(button1);
      f.add(button2);
      f.add(button3);
      f.setSize (200,200);
      f.pack();
      f.setVisible(true);
      }
      }
      程序运行结果见图10-3。
      
      
      图10-3 顺序布局(Flow Layout)
       2.边界布局
      边界布局(Border Layout)包括5个区:北区、南区、东区、西区和中区。这5个区在面板上的分布规律是“上北下南,左西右东”。下面是一个边界布局的例子。
      package sample;
      import java.awt.*;
      import java.awt.event.WindowAdapter;
      import java.awt.event.WindowEvent;
      public class MyBorderLayout {
      Frame f;
      Button east, south, west, north, center;
      
      public static void main(String args[]) {
      MyBorderLayout mb = new MyBorderLayout();
      mb.go();
      }
      
      public void go() {
      f = new Frame("BorderLayout 演示");
      f.addWindowListener(new WindowAdapter(){
      public void windowClosing(WindowEvent evt) {
      f.setVisible(false);
      f.dispose();
      System.exit(0);
      }
      });
      
      f.setBounds(0,0, 300, 300);
      f.setLayout(new BorderLayout());
      
      north = new Button("北");
      south = new Button("南");
      east = new Button("东");
      west = new Button("西");
      center= new Button("中");
      
      f.add(BorderLayout.NORTH, north);
      f.add(BorderLayout.SOUTH, south);
      f.add(BorderLayout.EAST, east);
      f.add(BorderLayout.WEST, west);
      f.add(BorderLayout.CENTER, center);
      
      f.setVisible(true);
      }
      }
      程序运行结果见图10-4。
      
      
      图10-4 边界布局(Border Layout)
       3.网格布局
      网格布局(Grid Layout)把面板分成一个个大小相等的网格,你可以给出网格的行数和列数。下面是一个网格布局的例子。
      package sample;
      import java.awt.*;
      import java.awt.event.*;
      public class MyGridLayout {
      private Frame f;
      private Button[] btn;
      public static void main(String args[]) {
      MyGridLayout grid = new MyGridLayout();
      grid.go();
      }
      public void go() {
      f = new Frame("GridLayout演示");
      f.addWindowListener(new WindowAdapter(){
      public void windowClosing(WindowEvent evt) {
      f.setVisible(false);
      f.dispose();
      System.exit(0);
      }
      });
      
      f.setLayout (new GridLayout (3, 3, 10, 10));
      btn = new Button[9];
      for(int i = 0; i <=8; i++) {
      int j = i + 1;
      btn[i] = new Button("" + j);
      f.add(btn[i]);
      }
      
      // f.pack();
      f.setSize(100, 100);
      f.setVisible(true);
      }
      }
      程序运行结果见图10-5。
      
      
      图10-5 网格布局(Grid Layout)
       4.卡片布局
      卡片布局(Card Layout)把每个组件看作一张卡片,好像一副扑克牌,它们叠在一起,每次只有最外面的一个组件可以被看到。
      package sample;
      import java.awt.*;
      import java.awt.event.*;
      public class MyCardLayout {
      public static void main(String args[]) {
      new MyCardLayout().go();
      }
      
      public void go() {
      final Frame f = new Frame("CardLayout演示");
      f.addWindowListener(new WindowAdapter(){
      public void windowClosing(WindowEvent evt) {
      f.setVisible(false);
      f.dispose();
      System.exit(0);
      }
      });
      
      f.setSize(300, 100);
      f.setLayout(new CardLayout());
      
      final Frame f1 = f;
      for(int i = 1; i <= 5; ++i) {
      Button b = new Button("Button "+ i);
      b.setSize(100, 25);
      b.addActionListener(new ActionListener() {
      public void actionPerformed(ActionEvent ae) {
      CardLayout cl = (CardLayout)f1.getLayout();
      cl.next(f1);
      }
      } );
      f.add(b, "button" + i);
      }
      f.setVisible(true);
      }
      }
      程序运行结果见图10-6。
      图10-6 卡片布局(Card Layout)
      单击按钮Button1后,显示下一个按钮Button2,依此类推。
       5.网格包布局
      网格包(GridBag)布局是基于网格布局之上的一种改进。和基本的网格布局不同的是,一个组件可以跨越一个或多个网格,这样一来增加了布局的灵活性。为了处理网格的跨越性,我们可以使用GridBagConstraints类。有兴趣的读者可以参考Java API来了解它。
      package sample;
      import java.awt.*;
      import java.util.*;
      import java.awt.event.*;
      public class MyGridBagLayout extends Panel {
      protected void makebutton(String name,
      GridBagLayout gridbag,
      GridBagConstraints c) {
      Button button = new Button(name);
      gridbag.setConstraints(button, c);
      add(button);
      }
      public void go() {
      GridBagLayout gridbag = new GridBagLayout();
      GridBagConstraints c = new GridBagConstraints();
      setFont(new Font("Helvetica", Font.PLAIN, 14));
      setLayout(gridbag);
      c.fill = GridBagConstraints.BOTH;
      c.weightx = 1.0;
      makebutton("Button001", gridbag, c);
      makebutton("Button2", gridbag, c);
      makebutton("Button3", gridbag, c);
      c.gridwidth = GridBagConstraints.REMAINDER; //end row
      makebutton("Button4", gridbag, c);
      c.weightx= 0.0; //reset to the default
      makebutton("Button5", gridbag, c); //another row
      c.gridwidth = 2; //GridBagConstraints.RELATIVE; //next-to-last in row
      makebutton("Button6", gridbag, c);
      c.gridwidth = GridBagConstraints.REMAINDER; //end row
      makebutton("Button007", gridbag, c);
      c.gridwidth =1; //reset to the default
      c.gridheight = 2;
      c.weighty = 1.0;
      makebutton("Button8", gridbag, c);
      c.weighty= 1.0; //reset to the default
      c.gridwidth = GridBagConstraints.REMAINDER; //end row
      c.gridheight = 1; //reset to the default
      makebutton("Button9", gridbag, c);
      makebutton("Button10", gridbag, c);
      setSize(300, 100);
      }
      public static void main(String args[]) {
      final Frame f = new Frame("GridBagLayout 演示");
      f.addWindowListener(new WindowAdapter(){
      public void windowClosing(WindowEvent evt) {
      f.setVisible(false);
      f.dispose();
      System.exit(0);
      }
      });
      MyGridBagLayout gb = new MyGridBagLayout();
      gb.go();
      f.add("Center", gb);
      f.pack();
      f.setVisible(true);
      }
      }
      程序运行结果见图10-7。
      
      
      图10-7 网格包(GridBag)布局
       10.2.3 AWT组件库
      本节从应用的角度进一步介绍AWT的一些组件,目的是使大家加深对AWT的理解,掌握如何用各种组件构造图形化用户界面,学会控制组件的颜色和字体等属性。在介绍组件过程中,我们提前引入了事件处理的一些相关内容(之后会详细展开)。
      下面是一些常用组件的介绍。
       1.按钮(Button)
      按钮是最常用的一个组件,其构造方法如下:
      Button b = new Button("Quit");
      当按钮被点击后,会产生ActionEvent事件,由ActionListener接口进行监听和处理事件。
      ActionEvent的对象调用getActionCommand()方法可以得到按钮的标识名,默认按钮名为label。用setActionCommand()可以为按钮设置组件标识符。
       2.标签
      标签是一种放到面板上的静止的正文。其构造方法如下:
      Label label1 = new Label("你好!")
      下面是一个标签的例子。
      import java.awt.*;
      import java.applet.Applet;
      public class LabelTest extends Applet {
      public void init() {
      setLayout(new FlowLayout(FlowLayout.CENTER, 10, 10));
      Label label1 = new Label("你好!");
      Label label2 = new Label("欢迎!");
      add(label1);
      add(label2);
      }
      ……
      }
       3.复选框(Checkbox)
      复选框提供简单的“on/off”开关,旁边显示文本标签。
      其主要方法如下:
      setLayout(new GridLayout(3,1));
      add(new Checkbox("one",null,true));
      add(new Checkbox("two"));
      add(new Checkbox("three"));
      复选框用ItemListener来监听ItemEvent事件,当复选框状态改变时,用getStateChange()获取当前状态,使用getItem()获得被修改复选框的字符串对象。
       4.复选框组(CheckboxGroup)
      使用复选框组,可以实现单选框的功能,也就是说,只能选择其中的一项。方法如下:
      setLayout(new GridLayout(3, 1));
      CheckboxGroup cbg = new CheckboxGroup();
      add(new Checkbox("one", cbg, true));
      add(new Checkbox("two", cbg, false));
      add(new Checkbox("three", cbg, false));
       5.下拉式菜单(Choice)
      下拉式菜单每次只能选择其中的一项,它能够节省显示空间,适用于大量选项。
      Choice colorChooser=new Choice();
      colorChooser.add("Green");
      colorChooser.add("Red");
      colorChooser.add("Blue");
      Choice用ItemListener接口来进行监听。
       6.画布(Canvas)
      一个应用程序必须继承Canvas类才能获得有用的功能,比如创建一个自定义组件。如果想在画布上完成一些图形处理,则Canvas类中的paint()方法必须被重写。
      Canvas组件监听各种鼠标、键盘事件。当在Canvas组件中输入字符时,必须先调用requestFocus()方法。
      创建画布的实例如下:
      import java.awt.*;
      import java.applet.Applet;
      public class CanvasGUI extends Applet {
      . . .
      MyCanvas doodle;
      . . .
      public void init() {
      . . .
      //建立我们的画布
      doodle = new MyCanvas();
      doodle.reshape(0,0,100,100);
      leftPanel.add("Center",doodle);
      . . .
      }
      }
      class MyCanvas extends Canvas {
      public void paint(Graphics g) {
      g.drawRect(0, 0, 99, 99);
      g.drawString("Canvas",15,40);
      }
      }
       7.单行文本输入区(TextField)
      单行文本输入区也叫做文本域,一般用来让用户输入像姓名、信用卡号这样的信息,它是一个能够接收用户的键盘输入的小块区域。
      单行文本输入区构造方法有4种类型供选择:空的、空的并且具有指定长度、带有初始文本内容的和带有初始文本内容并具有指定长度的。下面是生成这4种文本域的代码。
      TextField tf1, tf2, tf3, tf4;
      //空的文本域
      tf1 = new TextField();
      //长度为20的空的文本域
      tf2 = new TextField(20);
      //带有初始文本内容的文本域
      tf3 = new TextField("你好");
      //带有初始文本内容并具有指定长度的文本域
      tf4 = new TextField("你好", 30);
      单行文本输入区只能显示一行,当按下回车键时,会发生ActionEvent事件,可以通过ActionListener中的actionPerformed()方法对事件进行相应处理。可以使用setEditable(boolean)方法设置为只读属性。
       8.文本输入区(TextArea)
      TextArea可以显示多行多列的文本。与文本域类似,创建文本区时也有4种类型供选择,但如果指定文本区的大小,必须同时指定行数和列数。
      TextArea ta1, ta2;
      //一个空的文本区
      ta1 = new TextArea();
      //一个带有初始内容、大小为5x40的文本区
      ta2 = new TextArea("你好!", 5, 40);
      可以用成员方法setEditable()来决定用户是否可以对文本区的内容进行编辑。
      //使文本区为只读的
      ta2.setEditable(false)
      我们可以用成员方法getText()来获得文本区的当前内容。在TextArea中可以显示水平或垂直的滚动条。要判断文本是否输入完毕,可以在TextArea旁边设置一个按钮,通过按钮点击产生的ActionEvent事件对输入的文本进行处理。
       9.列表(List)
      列表框使用户易于操作大量的选项。创建列表框的方法和下拉式菜单有些相似。列表框的所有条目都是可见的,如果选项很多,超出了列表框可见区的范围,则列表框的旁边将会有一个滚动条。列表框中提供了多个文本选项,可以浏览多项。
      List lst=new List(4,false); //两个参数分别表示显示的行数,是否允许多选
      lst.add("Venus");
      lst.add("Earth");
      lst.add("Moon");
      lst.add("Mars");
      cnt.add(lst);
       10.滚动条
      在某些程序中,需要调整线性的值,这时就需要滚动条。滚动条提供了易于操作的值的范围或区的范围。
      (1)创建滚动条
      当创建一个滚动条时,必须指定它的方向、初始值、滑块的大小、最小值和最大值。
      public Scrollbar(int orientation, int initialValue, int sizeOfSlider, int minValue, int maxValue);
      下面是一个例子。
      Scrollbar redSlider;
      public void init() {
      redSlider = new Scrollbar(Scrollbar.VERTICAL,0,1,0,255);
      add(redSlider);
      }
      (2)滚动条事件
      和其他接口元件一样,滚动条产生一个可以控制的事件;但和其他事件不同,你必须直接使用成员方法handleEvent(),而不能使用成员方法action()。
      (3)滚动条的值的显示
      如果想显示滑块所在位置的值,则需要添加一个自己的文本域。下面是一个例子。
      import java.awt.*;
      import java.applet.Applet;
      public class RedSliderTest extends Applet {
      Scrollbar redslider;
      TextField redvalue;
      Label redlabel;
      public void init( ) {
      setLayout(new GridLayout(1,3));
      redslider = new Scrollbar(Scrollbar.HORIZONTAL,0,1,0,255);
      redvalue = new TextField("0",5);
      redvalue.setEditable(false);
      redlable = new Label("Red(0-255)");
      add(redlabel);
      add(redslider);
      add(redvalue);
      }
      public boolean handleEvent(Event e) {
      if (e.target instanceof Scrollbar) {
      redvalue.setText(Integer.toString(((Scrollbar)e.target).getValue()));
      return true;
      }
      return super.handleEvent(e);
      }
      public boolean action(Event e, Object arg) {
      System.out.println("Event"+ arg);
      return true;
      }
      }
       11.对话框(Dialog)
      对话框是Window类的子类,是一个容器类,属于特殊组件。对话框和一般窗口的区别在于它依赖于其他窗口。对话框分为非模式(non-modal)和模式(modal)两种。
       12.文件对话框(Filedialog)
      当用户想打开或存储文件时,使用文件对话框进行操作。主要代码如下:
      FileDialog d=new FileDialog(ParentFr,"FileDialog");
      d.setVisible(true);
      String filename=d.getFile();
       13.菜单(Menu)
      菜单的开发相对复杂,我们需要使用3个类:Menu、MenuBar和MenuItem。它们的层次结构如图10-8所示。
      
      
      图10-8 菜单的层次结构
      (1)MenuBar
      我们无法直接将菜单添加到容器的某一位置,也无法使用布局管理器对其加以控制。菜单只能被添加到菜单容器(MenuBar)中。MenuBar会被添加到Frame对象中,作为整个菜单树的根基。
      Frame fr = new Frame("MenuBar");
      MenuBar mb = new MenuBar();
      fr.setMenuBar(mb);
      fr.setSize(150,100);
      fr.setVisible(true);
      (2)Menu
      菜单可以被添加到MenuBar中或其他Menu中。
      Frame fr = new Frame("MenuBar");
      MenuBar mb = new MenuBar();
      fr.setMenuBar(mb);
      Menu m1 = new Menu("File");
      Menu m2 = new Menu("Edit");
      Menu m3 = new Menu("Help");
      mb.add(m1);
      mb.add(m2);
      mb.setHelpMenu(m3);
      fr.setSize(200,200);
      fr.setVisible(true);
      (3)MenuItem
      MenuItem是菜单树中的“叶子节点”。MenuItem通常被添加到一个Menu中。对于MenuItem对象可以添加ActionListener,使其能够完成相应的操作。
      Menu m1 = new Menu("File");
      MenuItem mi1 = new MenuItem("Save");
      MenuItem mi2 = new MenuItem("Load");
      MenuItem mi3 = new MenuItem("Quit");
      m1.add(mi1);
      m1.add(mi2);
      m1.addSeparator();
      m1.add(mi3);
      MenuBar和Menu都没有必要注册监听器,只需要对MenuItem添加监听器ActionListener,完成相应的操作。
      我们看一个完整的Menu实例。
      /**
      * 演示Menu、MenuBar和MenuItem的使用
      */
      package sample;
      import java.awt.*;
      import java.awt.event.*;
      class MenuTest extends Frame {
      PopupMenu pop;
      public MenuTest() {
      super("Golf Caddy");
      addWindowListener(new WindowAdapter() {
      public void windowClosing(WindowEvent evt) {
      setVisible(false);
      dispose();
      System.exit(0);
      }
      });
      this.setSize(300,300);
      //this.setLayout(new FlowLayout());
      this.add(new Label("Choose club."), BorderLayout.NORTH);
      
      Menu woods = new Menu("Woods");
      woods.add("1 W");
      woods.add("3 W");
      woods.add("5 W");
      
      Menu irons = new Menu("Irons");
      irons.add("3 iron");
      irons.add("4 iron");
      irons.add("5 iron");
      irons.add("7 iron");
      irons.add("8 iron");
      irons.add("9 iron");
      irons.addSeparator();
      irons.add("PW");
      irons.insert("6 iron", 3);
      
      MenuBar mb = new MenuBar();
      mb.add(woods);
      mb.add(irons);
      this.setMenuBar(mb);
      
      pop = new PopupMenu("Woods");
      pop.add("1 W");
      pop.add("3 W");
      pop.add("5 W");
      
      final TextArea p = new TextArea(100, 100);
      
      p.setBounds(0,0,100,200);
      p.setBackground(Color.green);
      p.add(pop);
      //以下是事件处理,稍后介绍
      p.addMouseListener(new MouseAdapter() {
      public void mouseReleased(java.awt.event.MouseEvent evt) {
      if(evt.isPopupTrigger()) {
      System.out.println("popup trigger");
      System.out.println(evt.getComponent());
      System.out.println("" + evt.getX()+ ""+ evt.getY());
      pop.show(p, evt.getX(), evt.getY());
      }
      
      }
      });
      this.add(p, BorderLayout.CENTER);
      }
      
      public static void main (String [] args) {
      new MenuTest().setVisible(true);
      }
      } 
    展开全文
  • AWT初步—Frame Panel

    2017-01-17 16:08:00
    GUI AWT GUI:Graphics User Interface 图形用户界面 AWT:AbstractWindow Toolkit 抽象窗口工具集 之前的程序输出结果均在控制台上显示,现在学习AWT后,可以编程显示图形用户界面。 抽象窗口工具包AWT ...
    1. 初识 AWT

          GUI 和 AWT

    GUI:Graphics User Interface  图形用户界面

    AWT:Abstract Window Toolkit  抽象窗口工具集

    之前的程序输出结果均在控制台上显示,现在学习AWT后,可以编程显示图形用户界面。

    抽象窗口工具包AWT (Abstract Window Toolkit) 是 API为Java 程序提供的建立图形用户界面GUI (Graphics User Interface)工具集,之所以叫抽象窗口工具集,是因为该图形用户界面可以与系统无关,可以跨平台AWT可用于Java的applet和applications中,它支持图形用户界面编程。

    • 功能包括:

    用户界面组件;

    事件处理模型;

    图形和图像工具,包括形状、颜色和字体类;

    布局管理器,可以进行灵活的窗口布局而与特定窗口的尺寸和屏幕分辨率无关;

    数据传送类,可以通过本地平台的剪贴板来进行剪切和粘贴。

    • java.awt包

    java.awt包中提供了GUI设计所使用的类和接口。
    java.awt包提供了基本的java程序的GUI设计工具。主要包括下述三个概念:

    组件--Component
    容器--Container
    布局管理器--LayoutManager

    • 组件、容器和布局管理器

     组件    

          Java的图形用户界面的最基本组成部分是组件(Component),组件是一个可以以图形化的方式显示在屏幕上并能与用户进行交互的对象,例如一个按钮,一个标签等。组件不能独立地显示出来,必须将组件放在一定的容器中才可以显示出来。

    常用组件:

          Button 按钮:

          label 标签 :显示文字内容

          TextField 文本框 :接受用户输入

          这些组件都被封装成类,编程时进行实例化被直接调用。

      类java.awt.Component是许多组件类的父类,Component类中封装了组件通用的方法和属性,如图形的组件对象、大小、显示位置、前景色和背景色、边界、可见性等,因此许多组件类也就继承了Component类的成员方法和成员变量,相应的成员方法包括:

            getComponentAt(int x, int y)
       getFont()
       getForeground()
       getName()
       getSize()
       paint(Graphics g)
       repaint()
       update()
       setVisible(boolean b)
       setSize(Dimension d)
       setName(String name)等

    容器

     

          容器(Container)也是一个类,实际上是Component的子类,因此容器本身也是一个组件,具有组件的所有性质,但是它的主要功能是容纳其它组件和容器。

    常用容器

      容器java.awt.Container是Component的子类,一个容器可以容纳多个组件,并使它们成为一个整体。容器可以简化图形化界面的设计,以整体结构来布置界面。所有的容器都可以通过add()方法向容器中添加组件。

      有三种类型的容器:Window、Panel、ScrollPane,常用的有Panel, Frame, Applet。

     1.Frame 窗口
         继承关系


      


    • 程序实现
    public class Demo01 {
    
        public static void main(String[] args) {
            Frame frame = new Frame("我的第一个窗口");
            frame.setBounds(50, 50, 300, 200);//设置Frame 的大小,距离windows界面上左均为50,宽和高分别为300 200
            frame.setBackground(Color.PINK);
            frame.setVisible(true);//设置Frame为可见
    
        }
    
    }

    Output:

     

          一般我们要生成一个窗口,通常是用Window的子类Frame来进行实例化,而不是直接用到Window类。Frame的外观就像我们平常在windows系统下见到的窗口,有标题、边框、菜单、大小等等。每个Frame的对象实例化以后,都是没有大小和不可见的,因此必须调用setSize( )来设置大小,调用setVisible(true)来设置该窗口为可见的。

      另外,AWT在实际的运行过程中是调用所在平台的图形系统,因此同样一段AWT程序在不同的操作系统平台下运行所看到的图形系统是不一样的。例如在windows下运行,则显示的窗口是windows风格的窗口;而在UNIX下运行时,则显示的是UNIX风格的窗口。

    2. Panel 面板

     
     

     

    • 程序实现
    public class Demo02 {
    
        public static void main(String[] args) {
            Frame frame = new Frame("我的panel 界面");
            frame.setBounds(50, 50, 500, 300);
            Panel panel = new Panel();
            panel.setBackground(Color.pink);
            //panel.setBounds(0, 0, 200, 100); 如果要用 panel将整个窗口分块,则要用到布局管理器,不可直接调用实现
            
            frame.add(panel);
            frame.setVisible(true);
            
        }
    
    }

    Output:

     

    Panel 可以作为容器容纳其他组件,但不可以像Frame 一样独立存在,必须将其添加到其他容器其中。

    • 简单的用户登陆界面的代码实现
    public class Demo03 {
    
        public static void main(String[] args) {
            Frame frame = new Frame("用户登入窗口");
            frame.setBounds(50, 50, 400, 100);
            
            Panel panel = new Panel();
            panel.setBackground(Color.pink);
            frame.add(panel);
            
            Label lable = new Label("用户名");
            TextField textField = new TextField("请输入用户名",20);//20为文本框长度
            Button loginbtn = new Button("确定");
            
            panel.add(lable);
            panel.add(textField);
            panel.add(loginbtn);
            
            frame.setVisible(true);
        }
    
    }

    Output:

     

          需要注意的是,Lebel 、TextField、 Button这些组件的添加是有顺序的,以上是一个简单的界面,比较复杂的情况则要使用布局管理器来实现。 并且以上的代码比较简单,实现的只是最基本的显示功能,并不能进行实际的登陆与关闭操作。


      布局管理器(LayoutManager):每个容器都有一个布局管理器,当容器需要对某个组件进行定位或判断其大小尺寸时,就会调用其对应的布局管理器。

    为了使我们生成的图形用户界面具有良好的平台无关性,Java语言中,提供了布局管理器这个工具来管理组件在容器中的布局,而不使用直接设置组件位置和大小的方式。

          布局管理器主要包括:FlowLayout,BorderLayout,GridLayout,CardLayout,GridBagLayout

    1. FlowLayout(流布局)

      FlowLayout 是Panel,Applet的缺省布局管理器(默认布局管理器)。其组件的放置规律是从上到下、从左到右进行放置,如果容器足够宽,第一个组件先添加到容器中第一行的最左边,后续的组件依次添加到上一个组件的右边,如果当前行已放置不下该组件,则放置到下一行的最左边。

          FlowLayout(FlowLayout.RIGHT,20,40);
      /*第一个参数表示组件的对齐方式,指组件在这一行中的位置是居中对齐、居右对齐还是居左对齐,第二个参数是组件之间的横向间隔,第三个参数是组件之间的纵向间隔,单位是象素。*/
      FlowLayout(FlowLayout.LEFT);
      //居左对齐,横向间隔和纵向间隔都是缺省值5个象素

      FlowLayout();
      //缺省的对齐方式居中对齐,横向间隔和纵向间隔都是缺省值5个象素

    • 代码实现
        public static void main(String[] args) {
            Frame frame = new Frame("FlowLayout");
            frame.setBounds(100, 100, 400, 300);
            frame.setLayout(new FlowLayout());
            
            Button but1 = new Button("button1");
            Button but2 = new Button("button2");
            Button but3 = new Button("button3");
            Button but4 = new Button("button4");
            Button but5 = new Button("button5");
            
            but1.setBackground(Color.blue);
            but2.setBackground(Color.yellow);
            but3.setBackground(Color.red);
            but4.setBackground(Color.green);
            but5.setBackground(Color.pink);
            
            frame.add(but1);
            frame.add(but2);
            frame.add(but3);
            frame.add(but4);
            frame.add(but5);
            
            frame.setVisible(true);
            
        }
    
    }

    Output:

          流布局与麻将布局的不同在于麻将布局要自己设置东西南北中的位置布局,而流布局则是按照按钮的调用先后顺序依次排列。默认居中排列,如果要设置为居左或居右排列,只需实例化FlowLayout ,用其实例对象 fl 调用设置队列的方法,将其设置为居左。

    即FlowLayout fl = new FlowLayout();
       fl.setAlignment(FlowLayout.LEFT);
       frame.setLayout(fl);

    上图为居左放置。

    2. BorderLayout(麻将布局)

      BorderLayout 是Window,Frame和Dialog的缺省(默认)布局管理器。BorderLayout布局管理器把容器分成5个区域:North,South,East,West和Center,每个区域只能放置一个组件。各个区域的位置及大小如下图所示:

        

    • 代码实现
    public class Demo04 {
    
        public static void main(String[] args) {
            Frame frame = new Frame("BorderLayt");
            frame.setBounds(100, 100, 400, 300);
            //设置 frame 的布局为BorderLayout
            frame.setLayout(new BorderLayout());
            
            Button btn1 = new Button("button1");
            Button btn2 = new Button("button2");
            Button btn3 = new Button("button3");
            Button btn4 = new Button("button4");    
            Button btn5 = new Button("button5");
            
            btn1.setBackground(Color.blue);
            btn2.setBackground(Color.yellow);
            btn3.setBackground(Color.pink);
            btn4.setBackground(Color.green);
            btn5.setBackground(Color.red);
            
            frame.add(btn1,BorderLayout.EAST);
            frame.add(btn2,BorderLayout.NORTH);
            frame.add(btn3,BorderLayout.SOUTH);
            frame.add(btn4,BorderLayout.WEST);
            frame.add(btn5);
            
            frame.setVisible(true);
        }
    
    }

    Output:

     

    3. GridLayout(表格布局)

      使容器中各个组件呈网格状布局,平均占据容器的空间。

      在程序中安排组件的位置和大小时,应该注意以下两点:

    • 容器中的布局管理器负责各个组件的大小和位置,因此用户无法在这种情况下设置组件的这些属性。如果试图使用Java 语言提供的setLocation(),setSize(),setBounds() 等方法,则都会被布局管理器覆盖。
    • 如果用户确实需要亲自设置组件大小或位置,则应取消该容器的布局管理器,方法为:setLayout(null);

     

    •  代码实现
    public class Demo06 {
    
        public static void main(String[] args) {
            Frame frame = new Frame("FlowLayout");
            frame.setBounds(100, 100, 400, 300);
            
            GridLayout gl = new GridLayout(3,2,5,5); //设置表格为3行两列排列,表格横向间距为5个像素,纵向间距为5个像素
            frame.setLayout(gl);
            
            
            Button but1 = new Button("button1");
            Button but2 = new Button("button2");
            Button but3 = new Button("button3");
            Button but4 = new Button("button4");
            Button but5 = new Button("button5");
            
            but1.setBackground(Color.blue);
            but2.setBackground(Color.yellow);
            but3.setBackground(Color.red);
            but4.setBackground(Color.green);
            but5.setBackground(Color.pink);
            
            frame.add(but1);
            frame.add(but2);
            frame.add(but3);
            frame.add(but4);
            frame.add(but5);
            
            frame.setVisible(true);
            
        }
    
    }

    Output:

    • 综合运用—— 实现一个简单的4*4 计算器界面
    public class Demo07 {
    
        public static void main(String[] args) {
            Frame frame = new Frame("计算器");
            frame.setBounds(100, 100, 300, 420);
            /*因为Frame 的默认布局为BorderLayout 所以这两句代码可以省略。
            BorderLayout bl = new BorderLayout();
            frame.setLayout(bl);
            */
            
            //创建一个文本输入框,然后将其添加到 North 位置
            TextField tf = new TextField();
            frame.add(tf, BorderLayout.NORTH);
            
            //创建一个Panel 面板,并设置布局为 GridLayout
            Panel panel = new Panel();
            GridLayout gl = new GridLayout(4,4,1,1);//创建Panel 面板,大小为4*4,行距与列距均为1 个像素点
            panel.setLayout(gl);
            
            //将 panel 添加到 frame 的 Center 位置
            frame.add(panel, BorderLayout.CENTER);
            Button btn1 = new Button (" 7");
            Button btn2 = new Button (" 8");
            Button btn3 = new Button (" 9");
            Button btn4 = new Button (" +");
            Button btn5 = new Button (" 4");
            Button btn6 = new Button (" 5");
            Button btn7 = new Button (" 6");
            Button btn8 = new Button (" -");
            Button btn9 = new Button (" 1");
            Button btn10 = new Button ("2");
            Button btn11 = new Button ("3 ");
            Button btn12 = new Button ("*");
            Button btn13 = new Button ("0 ");
            Button btn14 = new Button (" .");
            Button btn15 = new Button (" =");
            Button btn16 = new Button (" /");
            
            //将按钮添加到 Panel 面板
            panel.add(btn1);
            panel.add(btn2);
            panel.add(btn3);
            panel.add(btn4);
            panel.add(btn5);
            panel.add(btn6);
            panel.add(btn7);
            panel.add(btn8);
            panel.add(btn9);
            panel.add(btn10);
            panel.add(btn11);
            panel.add(btn12);
            panel.add(btn13);
            panel.add(btn14);
            panel.add(btn15);
            panel.add(btn16);
            
            frame.setVisible( true);
            
        }
    
    }

    Output:

    • 总结


       1.Frame是一个顶级窗口。Frame的缺省布局管理器为BorderLayout。

       2.Panel 无法单独显示,必须添加到某个容器中。 Panel 的缺省布局管理器为FlowLayout。

       3.当把Panel 作为一个组件添加到某个容器中后,该Panel 仍然可以有自己的布局管理器。因此,可以利用Panel 使得BorderLayout 中某个区域显示多个组件,达到设计复杂用户界面的目的 。

       4.如果采用无布局管理器 setLayout(null),则必须使用setLocation(),setSize(),setBounds()等方法手工设置组件的大小和位置,此方法会导致平台相关,不鼓励使用。

     

    转载于:https://www.cnblogs.com/linlin0/p/6293498.html

    展开全文
  • Applet

    千次阅读 2018-04-03 14:01:43
    Applet称为JAVA小应用程序。这种Applet程序的“.class”文件可以被嵌入到Web网页中,当支持JAVA的浏览器下载含有JAVA 小应用程序的网页时,就可以解析执行其中的Applet程序。与一般的JAVA应用程序不同,Applet不是...

    Applet称为JAVA小应用程序。这种Applet程序的“.class”文件可以被嵌入到Web网页中,当支持JAVA的浏览器下载含有JAVA   小应用程序的网页时,就可以解析执行其中的Applet程序。
    与一般的JAVA应用程序不同,Applet不是通过main()方法来运行的。在运行时Applet通常会与用户进行互动,显示动态的画面,并且还会遵循严格的安全检查,阻止潜在的不安全因素(例如根据安全策略,限制Applet对客户端文件系统的访问)。

    Applet的语言特点

      类的定义如:

    public class AppletApp extends Applet

    Applet在浏览器中通过<Applet>标记嵌入在HTML文件中。如:

    < Applet

       code = " AppletApp.class"

       width= "500“  height= "300"

     />

    <Applet>标记的作用是在网页上加载Applet小程序,<Applet>标记的code属性指明网页上加载的Applet的类文件名称,width和height属性分别决定了Applet小程序的宽度和高度。

     

     Applet的生命周期

    Applet的生命周期的四个方法:

    init()

    start()

    stop()

    destroy()


    Applet方法介绍-1

    init( )方法,创建Applet时执行,只执行一次

    当一个新的小程序被浏览器加载,第一个被执行的方法就是init()方法,目的就是对Applet实例对象进行初始化设置。初始化工作可能包含创建Applet所需要的对象、设置初始状态、加载图像或者文字、设置参数等等。

    star( )方法多次执行,当浏览器打开该主页,或者是返回该主页时执行。

    系统在调用完init()方法之后,将自动调用start()方法。如果前面停止了Applet,也可能会出现重新启动。比如页面被重新访问后,调用该方法再次启动对页面进行处理。

    stop( )方法多次执行,在离开主页时执行,主要功能是停止一些耗用系统资源的工作。

    停止和启动是成对出现的。浏览器从当前页面跳转到其他页面时,将会调用stop()方法。该方法通常用于停止当前页面的活动线程,以便节省系统资源。也可自己以通过调用该方法使Applet自己来停止。

    destroy( )方法用来释放资源,在stop( )之后执行。

    正常结束浏览器进程时调用destroy()方法,可以使得Applet从内存中释放。我们可以使用destroy()方法来终止任何正在运行的线程,或者释放任何其他正在运行的对象。一般情况下,很少使用destroy()方法,除非有特定的资源需要释放。

     

    Applet的事件

    Applet中的事件和Frame中的事件实现起来是类似的。

    AppletGUI界面,即在Applet中可以使用JAVA语言中全部AWT组件和工具,包括事件和监听器等,来构造一个完整的界面。

    Applet类在类库中被定义为Panel类的子类,是一个面板容器,所以Applet默认的布局管理器为FlowLayout。理解这一点我们就很容易为Applet添加事件处理了。

     

    Applet和浏览器之间进行通信

    Applet类中提供了许多方法,使之可以与浏览器进行通信。

    getDocumentBase( ) 返回当前网页所在的URL

    getCodeBase( ) 返回当前applet所在的URL

    getImage(URL base,String target)  返回网址URL中名为target的图像

    getAudioClip(URL base,String target)   返回网址URL中名为target的声音对象

    getParameter(String target )  提取HTML文件中名为target的参数的值

    public AppletContext getAppletContext();

    通过AppletContext对象,可以得到当前小应用程序运行环境的信息。AppletContext是一个接口,其中定义了一些方法可以得到当前页的其它小应用程序,进而实现同页小应用程序之间的通信。

     

     

     


    展开全文
  • C#基础教程-c#实例教程,适合初学者

    万次阅读 多人点赞 2016-08-22 11:13:24
    本章介绍C#语言的基础知识,希望具有C语言的读者能够基本掌握C#语言,并以此为基础,能够进一步学习用C#语言编写window应用程序Web应用程序。当然仅靠一章的内容就完全掌握C#语言是不可能的,如需进一步学习C#语言...
  • Java 版 (精华区)--Frame和Panel的区别

    千次阅读 2015-10-23 17:02:55
    初学Java的时候一直弄不清Frame和Panel的区别,都是在上面装组件,也没看出什 么所以然,一直稀里糊涂地用。最近看来一下Java类库中几个主要类的源文件,才明白 了一点所以然。写下了此文,希望能给大家一点帮助。...
  • Java applet详解

    万次阅读 多人点赞 2018-09-09 14:55:52
    注:applethtml或者是jsp一起使用的,不能单独运行(当然你可以使用appletviewer命令或者是ide去运行),具体的使用将在代码中体现。 2. applet生命周期 初始化init():在这个方法中可以设置一些初始值...
  • Java --Frame和Panel的区别

    千次阅读 2017-05-28 19:44:38
    初学Java的时候一直弄不清Frame和Panel的区别,都是在上面装组件,也没看出什 么所以然,一直稀里糊涂地用。最近看来一下Java类库中几个主要类的源文件,才明白 了一点所以然。写下了此文,希望能给大家一点帮助。...
  • 引入了contextsession listeners的概念,当context 或session被初始化或者被将要被释放的时候,当向context或session中绑定属性或解除绑定的时候,可以对类进行监测。 servlet2.4新增功能 折叠 ...
  • Frame和Panel

    2019-11-21 14:49:25
    FlowLayout是Panel和 Applet的默认布局管理器。在该布局管理器中,组件在容器中按照从上到下,从左到右的顺序进行排列,行满后则换行。 BorderLayout是Window、FrameDialog的默认布局管理器,其将容器分成North、...
  • Applet介绍

    千次阅读 2015-10-08 14:10:10
    创建窗口与Applet   设计的宗旨是"能轻松完成简单的任务,有办法完成复杂的任务"。   本章只介绍Java 2的Swing类库,并且合理假定Swing是Java GUI类库的发展方向。   本章的开头部分会讲,用Swing创建applet与...
  • Java基础——GUI编程和Applet

    千次阅读 2013-07-14 20:09:06
    33、GUI 概述 GUI(Graphical User interface)图形用户接口 用图形的方式,来显示计算机操作的界面,这样更方便,更直观 CLI(Command Line User Interface)命令行用户...Java为GUI提供的对象都存在Java.awtJa
  • 选择题JAVA

    2021-06-16 15:01:57
    下面(ABE) 是合法的语句(以下PanelApplet和Frame类来自于java.awt包, 请查阅相关的java Doc文档了解它们是否有继承关系) A.Object o= new String(“a bed") ; B.Boolean b=true; C.Panel p= new Frame (): D....
  • Applet编程是java编程语言中至关重要的独特功能。它不同于一般的Java程序,其能够嵌入到HTML网页中,并由支持Java的Web浏览器解释执行。只有IE浏览器3 .0以上的版本,才支持Java Applet程序。通过这种小应用程序。所...
  • applet和应用程序

    2008-08-05 20:01:00
    applet和应用程序 在本章中,我们将介绍开发图形的applet程序和Java应用程序的基础。这当中包含一些简单的程序代码,它们显示处理Applet或应用程序关键问题的方法,并将讨论applet和java.awt软件包之间的关系。首先...
  • java组件和容器

    千次阅读 2013-10-02 08:44:45
    Java的图形用户界面的最基本组成部分是组件(Component),组件... 类java.awt.Component是许多组件类的父类,Component类中封装了组件通用的方法属性,如图形的组件对象、大小、显示位置、前景色背景色、边界、可
  • 导读: 10.2.1 容器 AWT容器分为两类:外部容器和内部容器。其中,外部容器一般会... 图10-2 AWT容器的层次结构 其中两个最常用的容器是Frame和Panel。在后面我们还要单独介绍Applet(一种特殊的Panel)。 框架(Fra
  • Applet程序设计

    2015-10-08 14:10:05
    Applet程序设计 【原文地址】 http://blog.csdn.net/flyuniverse_shell/article/details/4731103 本章目录 6.1 Applet基本概念 6.2 编写Applet程序 6.3 Applet多媒体设计 6.4 Applet的交互功能与通信功能 6.1 ...
  • //一个对话框类的Applet程序dialog.java import javax.swing.*; import java.awt.*; import java.awt.event.*; class PanelTest extends JApplet//面板 { JPanel panelObj; public PanelTest() { ...
  • Applet基础知识

    2015-05-17 19:03:35
    第9章 Applet 本章学习目标: ● 熟悉Applet技术 ● 掌握Applet的开发步骤 ● 理解Applet小程序的生命周期 ● 掌握Graphics类的用法 9.1 Applet 概 述  前面已经提到过,Java语言不仅可以用来编制独立运行的...
  • 一、明确概念 1.Applet是java的一个类,在java.applet包下; java.appletApplet java.lang.Object java.awt.Component java.awt.Container java.awt.Panel java.applet.AppletApplet
  • java Applet

    2011-03-20 21:39:00
    就是浏览器中的一个插件,插件的运行完全是由容器来控制调度的,容器是真正的应用程序,插件只是提供了一些约定的函数或者方法供容器去调用。   因为 Applet 的运行是从服务器主机上动态下载到浏览器所在的...
  • 最近在看java图形界面设计的内容,关于组件、容器之类的概念,觉得这篇文章写得不错。 参考博客原址: https://blog.csdn.net/qq_38858247/article/details/82950931 第一次转载,转载方法参考博客地址:...
  • GUI全称Graphical User Interfaces,意为图形用户户界面,又称为...这个QQ图标就可以被称作图形化的用户界面。 实现GUI编程的必不可少的三个条件是组件,事件事件监听。 组件 组件就是一些基本的图形元素,...
  • Applet加载Java应用程序

    2019-09-21 07:41:57
    如何编写小应用程序(Applet)并把其嵌入到网页中去的问题在很多关于Java的书中均有讨论。在这里我们不再重复此类问题,而是讨论如何将一个小应用程序用做构件,并能让自己编写的应用程序正常地加载并运行Java小应用...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,786
精华内容 714
关键字:

容器panel和applet