java图形界面小程序,堆栈,队列,排序,画图等功能

合集下载

Java语言程序设计-Java图形界面

java.awt.Container类是 java.awt.Component的子类，一个容器
可以容纳多个组件，并使它们成为一个整体。所有的容器都可以通过add()方法向容器中添加组件。有3种类型的容器： Window、Panel、ScrollPane，常用的有 Panel、Frame等。
12.2 创建窗体
设置组件类的显示位置
通过Point设置组件显示位置显示或隐藏组件向容器中增加组件
public void setLayout(LayoutManager manager)
public Container getContentPane()
设置布局管理器，null不设置返回此窗体的容器对象
12.2.2 操作任务—— 观察示例，创建一个新窗体
Biblioteka Baidu
序号 1 2 3 4 5 6 7 8 9 10 11 12
表12-1 JFrame类的常用方法
方法
描述
public JFrame() throws HeadlessException 构造一个不可见的窗体对象
public JFrame(String title) throws HeadlessException public void setSize(int width, int height) public void setSize(Dimension d) public void setBackground(Color c) public void setLocation(int x, int y)

Java图形用户界面：Swing和JavaFX的简单介绍

Java图形用户界面：Swing和JavaFX的简单

介绍

在计算机科学领域中，图形用户界面（GUI）是指通过图形、图像和视觉元素

来与计算机程序进行交互的界面。Java作为一种广泛使用的编程语言，提供了多种选择来构建图形用户界面。其中，Swing和JavaFX是最常用的两种选择。本文将

对这两种Java GUI工具进行简单介绍，并探讨它们的特点和用途。

一、Swing

Swing是Java提供的一套GUI工具包，旨在提供一种跨平台的解决方案。它是在AWT（抽象窗口工具包）的基础上开发的，为开发者提供了一系列可重用的

GUI组件，如按钮、文本框、标签等。Swing的特点之一是其轻量级性能，它不依

赖于操作系统的原生GUI组件，而是完全由Java代码实现。这使得Swing应用程

序可以在不同操作系统上以相同的方式运行，而无需进行任何修改。

Swing提供了丰富的组件库，使得开发者可以轻松构建复杂的用户界面。它还

支持可定制的外观和感觉，开发者可以根据自己的需求选择不同的外观主题。此外，Swing还提供了一些高级组件，如表格、树形结构和滚动面板，使得开发者可以创

建更复杂和功能强大的界面。

然而，Swing也有一些缺点。由于其完全由Java代码实现的特性，Swing应用

程序可能在性能方面存在一些问题。尤其是在处理大量数据或复杂图形时，Swing

的性能可能会受到影响。此外，Swing的外观和感觉可能与操作系统的原生界面存

在一些差异，这可能会对用户体验造成一定的影响。

二、JavaFX

JavaFX是Java平台上的另一种GUI工具，它提供了更现代化和富有表现力的

Java的形化界面开发选择合适的框架与工具

Java的形化界面开发选择合适的框架与工具Java的图形界面开发选择合适的框架与工具

Java是一种跨平台的编程语言，广泛应用于软件开发领域。在图形

界面开发方面，Java提供了多个框架与工具，开发者可以根据自身需

求选择合适的组件和工具来进行开发。本文将介绍几个常用的Java图

形界面开发框架与工具，并分析它们的优势和适用范围。

一、Swing框架

Swing是Java平台提供的主要图形界面开发框架之一。它基于Java

的AWT（Abstract Window Toolkit）框架，提供了丰富的GUI组件和

强大的事件处理机制。Swing具有良好的跨平台性能和灵活的可定制性，适用于开发各种类型的桌面应用程序。

Swing框架提供了一系列面向对象的GUI组件，如按钮、标签、文

本框、表格等，开发者可以通过组合这些组件来构建复杂的用户界面。此外，Swing还支持图形渲染、国际化和可访问性等功能，使得应用程序更加美观、易用和易于维护。

二、JavaFX框架

JavaFX是Java平台的另一个重要图形界面开发框架。它是在Java SE 8及其之后版本中引入的，作为Swing的继任者。JavaFX框架提供

了现代化的UI组件和丰富的动画效果，支持CSS样式表和FXML布

局文件，极大地简化了界面设计和开发流程。

JavaFX具有良好的性能和优秀的渲染效果，在图形处理、媒体播放和界面布局等方面有着卓越的表现。它的线程模型也更加灵活，能够实现响应式的用户界面设计。

三、AWT框架

AWT是Java最早引入的图形界面开发框架。它是使用本地窗口系统提供的原生组件，因此在外观和行为上与操作系统保持一致。AWT 提供了一系列基本的GUI组件，如按钮、标签、文本框等，可以通过AWT的布局管理器来进行界面排版。

Java程序设计中的图形界面制作案例

Java程序设计中的图形界面制作案例图形界面（Graphical User Interface, GUI）在软件开发中扮演着至关重要的角色。在Java程序设计中，使用GUI可以使程序更加直观、易用，并提供更好的用户交互体验。本文将介绍几个Java程序设计中的图形界面制作案例，帮助读者更好地理解和掌握GUI的设计与开发。

一、登录界面案例

登录界面是大多数应用程序的入口点，良好的登录界面设计能够提高用户的使用体验。在Java中，可以使用Swing库来构建登录界面。

首先，需要导入Swing库，然后创建一个JFrame对象，并设置其标题、大小和关闭操作。接着，创建一个JPanel对象，并添加各种Swing组件，如JLabel、JTextField、JPasswordField和JButton等。通过设置布局管理器，可以对这些组件进行适当的排列。

在登录按钮的事件处理中，可以添加登录验证的逻辑，比如判断用户名和密码是否匹配。如果验证成功，可以跳转到主界面；否则，弹出错误提示。

二、计算器案例

计算器是常见的GUI应用程序之一，它能够实现简单的数学计算。

在Java中，可以使用AWT（Abstract Window Toolkit）或Swing来创建计算器界面。这里以Swing为例。

首先，创建一个JFrame对象，并设置其标题、大小和关闭操作。

然后，创建一个JPanel对象，并设置其布局管理器为网格布局。在这

个JPanel对象中，可以添加各种按钮，比如数字按钮和运算符按钮。

为每个按钮注册事件监听器，以便捕获用户的点击事件。

java堆栈的用法

Java中的堆栈是一种非常重要的数据结构，它可以帮助我们管理程序中的动态数据。在Java中，堆栈通常用于实现函数调用、异常处理、内存分配等功能。本文将介绍Java堆栈的用法，帮助您更好地理解和应用它。

一、堆栈的基本概念

堆栈是一种后进先出（LIFO）的数据结构，它由一系列元素组成，每个元素都有一个与之关联的键和一个与之关联的值。堆栈中的元素按照键的顺序进行排序，最底部的元素具有最小的键值。堆栈有两个主要操作：push和pop。push操作将一个元素添加到堆栈的顶部，而pop操作则从堆栈的顶部移除一个元素。

在Java中，堆栈通常由Stack类实现。Java中的Stack类是一个单向链表，它实现了面向对象编程中的堆栈数据结构。

1.创建堆栈对象

在Java中，可以使用new关键字创建Stack对象，如下所示：```java

Stack<Integer>stack=newStack<Integer>();

```

这里，我们使用泛型<Integer>定义了一个整型堆栈。通过创建Stack对象，我们可以使用它来实现LIFO堆栈功能。

2.入堆栈操作（push）

入堆栈操作将元素添加到堆栈的顶部。在Java中，可以使用push()方法来实现这个操作。例如：

```java

stack.push(1);//将元素1添加到堆栈顶部

```

注意：入堆栈操作只能在非空堆栈上进行。如果堆栈为空，将抛出异常。

3.出堆栈操作（pop）

出堆栈操作从堆栈顶部移除一个元素。在Java中，可以使用

Java图形用户界面(GUI)编程Swing和AWT库的使用

Java图形用户界面（GUI）编程Swing和

AWT库的使用

在编程领域，图形用户界面（Graphical User Interface，简称GUI）是一种通过图形、图像和图标等可视化元素与用户进行交互的界面形式。Java作为一种跨平台的编程语言，提供了多种库和框架来实现GUI编程的需求。其中，Swing和AWT是两个常用的Java GUI库，它们提供了丰富的组件和功能来创建用户友好的界面。本文将重点介绍Java Swing和AWT库的使用，帮助读者了解和掌握这两个库的基本用法。

一、Swing库的使用

Swing库是Java提供的一个基于AWT库的GUI工具包，它提供了丰富的组件和功能来创建交互式的图形界面。下面将介绍几个常用的Swing组件及其使用方法。

1. JFrame窗口

JFrame是Swing中最基本的容器，它代表了一个窗口。我们可以使用JFrame类创建一个窗口，并在其中添加其他的组件。以下是一个示例代码：

```java

import javax.swing.*;

public class MyFrame extends JFrame {

public MyFrame() {

setTitle("My Frame");

setSize(300, 200);

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); setVisible(true);

}

public static void main(String[] args) {

SwingUtilities.invokeLater(new Runnable() {

使用Java Swing进行桌面应用程序开发

Java Swing是Java编程语言的一个GUI工具包，可以用于开发漂亮的桌面应用程序。它提供了丰富的组件和布局管理器，可以帮助开

发人员快速构建用户友好的界面。下面我们来介绍一下如何使用Java Swing进行桌面应用程序开发。

首先，我们需要创建一个Swing的主窗口。可以通过继承JFrame

类来创建一个新的窗口，然后设置窗口的标题、大小和关闭操作等属性。在构造函数中，可以添加各种组件来构建窗口的布局。

接着，我们可以在窗口中添加各种Swing组件，如按钮、文本框、标签、复选框等，来实现用户交互。通过设置组件的属性和监听器，

可以实现各种功能，如点击按钮触发事件、输入文本获取数据等。

另外，布局管理器也是Swing开发中很重要的一部分。Swing提供了多种布局管理器，如FlowLayout、BorderLayout、GridBagLayout 等，可以帮助我们更方便地实现窗口中组件的排列和布局。

除了基本的组件和布局管理器，Swing还提供了绘图功能和自定义组件的支持。通过继承JComponent类，可以实现自定义的绘图和组件，以满足更复杂的需求。

最后，在完成界面设计和功能实现后，可以通过调用

setVisible(true)方法来显示窗口，并运行程序。在程序运行时，用

户可以与界面进行交互，体验功能和效果。

总的来说，使用Java Swing进行桌面应用程序开发是一种简单而

灵活的方式。通过合理使用Swing提供的各种组件和功能，可以快速

实现各种桌面应用程序，并提供良好的用户体验。希望以上介绍对你

如何使用JAVA进行图形界面编程

如何使用JAVA进行图形界面编程引言：

在计算机科学领域中，图形用户界面（GUI）是一种用户与计算机交互的界面形式。它通过图形元素如按钮、文本框、菜单等，提供了一种直观、友好的方式来操作计算机程序。JAVA作为一种强大的编程语言，提供了丰富的库和工具来进行图形界面编程。本文将介绍如何使用JAVA进行图形界面编程，包括界面设计、事件处理和布局管理。

一、界面设计

1.1 使用Swing库

JAVA的Swing库是一套用于创建图形用户界面的API。它提供了各种组件和容器来构建界面。首先，我们需要导入Swing库：

```java

import javax.swing.*;

```

1.2 创建主窗口

在JAVA中，主窗口通常是一个JFrame对象。我们可以使用如下代码创建一个简单的主窗口：

```java

JFrame frame = new JFrame("My Application");

frame.setSize(800, 600);

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

frame.setVisible(true);

```

1.3 添加组件

在主窗口中，我们可以添加各种组件来构建界面。例如，我们可以添加一个按钮：

```java

JButton button = new JButton("Click me");

frame.getContentPane().add(button);

```

1.4 布局管理

布局管理器用于控制组件在界面中的位置和大小。JAVA提供了多种布局管理器，如FlowLayout、BorderLayout和GridLayout等。我们可以根据需要选择合适

如何用Java编写简单的图形界面

如何用Java编写简单的图形界面Java是一种强大的编程语言，它提供了多种库和工具来开发图形

界面。在本文中，将介绍如何使用Java编写简单的图形界面。

1. Java的图形界面编程主要基于Java Swing库。首先，要确保

已经安装了Java Development Kit(JDK)。

2.在开始编写图形界面之前，需要了解几个基本概念。Java的图

形界面是由组件（Component）构成的，比如按钮、文本框、标签等。

这些组件可以放置在容器（Container）中，比如窗口（Window）、面

板（Panel）等。容器可以包含其他组件，并且可以嵌套在其他容器中，形成多层次的布局。通过监听事件（Event）可以对用户的操作做出响应，比如按钮点击、鼠标移动等。

3.在Java中，可以使用Swing类库来创建图形界面。Swing提供

了一套完整的组件，用于创建各种图形界面应用程序。

4.首先，创建一个新的Java项目。在项目中创建一个新的Java 类，用于编写图形界面的代码。

5.在Java类中，需要导入相应的Swing库以及其他必要的类。导入语句一般写在文件的顶部。

```java

import javax.swing.*;

import java.awt.*;

```

6.创建一个继承自JFrame类的窗口对象，该对象将作为主窗口。在构造函数中设置窗口的标题、大小和关闭操作等。

```java

public class MyWindow extends JFrame {

public MyWindow() {

setTitle("我的窗口");

Java图形界面开发教程

Java是一种广泛应用于软件开发的编程语言，它提供了丰富的图形界面开发工

具和库。在本教程中，我们将介绍如何使用Java进行图形界面开发，并提供一些

实例来帮助你更好地理解。

一、Java图形界面开发的基础知识

1. Java图形界面开发的概述

Java图形界面开发是一种通过用户可视化方式与应用程序进行交互的方法。通

过图形界面，用户可以通过鼠标和键盘来操作应用程序，在界面上进行输入和输出。

2. Java图形界面开发的工具和库

Java提供了许多图形界面开发的工具和库，其中最常用的是Swing和AWT。Swing提供了丰富的组件和布局管理器，用于创建灵活、漂亮的用户界面。AWT

是Java最早的图形界面开发工具，提供了一组可直接使用的组件。

3. Java图形界面开发的基本概念

在Java图形界面开发中，有一些基本概念需要了解。其中包括组件、容器、布局管理器和事件处理。

- 组件：组件是图形界面的基本元素，包括按钮、文本框、标签等。每个组件

都有自己的属性和方法，用于设置和获取组件的状态和行为。

- 容器：容器是用于包含和布局其他组件的对象。常用的容器包括窗口、面板

和对话框。容器可以嵌套使用，形成复杂的界面结构。

- 布局管理器：布局管理器用于控制组件在容器中的位置和大小。Java提供了

多种布局管理器，如流式布局、边界布局和网格布局等。

- 事件处理：Java图形界面是事件驱动的，当用户进行操作时，会触发相应的

事件。开发者需要编写事件处理代码，来响应事件并执行相应的操作。

二、使用Swing进行图形界面开发

JAVA图形界面各种布局及使用方法

1.布局

对于JFrame窗口，默认布局是BorderLayout布局。

对于JPanel，默认布局是FlowLayout布局。

容器可以使用方法：

setLayout(布局对象)；来设置自己的布局。

（1）FlowLayout布局

FlowLayout类创建的对象称做FlowLayout型布局。

FlowLayout类的一个常用构造方法如下：

FlowLayout()

该构造方法可以创建一个居中对齐的布局对象。例如：

FlowLayout flow=new FlowLayout();

如果一个容器con使用这个布局对象：

con.setLayout(flow);

那么，con可以使用Container类提供的add方法将组件顺序地添加到容器中，组件按照加入的先后顺序从左向右排列，一行排满之后就转到下一行继续从左至右排列。

FlowLayout布局对象调用flow.setAlignment(FlowLayout.LEFT);来设置组件靠左对齐

FlowLayout布局对象调用setHgap(int hgap) 方法和setVgap(int vgap)可以重新设置布局的水平间隙和垂直间隙。

（2）BorderLayout布局

BorderLayout 布局是Window型容器的默认布局，例如JFrame、JDialog都是Window类的间接子类，它们的默认布局都是BorderLayout 布局。容器使用BorderLayout 布局，那么容器空间简单地划分为东、西、南、北、中五个区域。每加入一个组件都应该指明把这个组件添加在哪个区域中，区域由BorderLayout中的静态常量CENTER、NORTH、SOUTH、WEST、EAST表示.

Java微信小程序开发指南使用Java开发小程序

Java微信小程序开发指南使用Java开发小

程序

使用Java开发微信小程序是一种强大的方式，可为开发人员提供广泛的工具和功能，以创建功能丰富、高性能的小程序。本文将向您介

绍Java微信小程序开发的指南，包括开发环境的设置、常用的开发工

具和技术，以及一些开发中常见的问题和解决方法。

一、开发环境设置

在开始Java微信小程序开发之前，您需要进行一些必要的开发环境设置。首先，您需要安装Java开发工具包（JDK），并配置Java开发

环境。您可以从Oracle官方网站下载JDK安装包，并按照安装向导进

行安装和设置。安装完成后，您可以通过命令行工具（如Windows的

命令提示符或Mac OS的终端）来验证您的Java环境是否已正确配置。

接下来，您需要安装开发集成工具（IDE），如Eclipse、IntelliJ IDEA等。这些IDE提供了丰富的功能和插件，以帮助您更高效地进行Java开发。您可以根据个人喜好选择适合自己的IDE，并按照安装向

导进行设置。

二、常用的开发工具和技术

在Java微信小程序开发中，有一些常用的开发工具和技术可以帮助您更好地进行开发。以下是其中几个常用的工具和技术：

1. Maven：Maven是一个项目管理工具，它可以用于构建、依赖管理和部署项目。您可以使用Maven来管理项目的依赖库和构建过程，以提高项目的可维护性和可扩展性。

2. Spring Boot：Spring Boot是一个开发框架，它可以帮助您快速构建Java应用程序。使用Spring Boot，您可以通过简单的配置和约定，减少繁琐的配置步骤，快速搭建起一个可运行的微信小程序。

Java调试技巧之堆栈分析

堆栈分析是Java开发者在调试代码时经常使用的一种技巧。通过分析堆栈信息，我们可以快速定位代码中的问题，并解决它们。在本文中，我将介绍一些常用的堆栈分析技巧，帮助读者更好地理解和利用这一工具。

首先，让我们了解一下堆栈的基本概念。堆栈是一种数据结构，用于存储方法

调用的信息。每当一个方法被调用时，Java虚拟机都会在堆栈中创建一个新的帧，用于存储该方法的局部变量、参数和返回地址等信息。当方法执行完成后，该帧将被销毁。因此，堆栈可以看作是方法调用的轨迹。

在进行堆栈分析时，我们通常会收集堆栈信息。在Java中，可以通过Thread

类的getStackTrace方法来获取当前线程的堆栈信息。这个方法返回一个StackTraceElement数组，每个元素代表一个方法调用。通过分析这些元素，我们

可以了解方法的调用关系和执行顺序。

堆栈分析的一个常见用途是定位异常的发生位置。当程序抛出异常时，Java虚

拟机会生成一个异常对象，并将当前线程的堆栈信息保存在该对象中。通过打印异常的堆栈信息，我们可以追踪异常的发生位置，并找到引发异常的代码。这对于调试代码和修复bug非常有帮助。

除了定位异常，堆栈分析还可以帮助我们找到性能问题。通过分析方法调用的

次数和耗时，我们可以确定哪些方法是程序的瓶颈。例如，如果某个方法被频繁调用且执行时间较长，那么可能需要优化该方法的算法或数据结构。通过堆栈分析，我们可以快速定位这些性能问题，并采取相应的优化措施。

在进行堆栈分析时，有一些常用的技巧可以帮助我们更好地理解和利用堆栈信息。首先，我们可以通过打印堆栈信息来获取更详细的调用链。例如，可以使用System.out.println方法将堆栈信息输出到控制台。这样做可以帮助我们更好地理解

值得苦练的55个java小项目

值得苦练的55个java小项目Java是一种广泛使用的编程语言，具有强大的跨平台能力和丰富的类库支持，因此在编程领域有着广泛的应用。对于初学者来说，通过实践小项目可以帮助巩固所学的知识，提高编程能力。下面是值得苦练的55个Java小项目，希望能对你有所帮助。

1.电子商务网站：实现用户注册、登录、购物车、订单管理等功能。

2.在线考试系统：包括题库管理、试卷生成、考试和成绩管理等功能。

3.学生成绩管理系统：实现学生信息录入、成绩查询和统计等功能。

4.客户关系管理系统：实现客户信息录入、跟踪、分析和营销等功能。

5.图书馆管理系统：包括图书的借阅、归还和图书信息管理等功能。

6.个人博客系统：实现用户的博客发布、分类、搜索以及评论功能。

7.社交网络系统：实现用户注册、登录、添加好友、发表动态等功能。

8.文件管理系统：包括文件上传、下载以及文件夹管理等功能。

9.问答系统：用户可以提出问题，其他用户可以回答和评论。

10.新闻聚合系统：整合多个新闻源的内容，进行分类和展示。

11.在线聊天系统：实现用户之间的在线聊天和文件传输功能。

12.客户端媒体播放器：包括音乐和视频的播放和管理功能。

13.文件加密解密工具：实现文件的加密和解密功能。

14.个人财务管理系统：包括收入、支出的记录和统计功能。

15.在线投票系统：用户可以发布投票，并进行统计和展示。

16.个人日程管理系统：包括日程的增加、编辑和提醒功能。

17.在线邮件系统：用户可以发送、接收和管理邮件。

18.智能家居控制系统：包括远程控制家居设备的功能。

Java图形界面开发教程

Java是一种强大且灵活的编程语言，可以用于开发各种应用程序，包括图形界面（Graphical User Interface，GUI）应用程序。在本教程中，我将介绍如何使用Java开发图形界面应用程序，并提供一些实用的技巧和示例代码。

一、Java图形界面开发概述

图形界面是现代应用程序中常见的用户界面形式，它通过图形元素（如按钮、文本框、标签等）和视觉效果来与用户进行交互。Java提供了Swing和JavaFX两个主要的GUI库，它们可以用于构建各种各样的图形界面应用程序。

1.1 Swing GUI库

Swing是Java平台的一部分，提供了一组用于构建图形界面的类和组件。它具有跨平台的特性，可以在各种操作系统上运行。Swing组件包括窗口（JFrame）、按钮（JButton）、文本框（JTextField）、标签（JLabel）等，开发者可以通过简单地实例化这些组件来创建界面。

1.2 JavaFX GUI库

JavaFX是Java平台的另一个图形界面库，它提供了更现代化和丰富的用户界面特性。与Swing相比，JavaFX采用了更加灵活的UI布局方式，并且支持更多的动画效果和视觉效果。JavaFX中的主要组件包括容器（Pane）、按钮（Button）、文本框（TextField）、标签（Label）等。

二、Swing图形界面开发实例

下面是一个简单的Swing图形界面应用程序的示例代码：

```java

import javax.swing.*;

public class SimpleSwingApp extends JFrame {

Java形界面SwingJavaFX和AWT

Java形界面SwingJavaFX和AWT Java形界面Swing、JavaFX和AWT

Java是一种广泛应用的编程语言，其强大的图形界面（GUI）库使得开发者能够创建各种各样的用户界面。在Java中，有三种主要的GUI库，它们分别是Swing、JavaFX和AWT。本文将详细介绍这三种GUI库的特性和使用方法。

一、Swing

Swing是Java提供的一套用于构建图形界面的库，它基于AWT库进行了扩展。Swing提供了丰富的组件和布局管理器，使得开发者能够轻松地创建漂亮和交互性强的界面。

1.1 组件

Swing提供了大量的组件，包括按钮、文本框、标签、列表框、表格等。开发者可以通过组合这些组件来构建复杂的界面。Swing组件的特点是可定制性高，开发者可以自定义组件的外观和行为。

1.2 布局管理器

Swing通过布局管理器来自动调整组件的位置和大小。常用的布局管理器有FlowLayout、BorderLayout、GridLayout和GridBagLayout。开发者可以根据界面的需要选择合适的布局管理器。

1.3 事件处理

Swing使用事件模型来处理用户的输入和其他操作。开发者可以为

组件添加事件监听器，响应用户的操作。事件处理是Swing应用中的

重要部分，可以使界面与用户产生交互。

二、JavaFX

JavaFX是Oracle推出的新一代Java GUI库。与Swing相比，JavaFX提供了更多的现代化特性，包括动画效果、3D支持和富文本等。

2.1 UI控件

JavaFX提供了一套丰富的UI控件，包括按钮、标签、文本框、下

相关主题

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.*;
import java.util.Timer;
import java.util.TimerTask;
import ng.*;
import java.text.*;
import javax.swing.border.*;
import javax.script.*;
public class Ex1_0 implements ActionListener
{
static JFrame f=null;
JButton r1,r2,r3,r4,r5,r6,b1,b2,b3,b4,b5,b6,b7,b8,b9,b10;
JTextField F1,F3,F4,F6,F7,F8,F12,F13,F14,F15;
JTextArea F2,F5,F9,F10,F11,T1;
JScrollPane sp;
JPanel p2,p3,p4,p5,p6,p7;
SpringLayout layout;
Container contentPane;
public Ex1_0()
{
f=new JFrame("蓝点暑期任务");
contentPane=f.getContentPane();
f.setPreferredSize(new Dimension(570,450));

JPanel p1=new JPanel();
p1.setLayout(new GridLayout(1,6));
p1.setBorder(BorderFactory.createTitledBorder(BorderFactory.createLineBorder(
Color.blue,2),"选择功能种类",TitledBorder.CENTER,TitledBorder.TOP));
r1 = new JButton("堆栈");
r2 = new JButton("队列");
r3 = new JButton("排序");
r4 = new JButton("正弦图");
r5 = new JButton("画图");
r6 = new JButton("退出");
p1.add(r1);
p1.add(r2);
p1.add(r3);
p1.add(r4);
p1.add(r5);
p1.add(r6);
r1.addActionListener(this);
r2.addActionListener(this);
r3.addActionListener(this);
r4.addActionListener(this);
r5.addActionListener(this);
r6.addActionListener(this);

//p2 代码显示区
p2=new JPanel();
p2.setBounds(10,10,200,200);
p2.setLayout(new GridLayout(1,1));
p2.setBorder(BorderFactory.createTitledBorder(BorderFactory.createLineBorder
(Color.blue,2),"代码显示区域",TitledBorder.CENTER,TitledBorder.TOP));
T1 = new JTextArea(" ",10,23);
T1.setLineWrap(true);
sp = new JScrollPane(T1);
p2.add(sp);
//T1.setPreferredSize(new Dimension(5,5));
//p2.add(T1);

//p3 堆栈布局
p3=new JPanel();
layout= new SpringLayout();
p3.setLayout(layout);
p3.setPreferredSize(new Dimension(270,350));
p3.setBorder(BorderFactory.createTitledBorder(BorderFactory.createLineBorder
(Color.blue,2),"功能显示区域",TitledBorder.CENTER,TitledBorder.TOP));
JLabel L1 = new JLabel("入栈数据");
p3.add(L1);
layout.putConstraint(SpringLayout.NORTH,L1,60,SpringLayout.NORTH,p3);
layout.putConstraint(SpringLayout.WEST,L1,10,SpringLayout.WEST,p3);
F1 = new JTextField(10);
p3.add(F1);
layout.putConstraint(SpringLayout.NORTH,F1,60,SpringLayout.NORTH,p3);
layout.putConstraint(SpringLayout.WEST,F1,65,SpringLayout.WEST,p3);
b1 = new JButton("确定");
b1.setPreferredSize(new Dimension(60,22));
p3.add(b1);
layout.putConstraint(SpringLayout.NORTH,b1,60,SpringLayout.NORTH,p3);
layout.putConstraint(SpringLayout.WEST,b1,190,SpringLayout.WEST,p3);
JLabel L2 = new JLabel("出栈数据");
p3.add(L2);
layout.putConstraint(SpringLayout.NORTH,L2,140,SpringLayout.NORTH,p3);
layout.putConstraint(SpringLayout.WEST,L2,10,S

pringLayout.WEST,p3);
F2 = new JTextArea(" ",1,10);
p3.add(F2);
layout.putConstraint(SpringLayout.NORTH,F2,140,SpringLayout.NORTH,p3);
layout.putConstraint(SpringLayout.WEST,F2,65,SpringLayout.WEST,p3);
b9 = new JButton("确定");
b9.setPreferredSize(new Dimension(60,22));
p3.add(b9);
layout.putConstraint(SpringLayout.NORTH,b9,140,SpringLayout.NORTH,p3);
layout.putConstraint(SpringLayout.WEST,b9,190,SpringLayout.WEST,p3);
JLabel L3 = new JLabel("栈顶元素");
p3.add(L3);
layout.putConstraint(SpringLayout.NORTH,L3,220,SpringLayout.NORTH,p3);
layout.putConstraint(SpringLayout.WEST,L3,10,SpringLayout.WEST,p3);
F3 = new JTextField(5);
p3.add(F3);
layout.putConstraint(SpringLayout.NORTH,F3,220,SpringLayout.NORTH,p3);
layout.putConstraint(SpringLayout.WEST,F3,65,SpringLayout.WEST,p3);
b2 = new JButton("取栈顶元素");
b2.setPreferredSize(new Dimension(105,22));
p3.add(b2);
layout.putConstraint(SpringLayout.NORTH,b2,220,SpringLayout.NORTH,p3);
layout.putConstraint(SpringLayout.WEST,b2,150,SpringLayout.WEST,p3);

//p4 队列布局
p4=new JPanel();
layout= new SpringLayout();
p4.setLayout(layout);
p4.setPreferredSize(new Dimension(270,350));
p4.setBorder(BorderFactory.createTitledBorder(BorderFactory.createLineBorder
(Color.blue,2),"功能显示区域",TitledBorder.CENTER,TitledBorder.TOP));
JLabel L4 = new JLabel("入队数据");
p4.add(L4);
layout.putConstraint(SpringLayout.NORTH,L4,60,SpringLayout.NORTH,p4);
layout.putConstraint(SpringLayout.WEST,L4,10,SpringLayout.WEST,p4);
F4 = new JTextField(10);
p4.add(F4);
layout.putConstraint(SpringLayout.NORTH,F4,60,SpringLayout.NORTH,p4);
layout.putConstraint(SpringLayout.WEST,F4,65,SpringLayout.WEST,p4);
b3 = new JButton("确定");
b3.setPreferredSize(new Dimension(60,22));
p4.add(b3);
layout.putConstraint(SpringLayout.NORTH,b3,60,SpringLayout.NORTH,p4);
layout.putConstraint(SpringLayout.WEST,b3,190,SpringLayout.WEST,p4);
JLabel L5 = new JLabel("出队数据");
p4.add(L5);
layout.putConstraint(SpringLayout.NORTH,L5,140,SpringLayout.NORTH,p4);
layout.putConstraint(SpringLayout.WEST,L5,10,SpringLayout.WEST,p4);
F5 = new JTextArea(" ",1,10);
p4.add(F5);
layout.putConstraint(SpringLayout.NORTH,F5,140,SpringLayout.NORTH,p4);
layout.putConstraint(SpringLayout.WEST,F5,65,SpringLayout.WEST,p4);
b10 = new JButton("确定");
b10.setPreferredSize(new Dimension(60,22));
p4.add(b10);
layout.putConstraint(SpringLayout.NORTH,b10,140,SpringLayout.NORTH,p4);
layout.putConstraint(SpringLayout.WEST,b10,190,SpringLayout.WEST,p4);
JLabel L6 = new JLabel("队头元素");
p4.add(L6);
layout.putConstraint(SpringLayout.NORTH,L6,220,SpringLayout.NORTH,p4);
layout.putConstraint(SpringLayout.WEST,L6,10,SpringLayout.WEST,p4);
F6 = new JTextField(5);
p4.add(F6);
layout.putConstraint(SpringLayout.NORTH,F6

,220,SpringLayout.NORTH,p4);
layout.putConstraint(SpringLayout.WEST,F6,65,SpringLayout.WEST,p4);
b4 = new JButton("取队头元素");
b4.setPreferredSize(new Dimension(105,22));
p4.add(b4);
layout.putConstraint(SpringLayout.NORTH,b4,220,SpringLayout.NORTH,p4);
layout.putConstraint(SpringLayout.WEST,b4,150,SpringLayout.WEST,p4);
JLabel L7 = new JLabel("队尾元素");
p4.add(L7);
layout.putConstraint(SpringLayout.NORTH,L7,290,SpringLayout.NORTH,p4);
layout.putConstraint(SpringLayout.WEST,L7,10,SpringLayout.WEST,p4);
F7 = new JTextField(5);
p4.add(F7);
layout.putConstraint(SpringLayout.NORTH,F7,290,SpringLayout.NORTH,p4);
layout.putConstraint(SpringLayout.WEST,F7,65,SpringLayout.WEST,p4);
b5 = new JButton("取队尾元素");
b5.setPreferredSize(new Dimension(105,22));
p4.add(b5);
layout.putConstraint(SpringLayout.NORTH,b5,290,SpringLayout.NORTH,p4);
layout.putConstraint(SpringLayout.WEST,b5,150,SpringLayout.WEST,p4);

//p5 排序布局
p5 = new JPanel();
layout= new SpringLayout();
p5.setLayout(layout);
p5.setPreferredSize(new Dimension(270,350));
p5.setBorder(BorderFactory.createTitledBorder(BorderFactory.createLineBorder
(Color.blue,2),"功能显示区域",TitledBorder.CENTER,TitledBorder.TOP));
JLabel L8 = new JLabel("初始序列");
p5.add(L8);
layout.putConstraint(SpringLayout.NORTH,L8,60,SpringLayout.NORTH,p5);
layout.putConstraint(SpringLayout.WEST,L8,10,SpringLayout.WEST,p5);
F8 = new JTextField(10);
p5.add(F8);
layout.putConstraint(SpringLayout.NORTH,F8,60,SpringLayout.NORTH,p5);
layout.putConstraint(SpringLayout.WEST,F8,65,SpringLayout.WEST,p5);
b6 = new JButton("确定");
b6.setPreferredSize(new Dimension(60,22));
p5.add(b6);
layout.putConstraint(SpringLayout.NORTH,b6,60,SpringLayout.NORTH,p5);
layout.putConstraint(SpringLayout.WEST,b6,190,SpringLayout.WEST,p5);
JLabel L9 = new JLabel("插入排序");
p5.add(L9);
layout.putConstraint(SpringLayout.NORTH,L9,140,SpringLayout.NORTH,p5);
layout.putConstraint(SpringLayout.WEST,L9,10,SpringLayout.WEST,p5);
F9 = new JTextArea("",1,10);
p5.add(F9);
layout.putConstraint(SpringLayout.NORTH,F9,140,SpringLayout.NORTH,p5);
layout.putConstraint(SpringLayout.WEST,F9,65,SpringLayout.WEST,p5);
JLabel L10 = new JLabel("冒泡排序");
p5.add(L10);
layout.putConstraint(SpringLayout.NORTH,L10,220,SpringLayout.NORTH,p5);
layout.putConstraint(SpringLayout.WEST,L10,10,SpringLayout.WEST,p5);
F10 = new JTextArea("",1,10);
p5.add(F10);
layout.putConstraint(SpringLayout.NORTH,F10,220,SpringLayout.NORTH,p5);
layout.putConstraint(SpringLayout.WEST,F10,65,SpringLayout.WEST,p5);
JLabel L11 = new JLabel("选择排序");
p5.add(L11);
layout.putConstraint(SpringLayout.NORTH,L11,290,SpringLayout.NORTH,p5);
layout.putConstraint(SpringLayout.WEST,L11,10,SpringLayout.WEST,p5);

F11 = new JTextArea("",1,10);
p5.add(F11);
layout.putConstraint(SpringLayout.NORTH,F11,290,SpringLayout.NORTH,p5);
layout.putConstraint(SpringLayout.WEST,F11,65,SpringLayout.WEST,p5);

//p6 画正弦图
p6 = new JPanel();
layout= new SpringLayout();
p6.setLayout(layout);
p6.setPreferredSize(new Dimension(270,350));
p6.setBorder(BorderFactory.createTitledBorder(BorderFactory.createLineBorder
(Color.blue,2),"功能显示区域",TitledBorder.CENTER,TitledBorder.TOP));
JLabel L12 = new JLabel("请输入x的值");
p6.add(L12);
layout.putConstraint(SpringLayout.NORTH,L12,10,SpringLayout.NORTH,p6);
layout.putConstraint(SpringLayout.WEST,L12,10,SpringLayout.WEST,p6);
F12 = new JTextField(5);
p6.add(F12);
layout.putConstraint(SpringLayout.NORTH,F12,10,SpringLayout.NORTH,p6);
layout.putConstraint(SpringLayout.WEST,F12,100,SpringLayout.WEST,p6);
b7 = new JButton("确定");
b7.setPreferredSize(new Dimension(63,22));
p6.add(b7);
layout.putConstraint(SpringLayout.NORTH,b7,10,SpringLayout.NORTH,p6);
layout.putConstraint(SpringLayout.WEST,b7,180,SpringLayout.WEST,p6);

//p7
p7 = new JPanel();
layout= new SpringLayout();
p7.setLayout(layout);
p7.setPreferredSize(new Dimension(270,350));
p7.setBorder(BorderFactory.createTitledBorder(BorderFactory.createLineBorder
(Color.blue,2),"功能显示区域",TitledBorder.CENTER,TitledBorder.TOP));
JLabel L13= new JLabel("正方形边长");
p7.add(L13);
layout.putConstraint(SpringLayout.NORTH,L13,30,SpringLayout.NORTH,p7);
layout.putConstraint(SpringLayout.WEST,L13,10,SpringLayout.WEST,p7);
F13 = new JTextField(5);
p7.add(F13);
layout.putConstraint(SpringLayout.NORTH,F13,30,SpringLayout.NORTH,p7);
layout.putConstraint(SpringLayout.WEST,F13,100,SpringLayout.WEST,p7);
b8 = new JButton("确定");
b8.setPreferredSize(new Dimension(63,22));
p7.add(b8);
layout.putConstraint(SpringLayout.NORTH,b8,30,SpringLayout.NORTH,p7);
layout.putConstraint(SpringLayout.WEST,b8,180,SpringLayout.WEST,p7);
JLabel L14 = new JLabel("圆的半径");
p7.add(L14);
layout.putConstraint(SpringLayout.NORTH,L14,70,SpringLayout.NORTH,p7);
layout.putConstraint(SpringLayout.WEST,L14,10,SpringLayout.WEST,p7);
F14 = new JTextField(5);
F14.setEditable(false);
p7.add(F14);
layout.putConstraint(SpringLayout.NORTH,F14,70,SpringLayout.NORTH,p7);
layout.putConstraint(SpringLayout.WEST,F14,100,SpringLayout.WEST,p7);
JLabel L15 = new JLabel("面积之比");
p7.add(L15);
layout.putConstraint(SpringLayout.NORTH,L15,110,SpringLayout.NORTH,p7);
layout.putConstraint(SpringLayout.WEST,L15,10,SpringLayout.WEST,p7);
F15 = new JTextField(5);
F15.setEditable(false);
p7.add(F15);
layout.putConstraint(SpringLayout.NORTH,F15,110,SpringLayout.NORTH,p7);
layout.putConstraint(SpringLayout.WEST,F15,100,SpringLayout.WEST,p7);

b1.addActionListener(this);
b2.addActionListener(this);
b9.addActionListener(this);
b3.addActionListener(this);
b4.addActionListener(this);
b5.addActionListener(this);
b10.addActionListener(this);
b6.addActionListener(this);
b7.addActionListener(this);
b8.addActionListener(this);

contentPane.add(p1,BorderLayout.NORTH);
contentPane.add(p2,BorderLayout.WEST);
contentPane.add(p3,BorderLayout.EAST);

f.pack();
f.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent evt){
System.exit(0);
}
});
}

//方法类声明
stack stack1 = new stack();
queue queue1 = new queue();
sort sort1 = new sort();
SinPanel sinPanel = new SinPanel();
shape shape1 = new shape();

public void actionPerformed(ActionEvent e)
{
if(e.getSource()==r1)
{
contentPane.add(p3,BorderLayout.EAST);
p3.setVisible(true);
p4.setVisible(false);
p5.setVisible(false);
p6.setVisible(false);
p7.setVisible(false);

T1.setText(" ");
File file = new File("e://stack.txt");
if (file.exists() && file.isFile()) {
try {
BufferedReader in = new BufferedReader(new FileReader(file));
String line;
while ((line = in.readLine()) != null)
T1.setText(T1.getText() + line + "\n");
} catch (IOException ioException) {
System.out.println(" NO File !");
}
}
}
else if(e.getSource()==r2)
{
contentPane.add(p4,BorderLayout.EAST);
p3.setVisible(false);
p4.setVisible(true);
p5.setVisible(false);
p6.setVisible(false);
p7.setVisible(false);

T1.setText(" ");
File file = new File("e://蓝点暑期作业//queue.txt");
if (file.exists() && file.isFile()) {
try {
BufferedReader in = new BufferedReader(new FileReader(file));
String line;
while ((line = in.readLine()) != null)
T1.setText(T1.getText() + line + "\n");
} catch (IOException ioException) {
System.out.println("NO File !");
}
}
}
else if(e.getSource()==r3)
{
contentPane.add(p5,BorderLayout.EAST);
p3.setVisible(false);
p4.setVisible(false);
p5.setVisible(true);
p6.setVisible(false);
p7.setVisible(false);

T1.setText(" ");
File file = new File("e://sort.txt");
if (file.exists() && file.isFile()) {
try {
BufferedReader in = new BufferedReader(new FileReader(file));
String line;
while ((line = in.readLine()) != null)
T1.setText(T1.getText() + line + "\n");

} catch (IOException ioException) {
System.out.println("NO File !");
}
}
}
else if(e.getSource()==r4)
{
contentPane.add(p6,BorderLayout.EAST);
p3.setVisible(false);
p4.setVisible(false);
p5.setVisible(false);
p6.setVisible(true);
p7.setVisible(false);

T1.setText(" ");
File file = new File("e://SinPanel.txt");
if (file.exists() && file.isFile()) {
try {
BufferedReader in = new BufferedReader(new FileReader(file));
String line;
while ((line = in.readLine()) != null)
T1.setText(T1.getText() + line + "\n");
} catch (IOException ioException) {
System.out.println("NO File !");
}
}

}
else if(e.getSource()==r5)
{
contentPane.add(p7,BorderLayout.EAST);
p3.setVisible(false);
p4.setVisible(false);
p5.setVisible(false);
p6.setVisible(false);
p7.setVisible(true);

T1.setText(" ");
File file = new File("e://shape.txt");
if (file.exists() && file.isFile()) {
try {
BufferedReader in = new BufferedReader(new FileReader(file));
String line;
while ((line = in.readLine()) != null)
T1.setText(T1.getText() + line + "\n");
} catch (IOException ioException) {
System.out.println("NO File !");
}
}
}
else if(e.getSource()==r6)
{
JOptionPane.showMessageDialog(null, "请多多关照！", "请多多支持",RMATION_MESSAGE);
System.exit(0);
}

//堆栈功能实现
else if(e.getSource() == b1)
{
F2.setText(" ");
String s1=(String)F1.getText();
String []a1 = new String[20];
a1=s1.split(" ");

for(int i=0;i{
stack1.push(a1[i]);
}
}

else if(e.getSource() == b9)
{
String b1=(String)stack1.pop();
String []temp1 = b1.split(" ");
int[] a1= new int[temp1.length];
for(int i=0;i{
a1[i]=Integer.parseInt(temp1[i]);
}
// temp1= b1.split(" ");
for(int k=0;k{
F2.append(String.valueOf(temp1[k])+" ");
}

/*for(int i=0;i{
F2.setText(temp1[i]);
} */
}

else if(e.getSource() == b2)
{
String s1=(String)F1.getText();
stack1.push(s1);
String []a1 = s1.split(" ");
for(int i=0;i{
stac

k1.push(a1[i]);
}
F3.setText((String)stack1.top());
}

//队列功能实现
else if(e.getSource() == b3)
{
F5.setText(" ");
String s2=(String)F4.getText();
String []a2 = s2.split(" ");
for(int i=0;i{
queue1.enqueue(a2[i]);
}

}

else if(e.getSource() == b10)
{
String b2=(String)queue1.dequeue();
String []temp2 = b2.split(" ");
int[] a2= new int[temp2.length];
for(int i=0;i{
a2[i]=Integer.parseInt(temp2[i]);
}
for(int k=0;k{
F5.append(String.valueOf(temp2[k])+" ");
}
/*for(int i=0;i{
F5.setText(temp2[i]);
}*/
}
else if(e.getSource() == b4)
{
F6.setText((String)queue1.front());
}
else if(e.getSource() == b5)
{
F7.setText((String)queue1.behind());
}

//排序功能实现
else if(e.getSource() == b6)
{
String s3 = (String)F8.getText();
String []b3 = s3.split(" ");
int[] a3= new int[b3.length];
for(int i=0;i{
a3[i]=Integer.parseInt(b3[i]);
}
F9.setText(" ");
sort1.insersort(a3);
F10.setText(" ");
sort1.bubbleSort(a3);
F11.setText("");
sort1.selectSort(a3);
}

//正弦图功能实现
else if(e.getSource() == b7)
{
Graphics g = p6.getGraphics();
g.clearRect(5,60,250,240);
sinPanel.paintComponent(g);
}

//画圆和正方形
else if(e.getSource() == b8)
{
Graphics g = p7.getGraphics();
g.clearRect(70,180,190,170);
shape1.paint(g);
}

}

public static void main(String[] args){
new Ex1_0();
new PassWord(f);
}

//堆栈类
class stack
{
Object[] elements;
int size;

public stack(int len) {
elements = new Object[len];
size = 0;
}

public stack() {
this(50);
}
public void push(Object element) {
elements[size] = element;
size++;
}
public Object pop() {
if (!this.isEmpty()) {
Object obj = elements[size - 1];
elements[size - 1] = null;
size--;
return obj;
}
else
{
return null;
}
}
public Object top() {
if (!this.isEmpty()) {
return elements[size - 1];
}
else
{
return null;
}
}
public boolean isEmpty() {
return this.size

1() == 0;
}
public int size1() {
return size;
}

}

//队列类
class queue
{
public Object[] data;
protected int size ;
protected int head;
public int tail;
public queue() {
final int LENGTH = 3;
data=new Object[LENGTH];
size=0;
head=0;
tail=-1;
}
public int size(){
return size;
}
public boolean isEmpty(){
return size==0;
}

public Object front(){
return data[head];
}

public Object behind(){
return data[tail];
}

public void enqueue(Object obj){

if(size==data.length){
Object[] oldData=data;
data=new Object[data.length*2];
System.arraycopy(oldData, head, data, 0, oldData.length-head);
if(head>0)
System.arraycopy(oldData, 0, data, head+1, tail+1);
head=0;
tail=oldData.length-1;
}
tail=(tail+1)%data.length;
size++;
data[tail]=obj;
}

public Object dequeue()
{
if(size==0)
throw new NoSuchElementException();
Object ele=data[head];
head=(head+1)%data.length;
size--;
return ele;
}
}

//排序
class sort
{
//插入排序
public void insersort(int a[]){
if(a!=null){
for(int i=1;iint temp=a[i],j=i;
if(a[j-1]>temp){
while(j>=1&&a[j-1]>temp){
a[j]=a[j-1];
j--;
}
}
a[j]=temp;
}
}else{
System.out.print("NO");
}
PrintSort1(a);
}
public void PrintSort1(int c[]){
for(int k=0;kF9.append(String.valueOf(c[k])+" ");
}
}

//冒泡排序
public void bubbleSort(int b[]){
for(int i=0;ifor(int j=0;jint temp=0;
if(b[j]>b[j+1]){
temp=b[j];
b[j]=b[j+1];
b[j+1]=temp;
}
}
}
PrintSort2(b);
}
public void PrintSort2(int c[]){
for(int k=0;kF10.append(String.valueOf(c[k])+" ");
}
}

//选择排序
public void selectSort(int[] a)
{
{
if (a == null || a.length <= 0) {
return;
}
for (int i = 0; i < a.length; i++) {
int min = i;
for (int j = i + 1; j < a.length; j++) {
if (a[min] > a[j]) {
min = j;
}
}
if (i != min) {
int tmp = a[min];
a[min] = a[i];
a[i] = tmp;
}
}
PrintSort3(a);
}
}
public void PrintSort3(int c[]){
for(i

nt k=0;kF11.append(String.valueOf(c[k])+" ");
}
}
}

//正弦图类
class SinPanel extends JPanel
{
public void paintComponent(Graphics g)
{
super.paintComponent(g);
Dimension panelSize = p6.getSize();
Location center = new Location(panelSize.width / 2, panelSize.height / 2);
int radius = (int)((Math.min(panelSize.width, panelSize.height) / 2) * 0.8);
// 确定每个点的坐标
int[] x = new int[2 * radius + 1];
int[] y = new int[2 * radius + 1];

String s = F12.getText();
int temp = Integer.parseInt(s);
if(temp <=10&&temp>=0)
{
for (int i = 0; i < 2 * radius + 1; i++)
{
x[i] = center.x - radius + i;
double y1 = Math.sin(((double) (-radius + i) / radius) * 4 * Math.PI*temp);//sin()里面必须为double值
int y2 = (int) (y1 * 100);
y[i] = center.y - y2;
}
}
else
{
JOptionPane.showMessageDialog(null, "请输入0~10的自然数！", "Warning",RMATION_MESSAGE);
}
g.setColor(Color.black);// 画坐标轴
g.drawLine(center.x - radius, center.y, center.x + radius, center.y);
g.drawLine(center.x, center.y - radius, center.x, center.y + radius);
g.drawLine(center.x + radius, center.y, center.x + radius - 10, center.y - 7);
g.drawLine(center.x + radius, center.y, center.x + radius - 10, center.y + 7);
g.drawLine(center.x, center.y - radius, center.x - 7, center.y - radius + 10);
g.drawLine(center.x, center.y - radius, center.x + 7, center.y - radius + 10);
g.setColor(Color.blue);
g.drawPolyline( x, y, 2 * radius + 1);
g.setColor(Color.red);
g.setFont(new Font("ScanSerif", Font.BOLD, 12));
g.drawString("X", center.x + radius, center.y - 10);
g.drawString("Y", center.x + 10, center.y - radius);
}
}
class Location
{
public int x;
public int y;
public Location(int x, int y)
{
this.x = x;
this.y = y;
}
}

//画图类
class shape
{
public void paint(Graphics g)
{

String s4 = F13.getText();
double t1 = Double.parseDouble(s4);
if(t1%2 == 0)
{
double t2 = t1/2;
String s5 = String.valueOf(t2);
F14.setText(s5);
double t3 = ((t1*t1)/(3.14*t2*t2));
DecimalFormat df = new DecimalFormat("0.00000");
String s6 = df.format(t3);
F15.setText(s6);
g.setColor(Color.blue);
g.drawRect(70, 180, (int)t1*10, (int)t1*10);
g.fillOval(70, 180, (int)t2*20, (int)t2*20);
}
else
{
F14.setText(" ");
F15.setText(" ");
JOptionPane.showMessageDialog(null, "请输入偶数！", "Warning",RMATION_MESSAGE);
}
}
}

}
class PassWord implements ActionListener
{
JTextField user;
JPas

swordField passWd;
JButton b1,b2;
Container dialogPane;
JDialog d;
JFrame f;

public PassWord(JFrame f)
{
d=new JDialog();
d.setTitle("请输入用户名和密码");
dialogPane=d.getContentPane();
dialogPane.setLayout(new GridLayout(3,2));
dialogPane.add(new JLabel("用户名",SwingConstants.CENTER));
user=new JTextField();
dialogPane.add(user);
dialogPane.add(new JLabel("密码",SwingConstants.CENTER));
passWd=new JPasswordField();
dialogPane.add(passWd);
b1=new JButton("确定");
b2=new JButton("退出");
dialogPane.add(b1);
dialogPane.add(b2);
b1.addActionListener(this);
b2.addActionListener(this);
d.setBounds(200,150,400,130);
d.getRootPane().setDefaultButton(b1);
d.setVisible(true);
this.f=f;
}

public void actionPerformed(ActionEvent e)
{
String cmd=e.getActionCommand();
if(cmd.equals("确定"));
{
String name=user.getText();
String passWord=passWd.getText();
if((name.equals("lijiaxuan"))&&(passWord.equals("19930604")))
{
d.dispose();
f.setVisible(true);
return;
}
else
{
JOptionPane.showMessageDialog(d,"错误的用户名或密码","请重新输入",JOptionPane.WARNING_MESSAGE);
user.setText("");
passWd.setText("");
}
}
if(cmd.equals("退出")) System.exit(0);
}
}