精华内容
下载资源
问答
  • Appengine-awt 自动从code.google.com/p/appengine-awt导出 appengine-awt是在Google AppEngine环境中使用的java.awt和javax.imageio包的纯Java实现。 该代码主要基于Apache Harmony和Apache Sanselan项目。 当前...
  • 改进 java.awt.Polygon contains() 方法的多边形类。 java.awt.Polygon 中的 contains() 方法可能不会为您期望的所有点返回 true。 示例:xArray = {0, 5, 10, 15, 15, 0},yArray = {0, 5, 3, 10, 0, 0}。 对于...
  • MMBT2907AWT1的技术参数

    2020-12-11 00:37:16
    产品型号:MMBT2907AWT1类型:PNP集电极-发射集最小雪崩电压Vceo(V):60集电极最大电流Ic(max)(mA):600直流电流增益hFE最小值(dB):100直流电流增益hFE最大值(dB):-最小电流增益带宽乘积Ft(MHz):200封装/温度(℃):3SOT...
  • ae-awt.jar.zip

    2020-01-17 15:34:57
    ae-awt.jar.zipae-awt.jar.zipae-awt.jar.zip
  • OpenGL和Vulkan对带有LWJGL 3的AWT的支持。 它对我有什么帮助? 支持OpenGL: 创建OpenGL 3.0和3.2核心/兼容性上下文(包括调试/转发兼容) OpenGL ES上下文 浮点和sRGB像素格式 多重采样的帧缓冲区(也具有不同...
  • Java-AWT

    2019-08-02 11:23:40
    NULL 博文链接:https://z18022893621.iteye.com/blog/1961118
  • MMBT2222AWT1G的技术参数

    2020-12-11 00:26:32
    产品型号:MMBT2222AWT1G类型:NPN集电极-发射集最小雪崩电压Vceo(V):40集电极最大电流Ic(max)(mA):600直流电流增益hFE最小值(dB):100直流电流增益hFE最大值(dB):300最小电流增益带宽乘积Ft(MHz):300封装/温度(℃):3...
  • AWT-源码

    2021-02-09 21:22:44
    AWT
  • #awt on android android 上的awt 与javainstaller( )一起运行java gui 程序很有用。 awtonandroid 是一个特定于平台的工具包,具有在 android 上运行 java awt 程序的特定于平台的方法。 网站上的更多信息和屏幕...
  • java GUI awt 实现鼠标绘制矩形,鼠标拖动矩形,鼠标改变矩形大小功能. 其它图形的绘制方法参考: https://blog.csdn.net/xietansheng/article/details/55669157
  • 主要为大家详细介绍了基于java语言下图形界面AWT编写计算器,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 本文展示了如何使用JDK1.3的JAWT接口在Java AWT Canvas中使用OpenGL调用
  • 100多个实例源码,学习awt、swing。AWT和Swing都是java中的包。 AWT(Abstract Window Toolkit):抽象窗口工具包,早期编写图形界面应用程序的包。 Swing :为解决 AWT 存在的问题而新开发的图形界面包。Swing是对...
  • awt-1.6.0-v201011041432.jar

    2020-05-19 17:21:25
    awt-1.6.0-v201011041432.jar
  • Java对GUI提供了丰富类库,分别位于java.awt和javax.swing包中,其中AWT不可跨平台,而Swing可以跨平台。 AWT概述: AWT是用于创建图形用户界面的一个工具包,它提供了一系列用于实现图形界面的组件,如窗口、按钮、...
  • Awt and Swing

    2018-07-02 15:24:32
    对于初学java编程 做ui的人员来说有一定的帮助,比较基础!
  • Java AWT组件综合练习

    2016-05-30 09:52:03
    Java AWT组件综合练习,list choice button textArea 等
  • awt中文乱码解决方法

    2015-08-18 10:19:25
    解决java软件中Myeclipse 中的awt乱码问题
  • java awt小练习

    2017-11-01 10:07:38
    java的awt小练习,包括关机 取消关机 启动bat程序 关闭某个进程 启动电脑某exe文件
  • BorderLayout——边界布局管理器:FlowLayout——流式布局管理器:GridLayout——网格布局:CardLayout——卡片式布局:...
  • java包awt Java抽象窗口工具包(AWT) (Java Abstract Window Toolkit(AWT)) Java AWT is an API that contains large number of classes and methods to create and manage graphical user interface ( GUI ) ...

    java包awt

    Java AWT is an API that contains large number of classes and methods to create and manage graphical user interface ( GUI ) applications. The AWT was designed to provide a common set of tools for GUI design that could work on a variety of platforms. The tools provided by the AWT are implemented using each platform's native GUI toolkit, hence preserving the look and feel of each platform. This is an advantage of using AWT. But the disadvantage of such an approach is that GUI designed on one platform may look different when displayed on another platform that means AWT component are platform dependent.

    Java AWT是一种API,其中包含大量用于创建和管理图形用户界面(GUI)应用程序的类和方法。 AWT旨在为GUI设计提供一套通用的工具,这些工具可以在多种平台上工作。 AWT提供的工具是使用每个平台的本机GUI工具包实现的,因此保留了每个平台的外观。 这是使用AWT的优势。 但是这种方法的缺点是,在一个平台上设计的GUI在另一个平台上显示时可能看起来有所不同,这意味着AWT组件依赖于平台。

    AWT is the foundation upon which Swing is made i.e Swing is a improved GUI API that extends the AWT. But now a days AWT is merely used because most GUI Java programs are implemented using Swing because of its rich implementation of GUI controls and light-weighted nature.

    AWT是制作Swing的基础,即Swing是改进的GUI API,它扩展了AWT。 但是现在仅使用AWT是因为大多数GUI Java程序都是使用Swing实现的,因为它具有丰富的GUI控件实现和轻量级的特性。

    Java AWT层次结构 (Java AWT Hierarchy)

    The hierarchy of Java AWT classes are given below, all the classes are available in java.awt package.

    Java AWT类的层次结构如下所示,所有类均在java.awt包中提供。

    heirarchy of component class

    组件类 (Component class)

    Component class is at the top of AWT hierarchy. It is an abstract class that encapsulates all the attributes of visual component. A component object is responsible for remembering the current foreground and background colors and the currently selected text font.

    组件类位于AWT层次结构的顶部。 它是一个抽象类,封装了可​​视组件的所有属性。 组件对象负责记住当前的前景色和背景色以及当前选择的文本字体。

    容器 (Container)

    Container is a component in AWT that contains another component like button, text field, tables etc. Container is a subclass of component class. Container class keeps track of components that are added to another component.

    容器是AWT中的一个组件,包含另一个组件,例如按钮,文本字段,表格等。 容器是组件类的子类。 容器类跟踪添加到另一个组件的组件。

    面板 (Panel)

    Panel class is a concrete subclass of Container. Panel does not contain title bar, menu bar or border. It is container that is used for holding components.

    面板类是Container的一个具体子类。 面板不包含标题栏,菜单栏或边框。 它是用于容纳组件的容器。

    窗类 (Window class)

    Window class creates a top level window. Window does not have borders and menubar.

    Window类创建一个顶层窗口。 窗口没有边框和菜单栏。

    (Frame)

    Frame is a subclass of Window and have resizing canvas. It is a container that contain several different components like button, title bar, textfield, label etc. In Java, most of the AWT applications are created using Frame window. Frame class has two different constructors,

    框架是Window的子类,具有调整画布大小。 它是一个包含几个不同组件的容器,如按钮,标题栏,文本字段,标签等。在Java中,大多数AWT应用程序都是使用“ 框架”窗口创建的。 框架类有两个不同的构造函数,

    Frame() throws HeadlessException
    Frame(String title) throws HeadlessException

    创建框架 (Creating a Frame)

    There are two ways to create a Frame. They are,

    有两种创建框架的方法。 他们是,

    1. By Instantiating Frame class

      通过实例化框架类

    2. By extending Frame class

      通过扩展框架类

    通过实例化Frame类创建Frame窗口 (Creating Frame Window by Instantiating Frame class)

    import java.awt.*;
    public class Testawt
    {
      Testawt()
      {
        Frame fm=new Frame();    //Creating a frame
        Label lb = new Label("welcome to java graphics");   //Creating a label
        fm.add(lb);                  //adding label to the frame
        fm.setSize(300, 300);   //setting frame size.
        fm.setVisible(true);     //set frame visibilty true
      }
      public static void main(String args[])
      {
        Testawt ta = new Testawt();
      }
    }
    creating Frame Window

    通过扩展Frame类创建Frame窗口 (Creating Frame window by extending Frame class)

    package testawt;
    
    import java.awt.*;
    import java.awt.event.*;
    
    public class Testawt extends Frame
    {
        public Testawt()
        {
            Button btn=new Button("Hello World");
            add(btn); 		//adding a new Button.
            setSize(400, 500);        //setting size.
            setTitle("StudyTonight");  //setting title.
            setLayout(new FlowLayout());	 //set default layout for frame.
            setVisible(true);           //set frame visibilty true.
        }
    
        public static void main (String[] args)
        {
            Testawt ta = new Testawt();   //creating a frame.
        }
    }
    awt example

    要记住的要点: (Points to Remember:)

    1. While creating a frame (either by instantiating or extending Frame class), Following two attributes are must for visibility of the frame:

      在创建框架时(通过实例化或扩展Frame类),必须具有以下两个属性才能使框架可见:

      • setSize(int width, int height);setSize(int width,int height);
      • setVisible(true);setVisible(true);
    2. When you create other components like Buttons, TextFields, etc. Then you need to add it to the frame by using the method - add(Component's Object);

      当创建其他组件(如Buttons,TextFields等)时,则需要使用方法-add(Component's Object);将其添加到框架中

    3. You can add the following method also for resizing the frame - setResizable(true);

      您还可以添加以下方法来调整框架的大小-setResizable(true);

    AWT按钮 (AWT Button)

    In Java, AWT contains a Button Class. It is used for creating a labelled button which can perform an action.

    在Java中,AWT包含一个Button类。 它用于创建可以执行操作的带标签的按钮。

    AWT按钮类声明: (AWT Button Classs Declaration:)

    public class Button extends Component implements Accessible

    公共类Button扩展组件实现Accessible

    例: (Example: )

    Lets take an example to create a button and it to the frame by providing coordinates.

    让我们以创建一个按钮并将其添加到框架为例。

    import java.awt.*;  
    public class ButtonDemo1
    {  
    public static void main(String[] args) 
    {  
        Frame f1=new Frame("studytonight ==> Button Demo");  
        Button b1=new Button("Press Here");  
        b1.setBounds(80,200,80,50);  
        f1.add(b1);  
        f1.setSize(500,500);  
        f1.setLayout(null);  
        f1.setVisible(true);   
    }  
    }
    awt-button awt-button

    AWT标签 (AWT Label)

    In Java, AWT contains a Label Class. It is used for placing text in a container. Only Single line text is allowed and the text can not be changed directly.

    在Java中,AWT包含标签类。 用于将文本放置在容器中。 仅允许使用单行文本,并且不能直接更改文本。

    标签声明: (Label Declaration:)

    public class Label extends Component implements Accessible

    公共类Label扩展组件实现Accessible

    例: (Example:)

    In this example, we are creating two labels to display text to the frame.

    在此示例中,我们将创建两个标签以在框架上显示文本。

    import java.awt.*;  
    class LabelDemo1
    {  
      public static void main(String args[])
      {     
        Frame l_Frame= new Frame("studytonight ==> Label Demo");  
        Label lab1,lab2;  
        lab1=new Label("Welcome to studytonight.com");  
        lab1.setBounds(50,50,200,30);  
        lab2=new Label("This Tutorial is of Java");  
        lab2.setBounds(50,100,200,30);  
    l_Frame.add(lab1); 
    l_Frame.add(lab2);  
    l_Frame.setSize(500,500);  
    l_Frame.setLayout(null);  
    l_Frame.setVisible(true);  
    }  
    }
    awt-label awt-label

    AWT TextField (AWT TextField)

    In Java, AWT contains aTextField Class. It is used for displaying single line text.

    在Java中,AWT包含一个TextField类。 用于显示单行文本。

    TextField声明: (TextField Declaration:)

    public class TextField extends TextComponent

    公共类TextField扩展了TextComponent

    例: (Example:)

    We are creating two textfields to display single line text string. This text is editable in nature, see the below example.

    我们正在创建两个文本字段以显示单行文本字符串。 该文本本质上是可编辑的,请参见以下示例。

    import java.awt.*;  
    class TextFieldDemo1{  
    public static void main(String args[]){  
        Frame TextF_f= new Frame("studytonight ==>TextField");  
    TextField text1,text2;  
        text1=new TextField("Welcome to studytonight");  
        text1.setBounds(60,100, 230,40);  
        text2=new TextField("This tutorial is of Java");  
        text2.setBounds(60,150, 230,40);  
    TextF_f.add(text1); 
    TextF_f.add(text2);  
    TextF_f.setSize(500,500);  
    TextF_f.setLayout(null);  
    TextF_f.setVisible(true);  
    }  
    }
    awt-textbox awt-textbox

    AWT TextArea (AWT TextArea)

    In Java, AWT contains aTextArea Class. It is used for displaying multiple-line text.

    在Java中,AWT包含一个TextArea类。 用于显示多行文本。

    TextArea声明: (TextArea Declaration:)

    public class TextArea extends TextComponent

    公共类TextArea扩展TextComponent

    例: (Example:)

    In this example, we are creating a TextArea that is used to display multiple-line text string and allows text editing as well.

    在此示例中,我们将创建一个TextArea,用于显示多行文本字符串并允许文本编辑。

    import java.awt.*;  
    public class TextAreaDemo1 
    {  
      TextAreaDemo1()
      {  
        Frame textArea_f= new Frame();  
        TextArea area=new TextArea("Welcome to studytonight.com");  
        area.setBounds(30,40, 200,200);  
        textArea_f.add(area);  
        textArea_f.setSize(300,300);  
        textArea_f.setLayout(null);  
        textArea_f.setVisible(true);  
      }  
      public static void main(String args[])  
      {  
        new TextAreaDemo1();  
      }  
    }
    awt-textarea awt-textarea

    AWT复选框 (AWT Checkbox)

    In Java, AWT contains a Checkbox Class. It is used when we want to select only one option i.e true or false. When the checkbox is checked then its state is "on" (true) else it is "off"(false).

    在Java中,AWT包含一个Checkbox类。 当我们只想选择一个选项(即true或false)时使用它。 选中此复选框时,其状态为“开”(true),否则为“关”(false)。

    复选框语法 (Checkbox Syntax)

    public class Checkbox extends Component implements ItemSelectable, Accessible

    公共类Checkbox扩展组件实现ItemSelectable,Accessible

    例: (Example:)

    In this example, we are creating checkbox that are used to get user input. If checkbox is checked it returns true else returns false.

    在此示例中,我们正在创建用于获取用户输入的复选框。 如果选中此复选框,则返回true,否则返回false。

    import java.awt.*;  
    public class CheckboxDemo1  
    {  
      CheckboxDemo1(){
        Frame checkB_f= new Frame("studytonight ==>Checkbox Example");  
        Checkbox ckbox1 = new Checkbox("Yes", true);  
        ckbox1.setBounds(100,100, 60,60);  
        Checkbox ckbox2 = new Checkbox("No");  
        ckbox2.setBounds(100,150, 60,60);  
        checkB_f.add(ckbox1);  
        checkB_f.add(ckbox2);  
        checkB_f.setSize(400,400);  
        checkB_f.setLayout(null);  
        checkB_f.setVisible(true);  
      }  
      public static void main(String args[])  
      {  
        new CheckboxDemo1();  
      }  
    }
    awt-checkbox awt-checkbox

    AWT CheckboxGroup (AWT CheckboxGroup)

    In Java, AWT contains aCheckboxGroup Class. It is used to group a set of Checkbox. When Checkboxes are grouped then only one box can be checked at a time.

    在Java中,AWT包含一个CheckboxGroup类。 它用于对一组复选框进行分组。 将复选框分组后,一次只能选中一个复选框。

    CheckboxGroup声明: (CheckboxGroup Declaration:)

    public class CheckboxGroup extends Object implements Serializable

    公共类CheckboxGroup扩展对象实现Serializable

    例: (Example:)

    This example creates a checkboxgroup that is used to group multiple checkbox in a single unit. It is helpful when we have to select single choice among the multiples.

    本示例创建一个复选框组,该复选框组用于将单个单元中的多个复选框分组。 当我们必须在多个选择中选择一个时,这将很有帮助。

    import java.awt.*;    
    public class CheckboxGroupDemo
    {    
      CheckboxGroupDemo(){    
        Frame ck_groupf= new Frame("studytonight ==>CheckboxGroup");    
        CheckboxGroupobj = new CheckboxGroup();  
        Checkbox ckBox1 = new Checkbox("Yes", obj, true);    
        ckBox1.setBounds(100,100, 50,50);    
        Checkbox ckBox2 = new Checkbox("No", obj, false);    
        ckBox2.setBounds(100,150, 50,50);    
        ck_groupf.add(ckBox1);    
        ck_groupf.add(ckBox2);    
        ck_groupf.setSize(400,400);    
        ck_groupf.setLayout(null);    
        ck_groupf.setVisible(true);    
      }    
      public static void main(String args[])    
      {    
        new CheckboxGroupDemo();    
      }    
    }
    awt-checkbox-group awt-checkbox-group

    AWT选择 (AWT Choice)

    In Java, AWT contains a Choice Class. It is used for creating a drop-down menu of choices. When a user selects a particular item from the drop-down then it is shown on the top of the menu.

    在Java中,AWT包含一个Choice类。 它用于创建选项的下拉菜单。 当用户从下拉菜单中选择特定项目时,该项目将显示在菜单顶部。

    选择声明: (Choice Declaration:)

    public class Choice extends Component implements ItemSelectable, Accessible

    公共类Choice扩展组件实现ItemSelectable,Accessible

    例: (Example:)

    In this example, we are creating drop-down menu that is used to get user choice from multiple choices.

    在此示例中,我们将创建一个下拉菜单,用于从多个选项中获取用户的选择。

    import java.awt.*;  
    public class ChoiceDemo
    {  
      ChoiceDemo()
      {  
        Frame choice_f= new Frame();  
        Choice obj=new Choice();  
        obj.setBounds(80,80, 100,100);  
        obj.add("Red");  
        obj.add("Blue");  
        obj.add("Black");  
        obj.add("Pink");  
        obj.add("White");  
        obj.add("Green");
        choice_f.add(obj);  
        choice_f.setSize(400,400);  
        choice_f.setLayout(null);  
        choice_f.setVisible(true);  
      }  
      public static void main(String args[])  
      {  
        new ChoiceDemo();  
      }  
    }
    awt-choice awt-choice

    AWT清单 (AWT List)

    In Java, AWT contains a List Class. It is used to represent a list of items together. One or more than one item can be selected from the list.

    在Java中,AWT包含一个列表类。 它用于一起表示项目列表。 可以从列表中选择一项或多项。

    清单声明: (List Declaration:)

    public class List extends Component implements ItemSelectable, Accessible

    公共类List扩展组件实现ItemSelectable,Accessible

    例: (Example:)

    In this example, we are creating a list that is used to list out the items.

    在此示例中,我们将创建一个用于列出项目的列表。

    import java.awt.*;  
    public class ListDemo
    {  
      ListDemo()
      {  
        Frame list_f= new Frame();  
        List obj=new List(6);  
        obj.setBounds(80,80, 100,100);  
        obj.add("Red");  
        obj.add("Blue");  
        obj.add("Black");  
        obj.add("Pink");  
        obj.add("White");  
        obj.add("Green");
        list_f.add(obj);  
        list_f.setSize(400,400);  
        list_f.setLayout(null);  
        list_f.setVisible(true);  
      }  
      public static void main(String args[])  
      {  
        new ListDemo();  
      }  
    }
    awt-list awt-list

    AWT帆布 (AWT Canvas)

    In Java, AWT contains a Canvas Class. A blank rectangular area is provided. It is used when a user wants to draw on the screen.

    在Java中,AWT包含一个Canvas类。 提供了一个空白的矩形区域。 当用户想要在屏幕上绘制时使用。

    宣言: (Declaration:)

    public class Canvas extends Component implements Accessible

    公共类Canvas扩展组件实现Accessible

    例: (Example:)

    The canvas is used to provide a place to draw using mouse pointer. We can used it to get user architectural user input.

    画布用于提供使用鼠标指针绘制的位置。 我们可以使用它来获取用户架构用户输入。

    import java.awt.*;  
    public class CanvasDemo1  
    {  
      public CanvasDemo1()  
      {  
        Frame canvas_f= new Frame("studytonight ==> Canvas");  
        canvas_f.add(new CanvasDemo());  
        canvas_f.setLayout(null);  
        canvas_f.setSize(500, 500);  
        canvas_f.setVisible(true);  
      }  
      public static void main(String args[])  
      {  
        new CanvasDemo1();  
      }  
    }  
    class CanvasDemo extends Canvas  
    {  
      public CanvasDemo() {  
        setBackground (Color.WHITE);  
        setSize(300, 200);  
      }  
      public void paint(Graphics g)  
      {  
        g.setColor(Color.green);  
        g.fillOval(80, 80, 150, 75);  
      }  
    }
    awt-canvas awt-canvas

    翻译自: https://www.studytonight.com/java/java-awt.php

    java包awt

    展开全文
  • 用java awt组件写的tcp文件传送和接收程序
  • java写UI时间很头疼的事儿,这里总结了网上的资料再汇总了一下,用滑动效果,有个登录界面,还有很多不一一列举了,祝好!
  • Java基础-GUI入门-AWT详解

    千次阅读 2020-08-18 23:20:49
    2.AWT 2.1、AWT介绍 其包含了很多的类和接口。 元素:窗口,按钮,文本框。 Java.awt: 2.2、组件和容器 1、Frame 代码: package com.edwin.lession01; import java.awt.*; //GUI第一个界面 /** * @...

    AWT

    2.1、AWT介绍

    • 其包含了很多的类和接口。

    • 元素:窗口,按钮,文本框。

    • Java.awt:

    在这里插入图片描述

    2.2、组件和容器

    1、Frame

    代码:

    package com.edwin.lession01;
    import java.awt.*;
    //GUI第一个界面
    /**
     * @author EdwinD
     * @create 2020.08.16 上午 10:03
     * @desc 
     **/
    public class TextFrame1 {
        public static void main(String[] args) {
    //        Frame,JDK,查看源码
            Frame frame = new Frame("My First Java 图形界面");
    
    //        设置窗口可见性,无关于窗口大小.
            frame.setVisible(true);
    
    //        设置窗口大小
            frame.setSize(777, 777);
    
    //        设置背景颜色
            frame.setBackground(new Color(77,77,77));
    
    //        设置初始位置
            frame.setLocation(777,77);
    
    //        控制窗口大小是否可改变,默认为True,即可以改变。
            frame.setResizable(false);
        }
    }
    

    输出效果:

    在这里插入图片描述

    缺点:

    此时的窗口无法关闭,只能通过IDEA停止代码,才可以关闭整个窗口。

    封装后多窗口输出:

    代码2.0:

    package com.edwin.lession01;
    import java.awt.*;
    public class TextFrame2 {
        public static void main(String[] args) {
    //        展示多个窗口new
            new MyFrame(77, 77, 350, 350, Color.blue);
            new MyFrame(77, 477, 350, 350, Color.red);
            new MyFrame(477, 77, 350, 350, Color.green);
            new MyFrame(477, 477, 350, 350, Color.gray);
    
        }
    
        static class MyFrame extends Frame{
            static int id = 0;//可能存在多个窗口,在此创造一个计数器.
    
            public MyFrame(int x, int y, int w, int h,Color color) {
                super("MyFrame+" + (++id));
                setVisible(true);
                setBounds(x, y, w, h);
                setBackground(color);
    
            }
        }
    }
    

    输出2.0:

    在这里插入图片描述

    2、Panel

    解决了关闭的小问题。

    **注:**Frame在add一个Panel的时候,使用的是frame.add(Component comp),这是因为Panel类extends了Container,而Container类extends了Component。

    在这里插入图片描述

    监听器小剧透

    • 添加监听事件,使用窗口上方的小叉叉进行关闭.调用System.exit(0).

    对于目前所编写的面板,窗口,都是无法直接通过点击上方的小叉进行关闭的,这里需要用到一些后面的监听器的内容进行功能的实现。

    1.常规情况下的监听器:

    frame.addWindowListener(new WindowListener() {
        @Override
        public void windowOpened(WindowEvent e) {
    
        }
    
        @Override
        public void windowClosing(WindowEvent e) {
    
        }
    
        @Override
        public void windowClosed(WindowEvent e) {
    
        }
    
        @Override
        public void windowIconified(WindowEvent e) {
    
        }
    
        @Override
        public void windowDeiconified(WindowEvent e) {
    
        }
    
        @Override
        public void windowActivated(WindowEvent e) {
    
        }
    
        @Override
        public void windowDeactivated(WindowEvent e) {
    
        }
    });
    

    但是这里使用到的监听器是全部的,太过于全面,我们只需要里面的部分监听器进行工作即可。因此,我们可以尝试调用其子类:

    在这里插入图片描述

    frame.addWindowListener(new WindowAdapter() {
        @Override
        public void windowClosing(WindowEvent e) {
    //      结束程序
            System.exit(0);
        }
    });
    
    • System.exit(0):正常关闭;System.exit(1):异常关闭.其关闭对象是Java程序。

    效果:
    在这里插入图片描述

    2.3、布局管理器

    • 流式布局

    代码:

    package com.edwin.lession01;
    import java.awt.*;
    /**
     * @author EdwinD
     * @create 2020.08.16 下午 09:29
     * @desc
     **/
    public class TextFlowLayout {
        public static void main(String[] args) {
            Frame frame = new Frame();
    
    //        尝试组件:按钮。
            Button button1 = new Button("Button1");
            Button button2 = new Button("Button2");
            Button button3 = new Button("Button3");
    
    //        设置为流式布局,默认为居中.
            frame.setLayout(new FlowLayout());
    //        frame.setLayout(new FlowLayout(FlowLayout.LEFT));
    //        frame.setLayout(new FlowLayout(FlowLayout.RIGHT));
    
            frame.setSize(277, 277);
    
            frame.add(button1);
            frame.add(button2);
            frame.add(button3);
    
            frame.setVisible(true);
        }
    }
    

    效果:

    在这里插入图片描述

    不论如何拖动,三个按钮都会是居中显示。

    • 东西南北中布局

    布局思想原理:

    在这里插入图片描述

    代码:

    package com.edwin.lession01;
    import java.awt.*;
    /**
     * @author EdwinD
     * @create 2020.08.16 下午 09:58
     * @desc
     **/
    public class TextBorderLayout {
        public static void main(String[] args) {
            Frame frame = new Frame("TextBorderLayout");
    
            Button east = new Button("East");
            Button west = new Button("West");
            Button north = new Button("North");
            Button south = new Button("South");
            Button center = new Button("Center");
    
            frame.add(center,BorderLayout.CENTER);
            frame.add(east,BorderLayout.EAST);
            frame.add(west,BorderLayout.WEST);
            frame.add(north,BorderLayout.NORTH);
            frame.add(south,BorderLayout.SOUTH);
    
            frame.setSize(277, 277);
            frame.setVisible(true);
        }
    }
    

    输出效果:

    在这里插入图片描述

    • 表格布局

    代码:

    package com.edwin.lession01;
    import java.awt.*;
    /**
     * @author EdwinD
     * @create 2020.08.16 下午 10:12
     * @desc
     **/
    public class TextGridLayout {
        public static void main(String[] args) {
            Frame frame = new Frame("TextGridLayout");
            Button but1 = new Button("but1");
            Button but2 = new Button("but2");
            Button but3 = new Button("but3");
            Button but4 = new Button("but4");
            Button but5 = new Button("but5");
            Button but6 = new Button("but6");
            Button but7 = new Button("but7");
    
            frame.setLayout(new GridLayout(3, 3));
            
            frame.add(but1);
            frame.add(but2);
            frame.add(but3);
            frame.add(but4);
            frame.add(but5);
            frame.add(but6);
            frame.add(but7);
    
            frame.setSize(277, 277);
            frame.setVisible(true);
        }
    }
    

    输出:

    在这里插入图片描述

    2.4、课堂练习

    package com.edwin.lession01;
    import java.awt.*;
    import java.awt.event.WindowAdapter;
    import java.awt.event.WindowEvent;
    /**
     * @author EdwinD
     * @create 2020.08.16 下午 10:21
     * @desc
     **/
    public class TextLayout {
        public static void main(String[] args) {
            Frame frame = new Frame("TextLayout");
    
            Panel panel1 = new Panel(new BorderLayout());
            Panel panel2 = new Panel(new GridLayout(2,1));
            Panel panel3 = new Panel(new BorderLayout());
            Panel panel4 = new Panel(new GridLayout(2,2));
    
            frame.setVisible(true);
            frame.setBackground(Color.blue);
            frame.setBounds(500, 500, 400, 300);
            frame.setResizable(false);
            frame.setLayout(new GridLayout(2,1));
    
            panel1.add(new Button("WEST-1"),BorderLayout.WEST);
            panel1.add(new Button("EAST-1"), BorderLayout.EAST);
            panel2.add(new Button("Cen1"));
            panel2.add(new Button("Cen2"));
            panel1.add(panel2,BorderLayout.CENTER);
    
            panel3.add(new Button("WEST-2"),BorderLayout.WEST);
            panel3.add(new Button("EAST-2"), BorderLayout.EAST);
    
            for (int i = 0; i < 4; i++) {
                panel4.add(new Button("for-" + i));
            }
            panel3.add(panel4, BorderLayout.CENTER);
    
            frame.add(panel1);
            frame.add(panel3);
    
            frame.addWindowListener(new WindowAdapter() {
                @Override
                public void windowClosing(WindowEvent e) {
                    System.exit(0);
                }
            });
        }
    }
    

    输出:

    在这里插入图片描述

    小结

    (1)Frame是一个顶级窗口。

    (2)Panel无法单独显示,必须添加到某一个容器中。

    (3)布局管理器:

    ​ - 流式布局

    ​ - 东西南北中布局

    ​ - 表格布局

    (4)每一个元素的大小,定位,背景色,可见性以及是否使用监听。

    2.5、事件监听

    所谓事件监听,就是指当某个事情发生的时候,应该做出何种反应。

    1.单一监听

    代码:

    package com.edwin.lession02;
    import java.awt.*;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    import java.awt.event.WindowAdapter;
    import java.awt.event.WindowEvent;
    /**
     * @author EdwinD
     * @create 2020.08.17 下午 01:30
     * @desc
     **/
    public class TextActionEvent<implement> {
        public static void main(String[] args) {
    //        初始化,目标:按下按钮,发生一些神奇的事情。
            Frame frame = new Frame("TextActionEvent");
            Button button = new Button();
    
    //        因为,addActionListener需要一个ActionListener,所以,我们自己要创建一个ActionListener
            MyActionListener myActionListener = new MyActionListener();
            button.addActionListener(myActionListener);
    
            frame.setVisible(true);
            frame.setBounds(577, 577, 377, 377);
            frame.add(button);
    
            //关闭窗口
            windowClose(frame);
        }
    
        //窗口关闭事件
        private static void windowClose(Frame frame){
            frame.addWindowListener(new WindowAdapter() {
                @Override
                public void windowClosing(WindowEvent e) {
                    System.exit(0);
                }
            });
        }
    }
    
    class MyActionListener implements ActionListener{
        @Override
        public void actionPerformed(ActionEvent e) {
            System.out.println("Push the Button.");
        }
    }
    

    输出:

    在这里插入图片描述

    2.多按钮同时监听

    代码:

    package com.edwin.lession02;
    import java.awt.*;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    import java.awt.event.WindowAdapter;
    import java.awt.event.WindowEvent;
    /**
     * @author EdwinD
     * @create 2020.08.17 下午 01:47
     * @desc
     **/
    public class TextActionTwo {
        public static void main(String[] args) {
    //        两个按钮,实现同一个监听.
    //        开始 & 停止
            Frame frame = new Frame("Start-Stop");
            Button button1 = new Button("Start");
            Button button2 = new Button("Stop");
    
            frame.pack();
            frame.setVisible(true);
            frame.setBounds(377, 377, 277, 277);
    
    //        可以显示的定义触发会返回的命令,如果不显示定义,则会走默认的值!
    //        可以多个按钮只写一个监听类
            button1.setActionCommand("Start-Button");
            button2.setActionCommand("Stop-Button");
    
            MyActionListener2 myActionListener2 = new MyActionListener2();
            button1.addActionListener(myActionListener2);
            button2.addActionListener(myActionListener2);
    
            frame.add(button1, BorderLayout.NORTH);
            frame.add(button2, BorderLayout.SOUTH);
    
            windowClose(frame);
        }
    
        private static void windowClose(Frame frame) {
            frame.addWindowListener(new WindowAdapter() {
                @Override
                public void windowClosing(WindowEvent e) {
                    System.exit(0);
                }
            });
        }
    }
    class MyActionListener2 implements ActionListener{
    //    e.getActionCommand()获得按钮信息.
        @Override
        public void actionPerformed(ActionEvent e) {
            System.out.println("按钮被点击了,消息内容为:"+e.getActionCommand());
        }
    }
    

    输出:

    在这里插入图片描述

    2.6、输入框 TextFile 及监听

    此功能用于类似于qq聊天的交流输入框,可以实现在肯本框中输入内容,在后台控制器中显示。

    代码:

    package com.edwin.lession02;
    import java.awt.*;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    import java.awt.event.WindowAdapter;
    import java.awt.event.WindowEvent;
    /**
     * @author EdwinD
     * @create 2020.08.17 下午 05:31
     * @desc
     **/
    public class TextTextFile {
        public static void main(String[] args) {
    //        启动
            MyFrame myFrame = new MyFrame();
            windowClose(myFrame);
        }
    
        private static void windowClose(Frame frame){
            frame.addWindowListener(new WindowAdapter() {
                @Override
                public void windowClosing(WindowEvent e) {
                    System.exit(0);
                }
            });
        }
    }
    
    class MyFrame extends Frame {
        public MyFrame() {
            TextField textField = new TextField();
            add(textField);
    
    //      监听此文本框的输入文字,
            MyActionListener3 myActionListener3 = new MyActionListener3();
    
    //        按下Enter就会触发这个输入框的事件
            textField.addActionListener(myActionListener3);
    
    //      设置替换编码,输入的内容被 setEchoChar('这里');的"这里"代替.
            textField.setEchoChar('!');
    
            setVisible(true);
            setBounds(377,377,277,277);
    
        }
    }
    
    class MyActionListener3 implements ActionListener {
        @Override
        public void actionPerformed(ActionEvent e) {
            TextField textFile = (TextField) e.getSource();
            System.out.println("输入框显示的为:\n"+textFile.getText());
    //        设置清空的反馈.每次回车后,会自动用""代替原来输入的内容,这里不可以用null,
    //        因为null是一个对象,而""中的空字符是一个字符串
            textFile.setText("");
        }
    }
    

    输出效果:

    在这里插入图片描述

    2.7、组合+内部类复习—>计算器

    践行OOP原则:组合大于继承。

    class A extends B{
        //正常继承,A有B的所有功能。
    }
    class A{
        public B b;
        //这就是组合的模式,可以减小耦合.
    }
    

    老式代码:

    package com.edwin.lession02;
    import java.awt.*;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    import java.awt.event.WindowAdapter;
    import java.awt.event.WindowEvent;
    /**
     * @author EdwinD
     * @create 2020.08.18 上午 07:28
     * @desc
     **/
    public class TextCalculator {
        public static void main(String[] args) {
            Calculator calculator = new Calculator();
            windowClose(calculator);
        }
    
        private static void windowClose(Frame frame){
            frame.addWindowListener(new WindowAdapter() {
                @Override
                public void windowClosing(WindowEvent e) {
                    System.exit(0);
                }
            });
        }
    }
    
    //计算器类
    class Calculator extends Frame {
        public Calculator() {
    //        三个文本框
            TextField num1 = new TextField(10);//字符数
            TextField num2 = new TextField(10);//字符数
            TextField num3 = new TextField(20);//字符数
    //        一个按钮
            Button button = new Button("=");
            button.addActionListener(new MyCalculatorListener(num1,num2,num3));
    //        一个标签
            Label label = new Label("+");
    //        布局
            setLayout(new FlowLayout());
            add(num1);
            add(label);
            add(num2);
            add(button);
            add(num3);
    
            setVisible(true);
            pack();
            setBounds(377,377,300,200);
        }
    }
    
    //监听器类
    class MyCalculatorListener implements ActionListener {
        private final TextField num1, num2, num3;
        //    获取三个变量
        public MyCalculatorListener(TextField num1, TextField num2, TextField num3) {
            this.num1 = num1;
            this.num2 = num2;
            this.num3 = num3;
        }
        @Override
        public void actionPerformed(ActionEvent e) {
    //        1.获得加数,被加数
            int n1 = Integer.parseInt(num1.getText());
            int n2 = Integer.parseInt(num2.getText());
    //        2.将两个值加法运算后,放到第三个框中,
            num3.setText(""+(n1+n2));
    //        3.清理前两个框中的数字
            num1.setText("");
            num2.setText("");
        }
    }
    

    输出:

    在这里插入图片描述

    新式·面向对象·代码:

    package com.edwin.lession02;
    import java.awt.*;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    import java.awt.event.WindowAdapter;
    import java.awt.event.WindowEvent;
    /**
     * @author EdwinD
     * @create 2020.08.18 上午 07:28
     * @desc
     **/
    public class TextCalculatorNew {
        public static void main(String[] args) {
            Calculator calculator = new Calculator();
    
            windowClose(calculator);
        }
    
        private static void windowClose(Frame frame){
            frame.addWindowListener(new WindowAdapter() {
                @Override
                public void windowClosing(WindowEvent e) {
                    System.exit(0);
                }
            });
        }
    }
    
    //计算器类
    class Calculator2 extends Frame {
        TextField num1, num2, num3;
        public Calculator2() {
    //        三个文本框
    //        一个按钮
    //        一个标签
            TextField num1 = new TextField(10);//字符数
            TextField num2 = new TextField(10);//字符数
            TextField num3 = new TextField(20);//字符数
            Label label = new Label("+");
            Button button = new Button("=");
    //        监听事件
            button.addActionListener(new MyCalculatorListener2(this));
    //        布局
            setLayout(new FlowLayout());
            add(num1);
            add(label);
            add(num2);
            add(button);
            add(num3);
    
            setVisible(true);
            pack();
            setBounds(377, 377, 300, 200);
        }
    }
    
    //监听器类
    class MyCalculatorListener2 implements ActionListener {
        Calculator2 calculator2 = null;
    
        public MyCalculatorListener2(Calculator2 calculator) {
            this.calculator2 = calculator;
        }
        @Override
        public void actionPerformed(ActionEvent e) {
    //        1.获得加数,被加数
            int n1 = Integer.parseInt(calculator2.num1.getText());
            int n2 = Integer.parseInt(calculator2.num2.getText());
    //        2.将两个值加法运算后,放到第三个框中,
            calculator2.num3.setText("" + (n1 + n2));
    //        3.清理前两个框中的数字
            calculator2.num1.setText("");
            calculator2.num2.setText("");
        }
    }
    

    输出:

    在这里插入图片描述

    2.8、画笔

    代码:

    package com.edwin.lession03;
    import java.awt.*;
    import java.awt.event.WindowAdapter;
    import java.awt.event.WindowEvent;
    /**
     * @author EdwinD
     * @create 2020.08.18 上午 11:14
     * @desc
     **/
    public class TextPaint {
        public static void main(String[] args) {
            MyPaint myPaint = new MyPaint();
            myPaint.loadFrame();
            windowClose(myPaint);
        }
    
        private static void windowClose(Frame frame) {
            frame.addWindowListener(new WindowAdapter() {
                @Override
                public void windowClosing(WindowEvent e) {
                    System.exit(0);
                }
            });
        }
    }
    
    class MyPaint extends Frame {
        @Override
        public void paint(Graphics g) {
    //        画笔,颜料,画啥.
            g.setColor(Color.blue);
    //        空心的圆
            g.drawOval(100, 100, 100, 100);
    //        实心的圆
            g.fillOval(100, 300, 100, 100);
    
            g.setColor(Color.GRAY);
            g.fillRect(300, 300, 100, 100);
    
    //        养成习惯:画笔用完之后,将其还原至最初的颜色.
        }
    
        public void loadFrame() {
            setBounds(277, 277, 677, 577);
            setVisible(true);
        }
    
    

    输出:

    在这里插入图片描述

    2.9、窗口监听

    Eg1,普通使用举例

    代码:

    package com.edwin.lession03;
    import java.awt.*;
    import java.awt.event.WindowAdapter;
    import java.awt.event.WindowEvent;
    /**
     * @author EdwinD
     * @create 2020.08.18 下午 05:02
     * @desc
     **/
    public class TextWindow {
        public static void main(String[] args) {
            new WindowFrame();
        }
    }
    
    class WindowFrame extends Frame {
        public WindowFrame(){
            setBackground(Color.black);
            setBounds(377, 377, 277, 277);
            setVisible(true);
    
    //        方法一对应的内部代码:
    //        addWindowListener(new MyWindowListener());
    
    //        方法二:推荐的方法。
    //        匿名内部类,可以取代方法一
            this.addWindowListener(new WindowAdapter() {
                @Override
                public void windowClosing(WindowEvent e) {
                    System.out.println("你点击了关闭的“X”");
                    setVisible(false);
                    System.exit(0);
                }
            });
        }
    }
    
    //    方法一:
    //    内部类,非静态。
    /*
        class MyWindowListener extends WindowAdapter {
            @Override
            public void windowClosing(WindowEvent e) {
    //            隐藏窗体,并不关闭。
                setVisible(false);
    //            正常退出,
                System.exit(0);
            }
        }
    }
    */
    

    输出:

    在这里插入图片描述

    Eg2:

    窗口激活,窗口关闭。

    代码:

    package com.edwin.lession03;
    import java.awt.*;
    import java.awt.event.WindowAdapter;
    import java.awt.event.WindowEvent;
    /**
     * @author EdwinD
     * @create 2020.08.18 下午 05:02
     * @desc
     **/
    public class TextWindow {
        public static void main(String[] args) {
            new WindowFrame();
        }
    }
    
    class WindowFrame extends Frame {
        public WindowFrame(){
            setBackground(Color.black);
            setBounds(377, 377, 277, 277);
            setVisible(true);
    
    //        方法二:推荐的方法。
    //        匿名内部类,可以取代方法一
            this.addWindowListener(new WindowAdapter() {
                @Override
                public void windowActivated(WindowEvent e) {
                    System.out.println("窗口激活了");
                    WindowFrame source = (WindowFrame) e.getSource();
                    source.setTitle("窗口激活了");
                }
    
                @Override
                public void windowClosing(WindowEvent e) {
                    System.out.println("你点击了关闭的“X”");
                    setVisible(false);
                    System.exit(0);
                }
            });
        }
    }
    

    输出:

    在这里插入图片描述

    2.10、鼠标监听

    目的:想要实现鼠标进行画画。

    思路:

    在这里插入图片描述

    代码:

    package com.edwin.lession03;
    import java.awt.*;
    import java.awt.event.MouseAdapter;
    import java.awt.event.MouseEvent;
    import java.awt.event.WindowAdapter;
    import java.awt.event.WindowEvent;
    import java.util.ArrayList;
    import java.util.Iterator;
    /**
     * @author EdwinD
     * @create 2020.08.18 上午 11:39
     * @desc 测试鼠标监听事件
     **/
    public class TextMouseListener {
        public static void main(String[] args) {
            MyFrame myFrame = new MyFrame("画图");
            windowClose(myFrame);
        }
        private static void windowClose(Frame frame) {
            frame.addWindowListener(new WindowAdapter() {
                @Override
                public void windowClosing(WindowEvent e) {
                    System.exit(0);
                }
            });
        }
    }
    
    class MyFrame extends Frame {
    //    思路:
    //    1.画画需要画笔.
    //    2.需要监听鼠标此刻的位置所在.
    //    3.需要有集合来存储这个点.
        ArrayList points;
    
        public MyFrame(String title) {
            super(title);
            setBounds(277, 277, 377, 377);
            setVisible(true);
    //        鼠标点击存放点
            points = new ArrayList<>();
    //        此窗口的鼠标监听器
            this.addMouseListener(new MouseListener());
        }
    
        @Override
        public void paint(Graphics g) {
    //        画画,鼠标的监听事件
            Iterator iterator = points.iterator();
            while (iterator.hasNext()) {
                Point point = (Point) iterator.next();
                g.setColor(Color.GREEN);
                g.fillOval(point.x, point.y, 7, 7);
            }
        }
    
        public void addPoint(Point point){
            points.add(point);
        }
    
        private class MouseListener extends MouseAdapter {
            @Override
            public void mousePressed(MouseEvent e) {
                MyFrame frame = (MyFrame) e.getSource();
    //            我们点击的时候,会在界面上产生一个点.
                frame.addPoint(new Point(e.getX(), e.getY()));
                frame.repaint();
            }
        }
    }
    

    输出:

    在这里插入图片描述

    2.11、键盘监听

    目的:将从键盘输入的内容识别出来。

    代码:

    package com.edwin.lession03;
    import java.awt.*;
    import java.awt.event.KeyAdapter;
    import java.awt.event.KeyEvent;
    import java.awt.event.WindowAdapter;
    import java.awt.event.WindowEvent;
    /**
     * @author EdwinD
     * @create 2020.08.18 下午 10:38
     * @desc Keyboard
     **/
    public class TextKeyListener {
        public static void main(String[] args) {
            new KeyFrame();
        }
    }
    
    class KeyFrame extends Frame {
        public KeyFrame() {
            setBounds(377, 377, 277, 277);
            setVisible(true);
    
            this.addKeyListener(new KeyAdapter() {
                //键盘按下时的监听
                @Override
                public void keyPressed(KeyEvent e) {
    //                获得键盘按下的键是哪一个,及当前按键的代号
                    int keyCode = e.getKeyCode();
                    System.out.println("You Have Pushed the Keyboard,the Num is"+keyCode);
                    if (keyCode == KeyEvent.VK_UP) {
                        System.out.println("向上键被按下了。");
                    }
                }
            });
    
            this.addWindowListener(new WindowAdapter() {
                @Override
                public void windowClosing(WindowEvent e) {
                    System.out.println("你点击了关闭X");
                    System.exit(0);
                }
            });
        }
    }
    

    输出效果:

    在这里插入图片描述
    路漫漫其修远兮,吾将上下而求索。

    参考文献

    《【狂神说Java】GUI编程入门到游戏实战》
    视频链接

    2020.08.18

    展开全文
  • NULL 博文链接:https://cleaneyes.iteye.com/blog/762921
  • java awt_Java AWT简介

    2020-08-03 02:04:55
    java awt Java AWT简介 (Introduction to Java AWT) Java AWT (Abstract Window Toolkit) package is a library used for designing graphical user interfaces. Java AWT(抽象窗口工具包)软件包是用于设计图形用户...

    java awt

    Java AWT简介 (Introduction to Java AWT)

    Java AWT (Abstract Window Toolkit) package is a library used for designing graphical user interfaces.

    Java AWT(抽象窗口工具包)软件包是用于设计图形用户界面的库。

    It contains classes for placing various user intractable components and graphics. However, the components of this class are platform dependent. They are heavy and rely on the OS for their functioning.

    它包含用于放置各种用户难以处理的组件和图形的类。 但是,此类的组件取决于平台。 它们很重,并且依靠OS来运行。

    The AWT package has classes using which we can create TextBoxes, CheckBoxes, RadioButton, List, etc.

    AWT包具有一些类,通过这些类可以创建TextBoxesCheckBoxesRadioButtonList等。

    层次结构 (Hierarchy)

    Java AWT Introduction

    Object: All classes in Java are inherited from the object class.

    对象: Java中的所有类均从对象类继承。

    Components: Elements like buttons, TextBox, RadioButton, etc. are called components in Java. We have separate classes for all components. To display elements on the screen, we need to place them in containers.

    组件:按钮,文本框,单选按钮等元素在Java中称为组件。 对于所有组件,我们都有单独的类。 要在屏幕上显示元素,我们需要将其放置在容器中。

    Container: It consists of classes that are used to hold other objects. All components are placed in containers, like Windows and Panels. Containers control the placement and layout of the components placed in them. A container in itself is a component.

    容器:由用于容纳其他对象的类组成。 所有组件都放置在容器中,例如Windows和Panels。 容器控制放置在其中的组件的放置和布局。 容器本身就是一个组件。

    Label: As the name suggests, it is used as a label, or a method to display text on the screen. The user cannot change the content of a label. It represents a read-only text.

    标签:顾名思义,它用作标签或在屏幕上显示文本的方法。 用户无法更改标签的内容。 它代表一个只读文本。

    Read: Java AWT Label

    阅读: Java AWT标签

    Button: A button is like a push button. It consists of a label (name of the button) and generates an event when clicked.

    按钮:按钮就像一个按钮。 它由一个标签(按钮的名称)组成,并在单击时生成一个事件。

    Read: Java AWT Button

    阅读: Java AWT按钮

    Checkbox: It is used to provide options. When clicked, it changes the state of the checkbox from 'on' to 'off' or vice-versa.

    复选框:用于提供选项。 单击时,它将复选框的状态从“打开”更改为“关闭”,反之亦然。

    Read: Java AWT Checkbox

    阅读: Java AWT复选框

    TextField: It is used to take single-line text input from the user. It can also be used to display editable text. Unlike a label, which provides read-only text, the text in the textfield can be edited by the user.

    TextField:用于接受用户的单行文本输入。 它也可以用来显示可编辑的文本。 与提供只读文本的标签不同,文本字段中的文本可由用户编辑。

    Read: Java AWT TextField

    阅读: Java AWT TextField

    TextArea: It allows the display of multiple lines of text. It provides 'an area' where text can be displayed and also edited by the user.

    TextArea:它允许显示多行文本。 它提供了一个“区域”,用户可以在其中显示和编辑文本。

    Read: Java AWT TextArea

    阅读: Java AWT TextArea

    一个简单的Java AWT程序 (A Simple Java AWT program)

    import java.awt.*;
    
    public class HelloWorld{
    
         public static void main(String []args){
            Frame f = new Frame();
            Button b1 = new Button("Click me!");
            Label l1 = new Label("Label");
            TextField t1 = new TextField("Text");
            b1.setBounds(50,50,100,50);
            l1.setBounds(50,100,100,50);
            t1.setBounds(50,150,100,50);
            
            f.setLayout(null);
            f.setSize(300,300);
            f.setVisible(true);
            
            f.add(b1);
            f.add(l1);
            f.add(t1);
            
         }
    }
    
    

    Output

    输出量

    Java AWT Introduction program

    In this example, we create a button with the title "Click me", a label with un-editable text "Label" and a TextField with editable text. The text of the Textfield has been changed by the user from "Text" to "Changed user".

    在此示例中,我们创建一个标题为“ Click me”的按钮,一个具有不可编辑文本“ Label”的标签和一个具有可编辑文本的TextField。 用户已将Textfield的文本从“ Text ”更改“ Changed user”

    All these components are placed on a frame (a container), using the add() function. The position and size of these elements are decided by the setBounds() function. The size of the frame is set by the setSize() function and the frame, including all components, is made visible by the setVisible() function.

    使用add()函数所有这些组件放置在框架(容器)上。 这些元素的位置和大小由setBounds()函数确定。 框架的大小由setSize()函数设置,并且框架(包括所有组件)通过setVisible()函数可见。

    翻译自: https://www.includehelp.com/java/awt-introduction.aspx

    java awt

    展开全文
  • Java AWT布局

    2020-06-04 13:05:37
    java.awt库提供5种基本布局。 每种布局都有其自身的意义,并且它们是完全不同的。 在本文的此处,我们将讨论如何将任何布局应用于框架或面板,并简要讨论每种布局。 java.awt库中可用的5种布局是: 边框布局 ...

    java.awt库提供5种基本布局。 每种布局都有其自身的意义,并且它们是完全不同的。 在本文的此处,我们将讨论如何将任何布局应用于框架或面板,并简要讨论每种布局。

    java.awt库中可用的5种布局是:

    1. 边框布局
    2. 网格布局
    3. GridBag布局
    4. 卡布局
    5. 流程布局

    1.边框布局

    BorderLayout是一种按照方向组织组件的布局。 边框布局将框架或面板分为5个部分-北,南,东,西和居中。 通过传递附加参数,可以将每个组件按特定方向排列。

    BorderLayoutExample.java
    package com.mkyong;
    
    import java.awt.BorderLayout;
    import java.awt.Button;
    import java.awt.Label;
    import javax.swing.JFrame;
    
    public class BorderLayoutExample extends JFrame {
    
        public static void main(String[] args) {
            BorderLayoutExample a = new BorderLayoutExample();
        }
    
        public BorderLayoutExample() {
    
            setVisible(true);
            setDefaultCloseOperation(EXIT_ON_CLOSE);
    
            BorderLayout b = new BorderLayout();
            setTitle("Border Layout");
    
            setSize(300, 300);
            add(new Button("North"), BorderLayout.NORTH);
            add(new Button("South"), BorderLayout.SOUTH);
            add(new Button("East"), BorderLayout.EAST);
            add(new Button("West"), BorderLayout.WEST);
            add(new Button("Center"), BorderLayout.CENTER);
    
        }
    }

    输出量

    awt-borderlayout

    2.网格布局

    GridLayout是排列组件的一种更有组织的方式。 它以包含均匀分布的单元格的网格形式划分框架或面板。 每个组件都添加到特定的单元格中。 组件的放置顺序直接取决于将它们添加到框架或面板的顺序。 下图显示了基于2列3行GridLayout的Frame。

    构造函数GridLayout(int row,int cols)确定网格大小。

    GridLayoutExample.java
    package com.mkyong;
    
    import java.awt.Button;
    import java.awt.GridLayout;
    import javax.swing.JFrame;
    
    public class GridLayoutExample extends JFrame {
    
        public static void main(String[] args) {
            GridLayoutExample a = new GridLayoutExample();
        }
    
        public GridLayoutExample() {
    
            setVisible(true);
            setDefaultCloseOperation(EXIT_ON_CLOSE);
    
            GridLayout g = new GridLayout(3, 2);
            setLayout(g);
            setTitle("Grid Layout");
            setSize(300, 300);
            add(new Button("Button 1"));
            add(new Button("Button 2"));
            add(new Button("Button 3"));
            add(new Button("Button 4"));
            add(new Button("Button 5"));
            add(new Button("Button 6"));
    
        }
    
    }

    输出量

    awt-gridlayout

    3. GridBag布局

    GridBagLayout是最灵活的布局,它提供了一种有组织但灵活的方式来排列组件。 它使开发人员可以灵活地选择组件的确切位置(在网格中),即行跨度和列跨度以及水平和垂直间距。 下图显示了GridBagLayout 。 它包含一次跨2行的Button 5。

    GridBagLayoutExample.java
    package com.mkyong;
    
    import java.awt.Button;
    import java.awt.CardLayout;
    import java.awt.FlowLayout;
    import java.awt.GridBagConstraints;
    import java.awt.GridBagLayout;
    import javax.swing.JFrame;
    
    public class GridBagLayoutExample extends JFrame {
    
        public static void main(String[] args) {
            GridBagLayoutExample a = new GridBagLayoutExample();
        }
    
        public GridBagLayoutExample() {
            setSize(300, 300);
            setPreferredSize(getSize());
            setVisible(true);
            setDefaultCloseOperation(EXIT_ON_CLOSE);
            GridBagLayout g = new GridBagLayout();
            GridBagConstraints gbc = new GridBagConstraints();
            setLayout(g);
            setTitle("GridBag Layout");
    
            GridBagLayout layout = new GridBagLayout();
    
            this.setLayout(layout);
    
            gbc.fill = GridBagConstraints.HORIZONTAL;
            gbc.gridx = 0;
            gbc.gridy = 0;
            this.add(new Button("Button 1"), gbc);
    
            gbc.gridx = 1;
            gbc.gridy = 0;
            this.add(new Button("Button 2"), gbc);
    
            gbc.fill = GridBagConstraints.HORIZONTAL;
            gbc.ipady = 20;
            gbc.gridx = 0;
            gbc.gridy = 1;
            this.add(new Button("Button 3"), gbc);
    
            gbc.gridx = 1;
            gbc.gridy = 1;
            this.add(new Button("Button 4"), gbc);
    
            gbc.gridx = 0;
            gbc.gridy = 2;
            gbc.fill = GridBagConstraints.HORIZONTAL;
            gbc.gridwidth = 2;
            this.add(new Button("Button 5"), gbc);
    
        }
    }

    输出量

    awt-gridbaglayout

    4.卡布局

    这是很少使用的布局,用于将组件彼此堆叠。 CardLayout允许组件保持彼此CardLayout ,并根据需要将任何组件切换到最前面。 用图片描述卡片的布局是没有意义的。 因此,让我们通过一个小例子来理解它。 考虑下面的代码:

    mychoice.addItemListener(new ItemListener() {
             public void itemStateChanged(ItemEvent e) {
                CardLayout cardLayout = (CardLayout)(e.getTarget().getParent().getLayout());
                cardLayout.show(panel, (String)e.getItem());
             }
          });

    上面的代码与带有组合框的事件侦听器相关联。 根据组合值的变化,将显示该组件。 为了创建卡片布局,您可以使用以下代码

    CardLayoutExample.java
    package com.mkyong;
    
    import java.awt.Button;
    import java.awt.CardLayout;
    import javax.swing.JFrame;
    
    public class CardLayoutExample extends JFrame {
    
        public static void main(String[] args) {
            CardLayoutExample a = new CardLayoutExample();
        }
    
        public CardLayoutExample() {
    
            setVisible(true);
            setDefaultCloseOperation(EXIT_ON_CLOSE);
    
            CardLayout g = new CardLayout();
            setLayout(g);
            setTitle("Card Layout");
    
            setSize(300, 300);
            add(new Button("Button 1"));
            add(new Button("Button 2"));
            add(new Button("Button 3"));
            add(new Button("Button 4"));
            add(new Button("Button 5"));
            add(new Button("Button 6"));
    
        }
    }

    输出量

    awt-cardlayout

    5.流程布局

    顾名思义, FlowLayout是一种布局,它允许组件流到可见部分的末端。 FlowLayout基本上有助于开发响应速度更快的UI,并使组件保持自由流动的方式。 下图显示了具有6个组件的实际流布局。

    由于这是框架或面板的默认布局,因此也可以在不显式应用布局的情况下工作。

    FlowLayoutExample.java
    package com.mkyong;
    
    import java.awt.Button;
    import java.awt.FlowLayout;
    import javax.swing.JFrame;
    
    public class FlowLayoutExample extends JFrame {
    
        public static void main(String[] args) {
            FlowLayoutExample a = new FlowLayoutExample();
        }
    
        public FlowLayoutExample() {
    
            setVisible(true);
            setDefaultCloseOperation(EXIT_ON_CLOSE);
    
            FlowLayout g = new FlowLayout();
            setLayout(g);
            setTitle("Flow Layout");
            setSize(300, 300);
            add(new Button("Button 1"));
            add(new Button("Button 2"));
            add(new Button("Button 3"));
            add(new Button("Button 4"));
            add(new Button("Button 5"));
            add(new Button("Button 6"));
    
        }
    }

    输出量

    awt-flowlayout

    结论

    本文讨论了可用的AWT布局。 讨论已经非常简短地进行了。 因此,参考文献中提供了一些链接,它们可能会帮助您了解更多信息。

    参考文献

    1. 布局细节
    2. 使用边框布局
    3. 使用卡布局
    4. 使用流程布局
    5. 使用GridBag布局
    6. 使用GridBag布局

    翻译自: https://mkyong.com/awt/java-awt-layouts/

    展开全文
  • AWT Framework

    2010-04-04 21:12:21
    AWT Framework is a lightweight framework for building AWT applications. Layout is configed by XML files. Events and View Switchs is managed by framework. Also you can plugin your customized AWT or ...
  • java(swing,awt)图形用户界面编程100多个案例,里面的例子好好学学
  • AWT与Swing使用区别

    2012-11-22 20:49:58
    对照了解AWT与Swing的区别,能更好地理解GUI

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 167,860
精华内容 67,144
关键字:

awt