java知识点回顾

简介：

   在java编程的学习过程中要建立编程思想，通过化繁为简、先死后活、过关斩将的方式提升编程能力。通过分析需求，锻炼代码实现的能力，多练习代码程序达到唯手熟尔！
SSM包括：spring(轻量级容器框架)、springMVC(分层的Web开发框架)、MyBatis(持久化框架)
重要特点:面向对象(OOP)、健壮性(强类型机制异常处理)、java语言跨平台多系统运行、解释型语言(C++为编译型语言)
JVM：因为有JVM,java程序可以在不同的操作系统中进行，虚拟计算机包含在JDK中,不同平台有不同的虚拟机,JVM屏蔽了底层平台的差异，实现一次编译到处运行。
JDK(java开发工具集): JDK = JRE(java运行环境) + Java的开发工具集
                     JRE(java运行环境) = JVM + Java核心类库

---

IDE使用

设置的快捷键

根据编程习惯设置自己的模板省缺以及快捷键

查看快捷键

.var    new对象时的快捷键
main    快速创建主函数
fori    快速创建for循环
sout    快速创建print语句
itit    快速创建迭代循环
ctrl+j    显示模板快捷键
ctrl+B    定位源码
ctrl+H    层级关系
ctrl+R    快速运行
ctrl+Y    删除行
ctrl+D    向下复制
ctrl+O    构造函数快捷键
ctrl+Alt    光标
ctrl+alt+t    快速包围异常
ctrl+Alt+R    格式化代码
Alt+insert    重写toString方法
Alt+Enter    导入包

编程规范

命名规范

1. 包名使用全小写格式
2. 类名使用大驼峰格式
3. 方法名使用小驼峰格式
4. 变量名使用全小写格式
5. 常量名使用全大写格式

运算符优先级

运算符优先级排序

1. 后缀运算符（如 x++、x- -）
2. 一元运算符（如 ++x、- -x、+x、-x、!、~）
3. 乘法运算符（如 *、/、%）
4. 加法运算符（如 +、-）
5. 移位运算符（如 <<、>>、>>>）
6. 比较运算符（如 <、<=、>、>=、instanceof）
7. 相等运算符（如 ==、!=）
8. 按位与运算符（如 &）
9. 按位异或运算符（如 ^）
10. 按位或运算符（如 |）
11. 逻辑与运算符（如 &&） 逻辑运算符也叫短路运算符
12. 逻辑或运算符（如 ||）
13. 条件运算符（如 ? :）
14. 赋值运算符（如 =、+=、-=、*=、/=、%=、&=、^=、|=、<<=、>>=、>>>=

流程控制语句

1. switch语句
   switch语句的表达式可以是char、byte、short、int或者枚举类型。计算结果是整型（int）或者字符型（char）
2. while循环语句
   1) 先判断表达式的真假，为真执行循环体，为假循环体结束，假时一次也不执行
   2) do语句在执行一次循环体后，再判断条件表达式真假，为真是再执行循环体，为假时结束，不论初始条件表达式为何值，循环体都至少执行一次
3. for语句
   for(i=0,j=0;i< arr.length;i++,j++){}
4. break语句与continue语句
   1) break语句用于结束当前循环（包括for、while、do-while等循环），并跳出该循环外执行下一条语句。
   通常情况下，break语句的执行是有条件的，即在满足一定的条件时才执行break语句。例如，当找到了需要的结果时，可以使用break语句结束循环，以提高程序的效率。
   2) continue语句用于终止当前循环中的当前迭代，跳过剩下的循环语句，直接开始下一次迭代。
   通常情况下，continue语句的执行也是有条件的，即在满足一定的条件时才执行continue语句。
   例如，在遍历一个数组或集合时，可以使用continue语句跳过一些元素，只处理需要的元素，以提高程序的效率。

数组和字符串

数组

1. 初始化
   分为静态初始化与动态初始化
   1) 静态初始化是在创建数组时直接为数组分配空间，指定数组元素的初始值

   dataType[] arrayName = {value1, value2, ..., valueN};

   2) 动态初始化是指在创建数组时，先为数组分配空间。然后再为每一个数组元素制定初始值

   dataType[] arrayName = new dataType[arraySize];

2. 数组的长度
   1) 在Java中，一维数组的长度是数组元素的数量，可以通过数组名.length获取。
   如，

   int[] arr = {1, 2, 3}; //这个数组的长度为3，即arr.length的值为3。

   2) 二维数组的长度包括它的行数和列数，可以使用数组名.length获取行数，使用数组名[0].length获取列数。
   例如，

   int[][] arr = {{1, 2}, {3, 4}}; //这个二维数组的行数为2，列数为2，即arr.length的值为2，arr[0].length的值为2。

   注意，这种方法只适用于所有行的列数都相同的情况，否则需要遍历整个二维数组来获取行数和列数。

继承与多态

接口

1. 成员变量必须是 public、static 和 final类型的，也就是常量，因为接口中不能包含可变状态。
2. 成员变量的值必须在定义时就确定，并且不能再被修改。
3. 在接口中定义方法时，需要满足以下要求：
   1) 方法必须是 public 和 abstract类型的，因为接口中的方法没有实现，只有定义。
   2) 方法不能包含方法体。
   3) 接口中可以定义默认方法和静态方法。默认方法是指已经有默认实现的方法，可以被实现该接口的类覆盖，也可以使用默认实现。静态方法是指不依赖于实例而存在的方法，可以通过接口名调用。

总之，在接口中定义的成员变量和方法都必须是公共的，并且不允许有实现。成员变量必须是常量，方法必须是抽象的或者默认方法或者静态方法。接口可以看做是一种约定或者协议，定义了实现该接口的类需要实现哪些方法，并且保证这些方法的调用方式和参数类型是一致的。

输入流与输出流

数据流的基本概念

  数据流是指一组有顺序的，有起点和终点的字节集合。

1. java.io包中提供了表示数据流的4个基本抽象类，分别是：
   1) InputStream
   2) OutputStream
   3) Reader
   4) Writer
2. java.io包中所有输入数据流都是从抽象类InputStream继承而来
   输入数据提供的主要数据操作方法：
   1) int read():从输入流中读取一个字节的二进制数据，当读取数据结束时，返回值为-1，需要使用close()方法关闭数据流，以免数据丢失。
   2) int read(byte[]b)将多个字节渎到数组中，填满整个数组
   3) int read(byte[]b,int off,int len)从输入流中下标为off处读取长度为len的数据，返回读取字节数。
   4) void close()关闭数据流
   5) void available() 返回可已读取的字节数（但是实际读取中可能大于这个值）
   6) long skip(long 1) 跳过数据流中制定数量的自己不读取
3. 对数流中字节的读取通常按照从头到尾书序进行，如果想要从反方向读取，则需要使用回推（Push Back）。经常用到的方法：
   1) boolean markSupported() 用于测试数据是否支持回推操作，当一个数据流支持mark()和reset()方法返回true,f否则返回false
   2) void mark(intnarkarea)用于标记数据流当前位置，并划出一个缓冲区末其大小至少为指定参数的大小
   3) void reset() 将输入流重新定位到对比此流最后调用mark方法时的位置。
4. java.io包中所有输出数据流都是从抽象类OutputStream继承而来
   1) int write():从输入流中读取一个字节的二进制数据
   2) int write(byte[]b)将多个字节渎到数组中，填满整个数组
   3) int write(byte[]b,int off,int len)从输入流中下标为off处读取长度为len的数据，返回读取字节数。
   4) void close()当结束对输出数据流的操作时应该将其关闭
   5) void flush()·刷新此输出流并强制写出所有缓冲的输出字节·

基本字节数据流

文件数据流包括FileInputStreaam与FileOutputStream其数据源与数据终点都应当是文件。通过所提供的方法可以对本机文件进行操作，但是不支持mark()和reset()方法。
如果FileOutputStream所指文件不存在，则系统会创建一个新文件。如果你只是想在当前项目目录下创建这些文件，可以将它们放在与Java源代码相同的目录中。如果你希望将它们保存在不同的目录中，你可以指定文件路径，

File inputFile = new File(“C:/myfiles/input.txt”);
File outputFile = new File(“C:/myfiles/output.txt”);

序列化

能够记录自己的状态以便将来得到复原的能力，称为对象持久性。

1. Serializable接口中没有定义任何方法，只是作为一个标记来指示实现该接口类可以进行序列化，而没有实现该接口类的对象不能长期保存期状态。
2. 对象结构表
   序列化只能保存对象的非静态成员变量，而不能保存任何成员方法和静态成员变量，并且保存的只是变量的值，对于变量的任何修饰符都不能保存。

• 写入对象文件

  Date d=new Date(); // 一个对象d
  FileOutpuStream f= new FileOutputStream("date.ser");
  // 输出文件 ObjectOutputStream s=new ObjectOutputStream(f);
  try
  s.writeObject(d);
  s.close();  //将对象d写入文件，关闭文件
  c.atch(IOExetion e)|
  e.pinStackTrace();

• 渎对象输入流

  ate d= null;
  FilelnputStream f= new FilelnputStream("date.ser ");
  ObjectInputStream s=new ObjectInpuStream(f);
  y
  d=(Date)s. readObject(d);
  s. lose();
  catch(IOException e){
  e.prinStackTace);
  System out. println("Date serialized at"+d);

基本字符流

1. Java中的字符流以字符为单位进行操作。Java中提供了两个基本的字符流类：Reader和Writer。它们的子类包括InputStreamReader、FileReader、OutputStreamWriter和FileWriter等，这些类提供了读取和写入字符的基本操作。
2. 缓冲区读者和缓冲区写者是对基本字符流的一种包装。这些类提供了缓冲功能，可以提高读取和写入数据的效率。例如，BufferedReader和BufferedWriter可以分别读取和写入一个字符或一行字符。当读取或写入大量数据时，使用缓冲区读者和缓冲区写者可以减少I/O操作，从而提高效率。
   缓冲区读者和缓冲区写者都是通过将数据缓存在内存中，从而减少访问硬盘或网络的次数，提高读写的效率。它们提供了很多便捷的方法，比如BufferedReader提供了readLine()方法，可以方便地读取一行字符。BufferedWriter提供了write()方法，可以方便地写入字符。
3. 在Java IO中，Reader和Writer是基本字符流，BufferedReader和BufferedWriter是缓冲区读者和缓冲区写者，它们提供了不同的方法。

Reader和Writer提供了以下方法：

read()：读取一个字符，返回字符的ASCII码或Unicode码。
read(char[] cbuf)：将字符读入到指定的字符数组中。
read(char[] cbuf, int off, int len)：将字符读入到指定的字符数组中的某个范围内。
skip(long n)：跳过n个字符。
ready()：返回是否已准备好读取数据。
close()：关闭流。
BufferedReader和BufferedWriter提供了以下方法：

readLine()：读取一行文本，返回一个字符串。
newLine()：写入一个换行符。
write(char[] cbuf)：将字符写入流中。
write(char[] cbuf, int off, int len)：将字符写入到指定的字符数组中的某个范围内。
write(int c)：写入单个字符。
flush()：将缓冲区内容写入目标流中。
close()：关闭流。

需要注意的是，当使用缓冲区读者和缓冲区写者时，必须使用close()方法关闭流。关闭流会将缓冲区中的数据写入目标设备，如果不关闭流，可能会导致数据丢失。

文件处理流

图形界面设计

AWT与swing

  图形用户界(GUI)面是大多数程序不可缺少的部分,java图形用户界面由各种组件构成，在java.awt与javax.swing包中定义了多种图形用户组件。Swing与AWT的最大区别在于，Swing组件的实现不包含任何本地代码，不受硬件平台限制。Swing被称为是轻量级组件，AWT被称为重量级组件.
轻量级组件与重量级组件同时使用时，重量级组件总是会显示在前面。

注意:

组件是构成图形用户界面的的基本元素。
组件可以分为容器组件和非容器组件。

容器

  容器组件是指可以包含其他组件的组件。可以分为顶层容器与一般用途容器。

Swing中提供了4种顶层容器：

1. JFrame    框架
2. JApplet    小应用程序
3. JDialog    对话框
4. JWindows    窗口

JFrame中常用的构造方法

查看代码

package 图形用户界面;

import javax.swing.*;s
import java.awt.*;

/**
 * @author 郑堃逢
 * @version 1.0
 */
public class JFrameDemo {
    public static void main(String[] args) {
        JFrame frame = new JFrame("JFrameDemo");
        //创建一个JFrame的实例，有标题
        JButton button= new JButton("Press me");
        //创建一个JButton的实例，按钮上有文字
        frame.setBounds(200 ,150,1000,500);
        //移动并调整框架大小
        frame.setBackground(Color.red); //设置背景颜色
//         frame.setLayout();  //设置布局管理器
        button.setSize(50,30);
        frame.getContentPane().add(button, BorderLayout.CENTER);
         //  返回内容窗体对象
        //   将按钮放在JFrame中央
//        frame.pack();//将JFrame设置为适当大小
        frame.setVisible(true);//显示JFrame
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//退出时关闭窗口
    }
}

内容窗格JPanel
4个顶层容器每一个都有一个内容窗格，除菜单之外顶层容器中的组件都放在内容窗格中。

一种方法是通过顶层容器的getContentPane()获得默认内容窗格

Container contentPane = frame.getComtentPane();
contentPane.add(button,BorderLayout.CENTER);

另一种方法是创建一个新的内容窗格JPanel实例.

查看代码

• 代码

因为顶层容器的布局管理器是BorderLayout，而JPanel的默认管理器是FlowLayout，因此要为JPanel设置一个BorderLayout布局管理器。

package 图形用户界面;

import javax.swing.*;
import java.awt.*;

/**
 * @author 郑堃逢
 * @version 1.0
 */
public class JFrameDemo2 {
    public static void main(String[] args) {
        JFrame frame = new JFrame("JFrameDemo2");
        JButton button= new JButton("Press me");
        JPanel contentPane = new JPanel();//创建一个JPanel实例
        contentPane.setLayout(new BorderLayout());
        // 为JPanes设置BorderLayout布局管理器
        contentPane.add(button,BorderLayout.CENTER);
        //将JBotton放在JPane中间
        frame.setContentPane(contentPane);
        //为JFrame设置新的内容窗格
        frame.pack();
        frame.setVisible(true);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    }
}

面板
面板不能独立存在必须添加到其他容器内部，尤其普通面板(JPanel)和滚动面板(JScrollPane)的用途最为广泛。

查看代码

• 代码

因为顶层容器的布局管理器是BorderLayout，而JPanel的默认管理器是FlowLayout，因此要为JPanel设置一个BorderLayout布局管理器。
jPanel.setLayout(new BorderLayout());

package 图形用户界面;

import javax.swing.*;
import java.awt.*;

/**
 * @author 郑堃逢
 * @version 1.0
 */
public class FrameWithPanel {
    public static void main(String[] args) {
        JFrame frame = new JFrame("浮生何必言");
        Container contentPane = frame.getContentPane();
        //获取内容窗格（面板）
        contentPane.setBackground(Color.GREEN);
        //为面板设置背景颜色、
        JPanel jPanel = new JPanel();
        //创建面板实例
        jPanel.setBackground(Color.YELLOW);
        //为JPanel实例设置背景颜色
        Button button = new Button("press ");
        jPanel.setLayout(new BorderLayout());
        //为JPanel设置布局管理器
        jPanel.add(button,BorderLayout.SOUTH);
        //将Button添加到JPanel实例中
//        contentPane.add(button,BorderLayout.SOUTH);
        //将JPanel实例放在JFrame的南侧
        frame.setSize(300,200);
        frame.add(jPanel);
        //将实例化的新面板添加到JFrame中可以覆盖顶层容器默认的内容窗格（面板）
        frame.setVisible(true);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);



    }
}

容器标签及按钮

查看教程

示例代码

package 图形用户界面;

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

/**
 * JButtonExample 是一个 Java Swing 应用程序，它演示了如何在窗口中创建一个带有文本字段和按钮的用户界面。
 */
public class JButtonExample extends WindowAdapter implements ActionListener {
    JFrame f; // 声明 JFrame 类型的变量 f，用于创建应用程序的窗口
    JButton b; // 声明 JButton 类型的变量 b，用于创建按钮
    JTextField tf; // 声明 JTextField 类型的变量 tf，用于创建文本字段
    int tag = 0; // 用于切换文本字段中的文本

    public static void main(String[] args) {
        JButtonExample be = new JButtonExample(); // 创建 JButtonExample 对象
        be.go(); // 调用 go 方法
    }

    /**
     * go 方法创建了应用程序的用户界面
     */
    public  void go(){
        f = new JFrame("JButton Example"); // 创建 JFrame 对象
        b = new JButton("Sample"); // 创建 JButton 对象
        b.addActionListener(this); // 添加事件监听器，监听器实现为类本身
        f.getContentPane().add(b,"South"); // 将按钮添加到窗口底部
        tf = new JTextField(); // 创建文本字段对象
        f.getContentPane().add(tf,"Center"); // 将文本字段添加到窗口中央
        f.addWindowListener(this); // 添加窗口事件监听器，监听器实现为类本身
        f.setBounds(150,100,300,150); // 设置窗口的位置和大小
        f.setVisible(true); // 显示窗口
    }

    /**
     * actionPerformed 方法用于处理按钮的单击事件
     */
    @Override
    public void actionPerformed(ActionEvent e) {
        String s1 = "you have pressed the button!"; // 按钮第一次单击时显示的文本
        String s2 = "you do another time!"; // 按钮第二次单击时显示的文本
        if (tag == 0){ // 如果标签为 0，则将文本字段的文本设置为 s1，并将标签设置为 1
            tf.setText(s1);
            tag = 1;
        }else{ // 如果标签不为 0，则将文本字段的文本设置为 s2，并将标签设置为 0
            tf.setText(s2);
            tag =0;
        }
    }

    /**
     * windowClosing 方法用于处理窗口关闭事件
     */
    @Override
    public void windowClosing(WindowEvent e) {
        System.exit(0); // 退出应用程序
    }
}

WindowListener

WindowListener 接口提供了处理与窗口相关的事件的方法。

public interface WindowListener extends EventListener {
    void windowOpened(WindowEvent e);
    void windowClosing(WindowEvent e);
    void windowClosed(WindowEvent e);
    void windowIconified(WindowEvent e);
    void windowDeiconified(WindowEvent e);
    void windowActivated(WindowEvent e);
    void windowDeactivated(WindowEvent e);
}

下面是每个方法的简要描述：

windowOpened(e:WindowEvent):void - 当窗口第一次打开时调用。
windowClosing(e:WindowEvent):void - 当窗口关闭时调用。
windowClosed(e:WindowEvent):void - 当窗口已经关闭时调用。
windowIconified(e:WindowEvent):void - 当窗口被最小化时调用。
windowDeiconified(e:WindowEvent):void - 当窗口从最小化状态恢复时调用。
windowActivated(e:WindowEvent):void - 当窗口变为活动状态时调用（即在其他窗口之上）。
windowDeactivated(e:WindowEvent):void - 当窗口失去活动状态时调用（即在其他窗口之后）。

布局管理器

在Java中，有四种主要的布局方式，分别是BorderLayout、FlowLayout、GridLayout和GridBagLayout。

1. BorderLayout 是一种将容器划分为五个区域的布局方式，它们分别是东、南、西、北和中间区域。可以通过指定组件的位置来放置组件，若未指定，则会放置到中间区域。
2. FlowLayout 是一种流式布局方式，它按照添加组件的顺序依次布局，如果一个组件放不下，则自动换行，如果设置了对齐方式，则会按照对齐方式对齐组件。
3. GridLayout 是一种网格布局方式，它将容器划分为多个单元格，每个单元格可以放置一个组件。可以通过指定行数和列数来确定单元格的数量，组件按照添加的顺序从左到右、从上到下的填充单元格。
4. CardLayout 卡片式布局管理器，它将容器中的卡片处理为一系列卡片，

事件处理

在 Java 中，事件监听器（Listener）是一种可以对组件事件做出响应的机制，常见的事件包括鼠标事件、键盘事件、窗口事件、组件事件等等。事件监听器通过在特定事件发生时调用特定方法来处理事件。

1. Java 为每种事件类型都提供了对应的监听器接口，并且提供了相应的方法来添加、删除、触发事件。
   
   
2. 事件适配器 Adapter
   事件监听模式允许为一个组件设置多个监听程序，通常的做法是在该事件的处理程序中进行编写需要的响应。Adapter适配器将Listener接口替换为抽象类，解决了调用全响应，难以分清同一事件监听次序的问题。

绘图基础

所有绘画都必须通过一个图形完成，可以直接在JFrame中显示文本信息，也可以直接在框架中绘图。在某个组件中绘图一般要为这个组件所属的子类重写print（）方法，在该重写的方法中进行绘画，但要在JCompoent子类组件中绘画，应重写printComponent()方法。
使用Graphics的基本格式：

class DrawingPanel extends JPanel {

    @Override
    protected void paintComponent(Graphics g) {

        super.paintComponent(g);//调用画笔
        Graphics2D g2d = (Graphics2D) g;//设置2d画笔

        // 绘制线段
        g2d.setColor(Color.RED);//设置画笔颜色
        g2d.drawLine(50, 50, 200, 50);}

Graphics类

1) drawLine(int x1, int y1, int x2, int y2)：绘制一条直线，起点为(x1, y1)，终点为(x2, y2)。
2) drawRect(int x, int y, int width, int height)：绘制一个矩形，左上角坐标为(x, y)，宽度为width，高度为height。
3) drawOval(int x, int y, int width, int height)：绘制一个椭圆形，左上角坐标为(x, y)，宽度为width，高度为height。
4) drawPolygon(int[] xPoints, int[] yPoints, int nPoints)：绘制一个多边形，多边形的各个点的坐标分别存储在xPoints和yPoints数组中，nPoints表示点的数量。
5) drawString(String str, int x, int y)：绘制一个字符串，字符串的左下角坐标为(x, y)。
6) setColor(Color c)：设置绘图颜色。
7) setFont(Font font)：设置绘图字体。
8) fillRect(int x, int y, int width, int height)：绘制一个填充的矩形，左上角坐标为(x, y)，宽度为width，高度为height。
9) fillOval(int x, int y, int width, int height)：绘制一个填充的椭圆形，左上角坐标为(x, y)，宽度为width，高度为height。
10) fillPolygon(int[] xPoints, int[] yPoints, int nPoints)：绘制一个填充的多边形，多边形的各个点的坐标分别存储在xPoints和yPoints数组中，nPoints表示点的数量。
11) clearRect(int x, int y, int width, int height)：清除指定区域内的内容，左上角坐标为(x, y)，宽度为width，高度为height。
12) drawImage(Image img, int x, int y, ImageObserver observer)：绘制一张图片，左上角坐标为(x, y)，observer为ImageObserver对象。
13) drawRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight)：绘制一个圆角矩形，左上角坐标为(x, y)，宽度为width，高度为height，arcWidth和arcHeight表示圆角的大小。
14) fillRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight)：绘制一个填充的圆角矩形，左上角坐标为(x, y)，宽度为width，高度为height，arcWidth和arcHeight表示圆角的大小。
drawArc(int x, int y, int width, int height, int startAngle, int arcAngle)：绘制一段圆弧，左上角坐标为(x

Graphics2D API扩展的绘图方法

raphics2D类仍然保留了 Graphics类的绘图方法，同时增加了许多新方法。
这些类主要有;Line2D线段类、RoundRectangle2D 圆角矩形类``、Ellipse2D椭圆类、Arc2D圆弧类、QuadCurve2D三次曲线类和 CubicCurve2D 三次曲线类。
1) 声明并创建线段对象，起点是（2，3），终点是（200，300）∶

Line2D line =new Line2D.Double(2,3,200,300);

2) 声明并创建矩形对象，矩形的左上角是（20，30），宽是300，高是40;

Rtectangle2Dret =new Rectangle2D.Double(20,30,80,40)

3) 声明并创建圆角矩形，左上角是（20，30），宽是130，高是 100，圆角的长轴是18，短轴是15∶

RoundRectangle2D rectRound=new RoundRectangle2D.Double(20,30,130,100,18,15);

4) 声明并创建椭圆，左上角（20，30），宽是100，高是50∶

Elipse2D llipse = new Elipse2D.Double(20,30,100,50);

5) 声明并创建圆弧，外接矩形的左上角是（8，30），宽是85，高是60，起始角是5度，终止角是90度，Arc2D.OPEN 表示是一个开弧∶

re2D arcl=new Are2D. Double(8,30,85,60,5,90,Are2D.OPEN);

6) 类似地，可以创建弓弧（Arc2D.CHORD）和饼弧（Arc2D.PIE）∶

rc2D arc2=new Arc2D.Double(20,65,90,70,0,180,Are2D. CHORD);//弓图
Arc2D are3=new Are2D.Double(40,110,50,90,0,270,Arc2D.PIE);//饼弧 

7) 在数学上，二次曲线用二阶多项式表示∶y（x）=ax2＋bx+c
绘制一条二次曲线时需要确定3个点，分别是始点、控制点和终点。方法 Double（）
中的6个参数分别是二次曲线的始点、控制点和终点。下面3条二次曲线有相同的始点和相
同的终点，控制点均不同∶

QuadCurve2D curve1 =new QuadCurver2D.Double(20,10,90,65,55,115);
QuadCurve2D curve2=new QuadCurver2D.Double(20,10,15,63,55,115);
QuadCurve2D curve3=new QuadCurver2D.Double(20,10,54,64,55, 115);

8) y（x）= ax2 ＋bx2+cx+d
绘制一条三次曲线时需要确定4个点，分别是始点、两个控制点和终点。方法 Double（）
中的8个参数分别是三次曲线的始点、两个控制点和终点。下面3条三次曲线有相同的始
点，不同的终点，而控制点不完全相同∶

CubicCurve2D curvel =new CubicCurve2D.Double(12,30,50,75,15,15,115,93);
CubicCurve2D curve2=new CubicCurve2D.Double(12,30,15,70,20,25,35,94);
CubicCurve2D curve3=new CubicCurve2D.Double(12,30,50,75,20,95,95,95);

Swing组件

组合框与列表

    组合框包括可编辑组合框与不可编辑组合框
nonEditableComboBox = new JComboBox<>(new String[]{“Item A”, “Item B”, “Item C”}); // 设置为不可编辑

组合框示例代码

import javax.swing.*;
import java.awt.*;

public class JComboBoxExample extends JFrame {
    private JComboBox<String> editableComboBox; // 可编辑组合框
    private JComboBox<String> nonEditableComboBox; // 不可编辑组合框

    public JComboBoxExample() {
        setTitle("JComboBox Example");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        // 可编辑组合框
        editableComboBox = new JComboBox<>();
        editableComboBox.setEditable(true); // 设置为可编辑
        editableComboBox.addItem("Item 1");
        editableComboBox.addItem("Item 2");
        editableComboBox.addItem("Item 3");

        // 不可编辑组合框
        nonEditableComboBox = new JComboBox<>(new String[]{"Item A", "Item B", "Item C"}); // 设置为不可编辑

        // 将组合框添加到面板
        JPanel panel = new JPanel();
        panel.setLayout(new GridLayout(2, 1));
        panel.add(editableComboBox);
        panel.add(nonEditableComboBox);

        setContentPane(panel);
        pack();
        setVisible(true);
    }

    public static void main(String[] args) {
        new JComboBoxExample();
    }
}

组合框示例代码2

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class JComboBoxTest extends JFrame implements ActionListener {
    private JComboBox<String> editableComboBox, nonEditableComboBox;
    private JButton addButton, removeButton, removeAllButton, getItemButton;

    public JComboBoxTest() {
        setTitle("JComboBox Test");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        // 创建可编辑的组合框
        editableComboBox = new JComboBox<>();
        editableComboBox.setEditable(true);
        editableComboBox.addActionListener(this);

        // 创建不可编辑的组合框
        nonEditableComboBox = new JComboBox<>();
        nonEditableComboBox.addItem("Apple");
        nonEditableComboBox.addItem("Banana");
        nonEditableComboBox.addItem("Orange");
        nonEditableComboBox.addActionListener(this);

        // 创建操作按钮
        addButton = new JButton("Add Item");
        addButton.addActionListener(this);

        removeButton = new JButton("Remove Selected Item");
        removeButton.addActionListener(this);

        removeAllButton = new JButton("Remove All Items");
        removeAllButton.addActionListener(this);

        getItemButton = new JButton("Get Selected Item");
        getItemButton.addActionListener(this);

        // 创建面板，添加组件
        JPanel panel = new JPanel(new GridLayout(5, 1));
        panel.add(editableComboBox);
        panel.add(nonEditableComboBox);
        panel.add(addButton);
        panel.add(removeButton);
        panel.add(removeAllButton);
        panel.add(getItemButton);

        // 添加面板到窗口
        add(panel);

        // 设置窗口大小并显示
        setSize(300, 200);
        setVisible(true);
    }

    // 监听器实现
    public void actionPerformed(ActionEvent e) {
        if (e.getSource() == addButton) {
            // 添加一个新的选项到可编辑的组合框中
            String newItem = JOptionPane.showInputDialog(this, "Enter a new item:");
            if (newItem != null && !newItem.isEmpty()) {
                editableComboBox.addItem(newItem);
            }
        } else if (e.getSource() == removeButton) {
            // 移除当前选中的项
            Object selectedItem = editableComboBox.getSelectedItem();
            if (selectedItem != null) {
                editableComboBox.removeItem(selectedItem);
            } else {
                JOptionPane.showMessageDialog(this, "Please select an item to remove.");
            }
        } else if (e.getSource() == removeAllButton) {
            // 移除所有项
            editableComboBox.removeAllItems();
        } else if (e.getSource() == getItemButton) {
            // 获取当前选中的项
            Object selectedItem = editableComboBox.getSelectedItem();
            if (selectedItem != null) {
                JOptionPane.showMessageDialog(this, "Selected item: " + selectedItem);
            } else {
                JOptionPane.showMessageDialog(this, "No item selected.");
            }
        } else if (e.getSource() == editableComboBox || e.getSource() == nonEditableComboBox) {
            // 当前选中项发生变化时触发
            JComboBox<String> comboBox = (JComboBox<String>) e.getSource();
            Object selectedItem = comboBox.getSelectedItem();
            if (selectedItem != null) {
                JOptionPane.showMessageDialog(this, "Selected item: " + selectedItem);
            }
        }
    }

    public static void main(String[] args) {
        new JComboBoxTest();
    }
}

文本组件

文本组件示例代码

import javax.swing.*;
import java.awt.*;

public class JTextFieldExample extends JFrame {
    private JTextField textField;
    private JPasswordField passwordField;
    private JTextArea textArea;

    public JTextFieldExample() {
        //设置窗口标题和大小
        setTitle("Text Field Example");
        setSize(400, 300);

        //创建面板
        JPanel panel = new JPanel(new GridLayout(3, 1));

        //创建文本框组件
        textField = new JTextField("This is a text field", 20);
        panel.add(textField);

        //创建密码框组件
        passwordField = new JPasswordField("password", 20);
        panel.add(passwordField);

        //创建文本区组件
        textArea = new JTextArea("This is a text area", 5, 20);
        JScrollPane scrollPane = new JScrollPane(textArea);
        panel.add(scrollPane);

        //将面板添加到窗口中
        add(panel);

        //设置窗口可见，并且当窗口关闭时退出程序
        setVisible(true);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }

    public static void main(String[] args) {
        new JTextFieldExample();
    }
}

菜单组件

菜单组件示例代码

import javax.swing.*;
import java.awt.event.*;

public class Menu extends JFrame implements ActionListener {
    private JMenuBar menuBar; //声明菜单条
    private JMenu fileMenu, editMenu;//声明菜单
    private JMenuItem newFile, openFile, saveFile, copy, paste, cut;//声明子菜单项
    private JCheckBoxMenuItem checkItem;//声明复合菜单
    private JPopupMenu popupMenu;//声明右键弹出菜单
    private JRadioButtonMenuItem radio1, radio2, radio3;//声明单元菜单

    public Menu() {
        // 设置窗口标题和大小
        setTitle("Menu Example");
        setSize(300, 200);

        // 创建菜单栏和菜单项
        menuBar = new JMenuBar();
        fileMenu = new JMenu("File");
        editMenu = new JMenu("Edit");

        // 创建菜单项
        newFile = new JMenuItem("New");
        openFile = new JMenuItem("Open");
        saveFile = new JMenuItem("Save");
        copy = new JMenuItem("Copy");
        paste = new JMenuItem("Paste");
        cut = new JMenuItem("Cut");

        // 添加菜单项到菜单
        fileMenu.add(newFile);
        fileMenu.add(openFile);
        fileMenu.add(saveFile);
        editMenu.add(copy);
        editMenu.add(paste);
        editMenu.add(cut);

        // 创建复选框菜单项
        checkItem = new JCheckBoxMenuItem("Check Item");

        // 添加菜单项到菜单
        editMenu.add(checkItem);

        // 创建弹出菜单
        popupMenu = new JPopupMenu("text");
        radio1 = new JRadioButtonMenuItem("Radio 1");
        radio2 = new JRadioButtonMenuItem("Radio 2");
        radio3 = new JRadioButtonMenuItem("Radio 3");

        // 将单选按钮组合起来
        ButtonGroup group = new ButtonGroup();
        group.add(radio1);
        group.add(radio2);
        group.add(radio3);

        // 将单选按钮添加到弹出菜单
        popupMenu.add(radio1);
        popupMenu.add(radio2);
        popupMenu.add(radio3);

        // 将菜单添加到菜单栏
        menuBar.add(fileMenu);
        menuBar.add(editMenu);

        // 将菜单栏添加到窗口
        setJMenuBar(menuBar);

        // 为弹出菜单添加事件监听器
        addMouseListener(new MouseAdapter() {
            public void mousePressed(MouseEvent e) {
                showPopup(e);
            }

            public void mouseReleased(MouseEvent e) {
                showPopup(e);
            }

            private void showPopup(MouseEvent e) {
                if (e.isPopupTrigger()) {
                    popupMenu.show(e.getComponent(), e.getX(), e.getY());
                }
            }
        });

        // 为菜单项添加事件监听器
        newFile.addActionListener(this);
        openFile.addActionListener(this);
        saveFile.addActionListener(this);
        copy.addActionListener(this);
        paste.addActionListener(this);
        cut.addActionListener(this);
        checkItem.addActionListener(this);
        radio1.addActionListener(this);
        radio2.addActionListener(this);
        radio3.addActionListener(this);

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

    public void actionPerformed(ActionEvent e) {
        // 获取事件的命令字符串并弹出消息对话框显示
        String command = e.getActionCommand();
        JOptionPane.showMessageDialog(null, command);
    }

    public static void main(String[] args) {
        new Menu();
    }
}

对话框

标准对话框

标准对话框是Java Swing提供的JOptionPane类，其中包括4种主要类型：

1. 消息对话框(MessageDialog)：用于向用户显示一条信息或者询问一个简单的问题。消息对话框通常包括一个或多个按钮，用户可以选择按下其中的一个按钮来做出反应。
2. 确认对话框(ConfirmationDialog)：与消息对话框类似，但通常用于向用户确认某个重要的操作。确认对话框通常包括两个或三个按钮，例如“确定”、“取消”、“是”、“否”。
3. 输入对话框(InputDialog)：用于接收用户输入的数据，例如用户的姓名、地址或密码等。输入对话框通常包括一个或多个文本框和一个或多个按钮。
4. 选项对话框(OptionDialog)：显示选项，要求用户尽行选择

JDialog的基本常用方法介绍

构造方法
JDialog()
创建一个没有父窗口的 JDialog，具有默认的模态行为和空字符串标题。
JDialog(Dialog owner)
创建一个具有指定所有者和默认模态行为的 JDialog，使用空字符串作为标题。
JDialog(Dialog owner, boolean modal)
创建一个具有指定所有者和指定模态性的 JDialog，使用空字符串作为标题。
JDialog(Dialog owner, String title)
创建一个具有指定所有者和默认模态行为的 JDialog，具有指定的标题。
JDialog(Dialog owner, String title, boolean modal)
创建具有指定所有者、指定模态性和指定标题的 JDialog。
JDialog(Frame owner)
创建一个具有指定所有者和默认模态行为的 JDialog，使用空字符串作为标题。
JDialog(Frame owner, boolean modal)
创建一个具有指定所有者和指定模态性的 JDialog，使用空字符串作为标题。
JDialog(Frame owner, String title)
创建一个具有指定所有者和默认模态行为的 JDialog，具有指定的标题。
JDialog(Frame owner, String title, boolean modal)
创建具有指定所有者、指定模态性和指定标题的 JDialog。
JDialog(Window owner)
创建一个具有指定所有者和默认模态行为的 JDialog，使用空字符串作为标题。
JDialog(Window owner, ModalityType modalityType)
创建具有指定所有者和指定模态类型的 JDialog，使用空字符串作为标题。
JDialog(Window owner, String title)
创建一个具有指定所有者和默认模态行为的 JDialog，具有指定的标题。
JDialog(Window owner, String title, ModalityType modalityType)
创建具有指定所有者、指定模态类型和指定标题的 JDialog。
常用方法
setVisible(boolean visible)
设置 JDialog 的可见性。
setModalityType(ModalityType modalityType)
设置 JDialog 的模态类型。
setTitle(String title)
设置 JDialog 的标题。
setDefaultCloseOperation(int operation)
设置关闭 JDialog 时的操作。
setLocationRelativeTo(Component c)
设置 JDialog 的位置相对于指定组件的位置。
add(Component comp)
将指定组件添加到 JDialog 中。
pack()
调整 JDialog 的大小，以适应其内容。
dispose()
释放 JDialog 使用的所有资源，并关闭 JDialog。
getContentPane()
返回 JDialog 的内容面板。
getOwner()
返回 JDialog 的所有者。
getRootPane()
返回 JDialog 的根面板。
setResizable(boolean resizable)
设置 JDialog 是否可以调整大小。
setSize(int width, int height)
设置 JDialog 的大小。
setLocation(int x, int y)
设置 JDialog 的位置。
setModal(boolean modal)
设置 JDialog 是否为模态对话框。
setDefaultCloseOperation(int operation)
设置 JDialog 关闭时的操作。

对话框示例代码

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.io.*;

public class JDdialog extends JFrame implements ActionListener {
    private JButton standardButton, fileButton; // 声明标准对话框和文件对话框按钮
    private JLabel standardLabel, fileLabel; // 声明标准对话框和文件对话框标签

    public JDdialog() {
        setTitle("Dialog Example"); // 设置窗口标题
        setSize(300, 200); // 设置窗口大小
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // 设置窗口关闭操作

        // 创建面板
        JPanel panel = new JPanel();
        panel.setLayout(new GridLayout(2, 2)); // 设置面板布局为网格布局

        // 创建标准对话框按钮和标签
        standardButton = new JButton("Standard Dialog");
        standardButton.addActionListener(this); // 给按钮添加事件监听器
        standardLabel = new JLabel("No dialog has been opened yet.");

        // 创建文件对话框按钮和标签
        fileButton = new JButton("File Dialog");
        fileButton.addActionListener(this); // 给按钮添加事件监听器
        fileLabel = new JLabel("No file has been selected yet.");

        // 将组件添加到面板
        panel.add(standardButton);
        panel.add(standardLabel);
        panel.add(fileButton);
        panel.add(fileLabel);

        // 将面板添加到窗口
        add(panel);

        setVisible(true);
    }

    public void actionPerformed(ActionEvent e) {
        if (e.getSource() == standardButton) {
            // 显示标准对话框
            String[] options = {"Option 1", "Option 2", "Option 3"};
            int choice = JOptionPane.showOptionDialog(this, "Choose an option.", "Standard Dialog", JOptionPane.YES_NO_CANCEL_OPTION, JOptionPane.PLAIN_MESSAGE, null, options, options[0]);
            if (choice != JOptionPane.CLOSED_OPTION) {
                standardLabel.setText("You selected " + options[choice] + ".");
            }
        } else if (e.getSource() == fileButton) {
            // 显示文件对话框
            JFileChooser fileChooser = new JFileChooser();
            int result = fileChooser.showOpenDialog(this);
            if (result == JFileChooser.APPROVE_OPTION) {
                File selectedFile = fileChooser.getSelectedFile();
                fileLabel.setText("You selected " + selectedFile.getName() + ".");
            }
        }
    }

    public static void main(String[] args) {
        new JDdialog();
    }
}

多线程

线程和多线程

创建线程

线程的基本控制

线程启动

API中提供了以下有关线程的操作方法;

• start（）;启动线程对象，让线程从新建状态转为就绪状态。
• run（）;用来定义线程对象被调度之后所执行的操作，用户必须重写run（）方法。
• yield（）∶强制终止线程的执行。
• isAlive（）∶测试当前线程是否在活动。
• sleep（int millsecond）∶使线程休眠一段时间，时间长短由 millsecond决定，单位为 ms。
• void wait（）∶使线程处于等待状态。
• wait（和 notify（）/notifyAll（））
  wait（）方法导致当前的线程签待，直到其他线程调用此对象的 notify（）方法或 notifyAll（） 方法—才能唤醒线程。

线程调度

线程调度方式：抢占式
优先级策略：

• 优先级高先执行，优先级低后执行
• 每个线程创建时都会被自动分配一个优先级，默认时，继承父类优先级
• 任务紧急的线程优先级较高
• 通优先级的线程按“先进先出”的调度原则

Thread类有3个与线程优先级有关的静态量，分别如下。
· MAX_PRIORITY∶最高优先级，值为10。
· MIN_PRIORITY;最低优先级，值为1。
· NORM_PRIORITY∶默认优先级，值为5。

线程的互斥

线程的同步