Java从入门到精通（12~21章）

运行结果

运行结果

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class HashMapTest {
 
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  Map<String,String>map=new HashMap<>();
  map.put("ISBN-978654","JAVA从入门到精通");
  map.put("ISBN-978361","Android从入门到精通");
  map.put("ISBN-978893","21天学Android");
  map.put("ISBN-978756","21天学JAVA");
  Set<String>set=map.keySet();
  Iterator<String>it=set.iterator();
  System.out.println("key值：");
  while (it.hasNext()) {
   System.out.print(it.next()+"  ");
  }
  Collection<String>coll=map.values();
  it=coll.iterator();
  System.out.println("\nvalue值：");
  while(it.hasNext()) {
   System.out.print(it.next()+"  ");
   }
  }
 
}

1、方法名和参数：在引用静态方法时，你需要提供方法的名称以及所需要的任何参数。例如，如果你有一个名为greet的静态方法，它需要一个字符串和一个整数作为参数，你可以这样引用它：ClassName.greet(参数1, 参数2)。
2、作用域：你可以在任何地方引用静态方法，包括在类的内部，其他类的内部，或者作为表达式的一部分。
3、访问权限：如果静态方法是私有的，那么你不能从类的外部访问它。如果它是受保护的，那么你可以从同一个包中的类或者其他包中的子类访问它。如果它是默认的（即没有修饰符），那么你可以从同一个包中的类访问它。
4、重载：你可以在一个类中拥有多个同名的静态方法，只要他们的参数列表不同（即形成了重载）。在引用时，Java会根据你提供的参数类型和数量来确定应该调用哪个方法。
5、泛型：虽然静态方法可以使用泛型，但是他们在引用时并不需要提供具体的类型参数。例如，如果你有一个名为calculate的静态方法，它需要一个List作为参数，你可以这样调用它：ClassName.calculate(myList)，而不必提供类型参数。
6、访问静态方法的方式：你可以通过类名来访问静态方法，或者通过实例来访问（虽然这有些混淆，因为通常我们通过实例来调用实例方法，而不是静态方法）。例如，ClassName.methodName()或者instanceName.methodName()。
7、链式调用：如果一个静态方法的返回值是返回类型的实例，那么我们可以连续地调用这个实例的方法。例如，如果add方法返回一个Calculator实例，并且这个实例有一个calculate方法，那么我们可以这样使用：ClassName.add(1, 2).calculate()。

使用stream流将List集合中的数据添加到map集合中，姓名做键，年龄做值。

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

public class 方法 {
    public static void main(String[] args) {
        /*
            总结方法：
            froEach方法，遍历
            count：统计
            toArray：将流中数据转换为指定类型数组进行返回。
            collect：将流中数据收集进一个集合进行返回
         */
        List<String> list=new ArrayList<>();
        Collections.addAll(list,"张无忌-男-18","wuhu-男-20","呀呼-女-20");

        // 匿名内部类实现stream流
        Map<String, String> user = list.stream().collect(Collectors.toMap(new Function<String, String>() {

                                                                                 @Override
                                                                                 public String apply(String s) {
                                                                                     return s.split("-")[0];
                                                                                 }
                                                                             }
                        , new Function<String, String>() {
                            @Override
                            public String apply(String s) {
                                return s.split("-")[2];
                            }
                        }
                )
        );

        // lambda实现stream流
        Map<String, String> user2 = list.stream().collect(Collectors.toMap(o1 -> o1.split("-")[0], o2 -> o2.split("-")[2]));

        user.forEach((o1,o2) -> System.out.println(o1+","+o2));
        System.out.println(user2);
    }
}

1、FileInputStream：用于从文件中读取字节数据。
2、FileOutputStream：用于向文件中写入字节数据。
3、BufferedInputStream：用于从文件中读取数据，并将数据缓存在内存中，以提高读取效率。
4、BufferedOutputStream：用于向文件中写入数据，并将数据缓存在内存中，以提高写入效率。
5、DataInputStream：用于从文件中读取基本数据类型，如int、float、double等。
6、DataOutputStream：用于向文件中写入基本数据类型，如int、float、double等。

1、创建输入输出流对象：使用上述类之一的构造函数创建输入输出流对象。例如，使用FileInputStream类创建文件输入流对象，使用FileOutputStream类创建文件输出流对象。
2、打开连接：使用open()方法打开文件，建立与文件的连接。
3、读取/写入数据：使用输入输出流提供的方法读取或写入数据。例如，使用read()方法从输入流中读取字节数据，使用write()方法向输出流中写入字节数据。
4、关闭连接：使用close()方法关闭文件，断开与文件的连接。

import java.io.FileInputStream;  
import java.io.IOException;  
  
public class FileReadingExample {  
    public static void main(String[] args) {  
        try (FileInputStream fileInputStream = new FileInputStream("path/to/file.txt")) {  
            int data;  
            while ((data = fileInputStream.read()) != -1) {  
                System.out.print((char) data);  
            }  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  
}

import java.io.FileOutputStream;  
import java.io.IOException;  
  
public class FileWritingExample {  
    public static void main(String[] args) {  
        try (FileOutputStream fileOutputStream = new FileOutputStream("path/to/file.txt")) {  
            String data = "Hello, World!";  
            fileOutputStream.write(data.getBytes());  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  
}

FileReader：用于从文件中读取字符数据。
FileWriter：用于向文件中写入字符数据。
BufferedReader：用于从文件中读取数据，并将数据缓存在内存中，以提高读取效率。
BufferedWriter：用于向文件中写入数据，并将数据缓存在内存中，以提高写入效率。
BufferedWriter：用于向文件中写入数据，并将数据缓存在内存中，以提高写入效率。

1、创建输入输出流对象：使用上述类之一的构造函数创建输入输出流对象。例如，使用FileReader类创建文件输入流对象，使用FileWriter类创建文件输出流对象。
2、打开连接：使用open()方法打开文件，建立与文件的连接。
3、读取/写入数据：使用输入输出流提供的方法读取或写入数据。例如，使用read()方法从输入流中读取字符数据，使用write()方法向输出流中写入字符数据。
4、关闭连接：使用close()方法关闭文件，断开与文件的连接。

import java.io.FileReader;  
import java.io.IOException;  
  
public class FileReadingExample {  
    public static void main(String[] args) {  
        try (FileReader fileReader = new FileReader("path/to/file.txt")) {  
            int data;  
            while ((data = fileReader.read()) != -1) {  
                System.out.print((char) data);  
            }  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  
}

import java.io.FileWriter;  
import java.io.IOException;  
  
public class FileWritingExample {  
    public static void main(String[] args) {  
        try (FileWriter fileWriter = new FileWriter("path/to/file.txt")) {  
            String data = "Hello, World!";  
            fileWriter.write(data);  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  
}

Class类对象只有三种可以获取方式，因为Class中的构造方法被private修饰了，所以我们无法通过构造方法来创建Class类的对象。

通过这个静态方法我们可以获取某个类的Class对象，全类名指的是这个类在什么位置。

例如：创建test包下的student类的Class对象。

public class demo_1 {
    public static void main(String[] args) throws ClassNotFoundException {
        Class claz = Class.forName("test.student");
    }
}

Class studentClass = student.class;

Object类是所有类的父类，在Object类中有一个方法：getClass方法，这个方法可以获取一个对应的Class对象。所以我们可以使用这个方法获取。

访问构造方法
访问成员变量
访问成员方法

获取构造方法的常用方法

示例

访问成员变量是使用Field类来进行的。

获取成员变量的常用方法：

FIeld类中常用方法
对获取出来的成员变量进行操作的话，需要使用Field类，以下是常用的方法，具体详见Java1.8api文档。

示例

访问某个类的成员方法是使用Method对象来进行操作的。

常用的方法有下图所示，具体详见Java1.8Api文档

获取Method对象常用的方法有：

示例：

@Override  // 这是一个注解，表示覆盖从父类继承的方法
public void myMethod() {  
    // method body  
}

你需要将MySQL的JDBC驱动包含在你的项目中。一般来说，这可以通过将相关的jar文件添加到项目的类路径中来完成。这个jar文件通常被称为mysql-connector-java-version-bin.jar，其中“version”是你的JDBC驱动的版本号。

在你的Java代码中，你需要在文件的顶部导入相关的包。这些包包括java.sql包和MySQL的JDBC驱动包。

import java.sql.*;  
import com.mysql.jdbc.*;

接下来，你需要创建一个连接到你的MySQL数据库的连接对象。这需要你的数据库的URL，用户名和密码。下面是一个例子：

String url = "jdbc:mysql://localhost:3306/mydatabase";  
String user = "root";  
String password = "mypassword";  
Connection conn = DriverManager.getConnection(url, user, password);

在上面的例子中，“localhost:3306”是你的MySQL服务器的地址和端口（通常为3306），“mydatabase”是你的数据库名，“root”和“mypassword”是你的用户名和密码。

一但设置了连接对象，你就可以创建一个Statement对象，然后使用它来执行SQL查询

例如：

在执行查询后，你需要处理查询的结果，并且清理你的资源。下面是一个例子：

在这个例子中，你需要替换"column1"和"column2"等为你的列的名字。在处理完结果后，你需要关闭ResultSet、Statement和Connection对象。这可以确保你的资源被正确地清理，防止内存泄漏和其他问题。

1、JFrame是一个顶级窗口，必须添加内容才能显示窗口。
2、JFrame可以添加各种组件，如按钮、文本框、标签等。
3、JFrame具有默认的关闭操作，可以关闭窗口。
4、JFrame可以设置窗口大小、标题等属性。

1、setTitle(String title)：设置窗口标题。
2、setDefaultCloseOperation(int operation)：设置窗口关闭操作，例如JFrame.EXIT_ON_CLOSE（关闭时退出程序）、JFrame.DISPOSE_ON_CLOSE（关闭时结束程序并释放窗口）等。
3、setBounds(int x, int y, int width, int height)：设置窗口大小和位置。
4、add(Component component)：添加组件到窗口中。
5、remove(Component component)：从窗口中移除组件。
6、setLayout(LayoutManager manager)：设置窗口的布局管理器。
7、getContentPane()：获取内容窗格。
8、getRootPane()：获取根窗格。
9、getWindowDecorationStyle()：获取窗口装饰样式。
10、setWindowDecorationStyle(int style)：设置窗口装饰样式。

public class Main {
    public static void main(String[] args) {
        JFrame jf = new JFrame("第一个窗体");
        jf.setSize(500,500);  // 设置大小
        jf.setAlwaysOnTop(true);          // 顶层显示方法
        jf.setLocationRelativeTo(null);   // 将窗口位置设置为屏幕中心
        jf.setDefaultCloseOperation(jf.EXIT_ON_CLOSE);  //设置关闭模式，关闭模式设置为关闭窗体时释放窗体资源并结束程序
        jf.setVisible(true);            //设置为显示
    }
}

1、可以创建模式对话框和非模式对话框。模式对话框会阻塞用户对其他窗口的访问，直到用户关闭该对话框或通过操作按钮取消对话框。非模式对话框不会阻塞用户对其他窗口的访问。
2、可以添加各种组件，如按钮、文本框、标签等。
3、可以设置对话框的标题、大小、位置等属性。
4、对话框默认情况下没有关闭操作，需要手动添加关闭操作。

1、setTitle(String title)：设置对话框标题。
2、setModal(boolean modal)：设置对话框是否为模式对话框。
3、setBounds(int x, int y, int width, int height)：设置对话框大小和位置。
4、add(Component component)：添加组件到对话框中。
5、remove(Component component)：从对话框中移除组件
6、setLayout(LayoutManager manager)：设置对话框的布局管理器。
7、getContentPane()：获取内容窗格。
8、getRootPane()：获取根窗格。
9、getWindowDecorationStyle()：获取窗口装饰样式。
10、setWindowDecorationStyle(int style)：设置窗口装饰样式。

import javax.swing.*;  
import java.awt.*;  
import java.awt.event.*;  
  
public class DialogExample {  
    private JFrame frame;  
    private JButton button;  
    private JDialog dialog;  
    private JTextField textField;  
  
    public DialogExample() {  
        // 创建主窗口  
        frame = new JFrame("Dialog Example");  
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  // 设置关闭模式
        frame.setSize(300, 200);   // 设置大小
        frame.setLayout(new BorderLayout());  
  
        // 创建按钮并添加到主窗口中  
        button = new JButton("Show Dialog");  
        frame.add(button, BorderLayout.NORTH);  
  
        // 创建对话框  
        dialog = new JDialog();  
        dialog.setTitle("Input Dialog");  
        dialog.setModal(true); // 设置为模式对话框  
        dialog.setSize(300, 200);  
        dialog.setLayout(new BorderLayout());  
  
        // 创建文本框并添加到对话框中  
        textField = new JTextField(20);  
        dialog.add(textField, BorderLayout.CENTER);  
  
        // 显示主窗口  
        frame.setVisible(true);  
    }  
  
    public static void main(String[] args) {  
        // 创建示例对象  
        DialogExample example = new DialogExample();  
    }  
}

在以上示例中，我们创建了一个主窗口（JFrame），并在其中添加了一个按钮（JButton）。当用户点击按钮时，会弹出一个模态对话框（JDialog），其中包含一个文本框（JTextField）。用户可以在文本框中输入内容，然后关闭对话框。在关闭对话框后，用户可以继续操作主窗口。

1、showMessageDialog(Component parentComponent, String message)：显示一个包含指定消息的对话框。
2、showInputDialog(Component parentComponent, String prompt, String title, int messageType)：显示一个包含输入框的对话框，用于获取用户输入。
3、showConfirmDialog(Component parentComponent, String message, String title, int optionType)：显示一个确认对话框，用于让用户选择是否继续操作。

import javax.swing.*;  
import java.awt.*;  
  
public class OptionPaneExample {  
    public static void main(String[] args) {  
        // 创建JFrame窗口  
        JFrame frame = new JFrame("OptionPane Example");  
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
        frame.setSize(300, 200);  
        frame.setLayout(new BorderLayout());  
  
        // 添加按钮并添加事件监听器  
        JButton button = new JButton("Show Message Dialog");  
        button.addActionListener(new ActionListener() {  
            public void actionPerformed(ActionEvent e) {  
                // 显示消息对话框  
                JOptionPane.showMessageDialog(frame, "Hello World!");  
            }  
        });  
        frame.add(button, BorderLayout.NORTH);  
  
        // 显示窗口  
        frame.setVisible(true);  
    }  
}

在以上示例中，我们创建了一个JFrame窗口，并在其中添加了一个按钮。当用户点击按钮时，会弹出一个包含"Hello World!"消息的消息对话框。

import javax.swing.*;
import java.awt.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        JFrame frame = new JFrame("Null Layout Example");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(400, 300);
        frame.setLayout(null); // 设置布局为null绝对布局

        // 添加组件并设置位置和大小
        JButton button1 = new JButton("按钮 1");
        button1.setBounds(10, 10, 80, 30);
        frame.add(button1);

        JButton button2 = new JButton("按钮 2");
        button2.setBounds(100, 10, 80, 30);
        frame.add(button2);

        JButton button3 = new JButton("按钮 3");
        button3.setBounds(190, 10, 80, 30);
        frame.add(button3);

        // 显示窗口
        frame.setVisible(true);
    }
}

import javax.swing.*;
import java.awt.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        JFrame frame = new JFrame("FlowLayout Example");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(300, 200);

        // 创建FlowLayout布局管理器并设置间距  
        FlowLayout layout = new FlowLayout();
        layout.setHgap(10);
        layout.setVgap(10);
        frame.setLayout(layout);

        // 添加组件并设置位置和大小  
        JButton button1 = new JButton("Button 1");
        frame.add(button1); // 直接添加到frame中，布局管理器会根据组件的尺寸和排列顺序自动调整位置和大小  

        JButton button2 = new JButton("Button 2");
        frame.add(button2); // 直接添加到frame中，布局管理器会根据组件的尺寸和排列顺序自动调整位置和大小  

        JButton button3 = new JButton("Button 3");
        frame.add(button3); // 直接添加到frame中，布局管理器会根据组件的尺寸和排列顺序自动调整位置和大小  

        // 显示窗口  
        frame.setVisible(true);
    }
}

1、每个区域只能包含一个组件。
2、组件不能覆盖多个区域。
3、组件的添加顺序不重要。
4、组件的尺寸由其自身的大小和容器的大小决定。
5、可以使用组件的setBounds方法设置组件的位置和大小。

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

public class Main {
    public static void main(String[] args) {
        JFrame frame = new JFrame("BorderLayout Example");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(400, 300);
        frame.setLayout(new BorderLayout()); // 设置布局为BorderLayout

        // 添加组件并设置位置和大小
        JButton button1 = new JButton("北");
        button1.setBounds(10, 10, 80, 30); // 设置位置和大小
        frame.add(button1, BorderLayout.NORTH); // 将按钮添加到NORTH区域

        JButton button2 = new JButton("中");
        button2.setBounds(10, 50, 80, 30); // 设置位置和大小
        frame.add(button2, BorderLayout.CENTER); // 将按钮添加到CENTER区域

        JButton button3 = new JButton("南");
        button3.setBounds(10, 90, 80, 30); // 设置位置和大小
        frame.add(button3, BorderLayout.SOUTH); // 将按钮添加到SOUTH区域

        JButton button4 = new JButton("东");
        button4.setBounds(100, 10, 80, 30); // 设置位置和大小
        frame.add(button4, BorderLayout.EAST); // 将按钮添加到EAST区域

        JButton button5 = new JButton("西");
        button5.setBounds(190, 10, 80, 30); // 设置位置和大小
        frame.add(button5, BorderLayout.WEST); // 将按钮添加到WEST区域

        // 显示窗口
        frame.setVisible(true);
    }
}

public GridLayout(int rows， int columns)
public GridLayout(int rows， int columns ，int hortizGap,int vertGap)

import javax.swing.*;
import java.awt.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main extends JFrame {
    public Main(){
        Container c = getContentPane();//获取主容器
        //创建文本区域组件，文本域默认大小为 20 行、50 列
        JTextArea ta = new JTextArea(20,50);
        //创建 JScrollPane 滚动面板，并将文本域放到滚动面板中
        JScrollPane sp = new JScrollPane(ta);
        c.add(sp);//将该面板添加到主容器中
        setTitle("带滚动条的文字编译器");
        setSize(400,200);
        setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
        
    }
    public static void main(String[] args) {
        Main p = new Main();
        p.setVisible(true);
    }

}

运行结果：

import javax.swing.*;
import java.awt.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main extends JFrame {
    public Main(){
        Container container=getContentPane();//获取主容器
        JLabel jl=new JLabel("这是一个 JFrame 窗体");//创建标签
        container.add(jl);
        setSize(200,100);//设置窗体大小
        setVisible(true);//设置窗体可见
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);//关闭窗体则停止程序
    }
    public static void main(String[] args) {
        Main p = new Main();
    }

}

import javax.swing.*;
import java.awt.*;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main extends JFrame {
    public Main(){
        Container container=getContentPane();
        JLabel jl=new JLabel("这是一个JFrame窗体");//创建标签
        URL url=Main.class.getResource("img\cell.png");//获取图片所在的URL
        Icon icon =new ImageIcon(url);//获取图片的icon对象
        jl.setIcon(icon);//为标签设置图片
        jl.setHorizontalAlignment(SwingConstants.CENTER);//设置文字放置在标签中间
        jl.setOpaque(true);//设置标签为不透明状态
        container.add(jl);//将标签添加到容器中
        setSize(300,200);//设置窗体大小
        setVisible(true);//使窗体可见
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);//关闭窗体则停止程序
        
    }
    public static void main(String[] args) {
        Main p = new Main();
    }

}

1、setText(String text)：设置按钮上显示的文本。
2、setMnemonic(char mnemonic)：设置按钮的快捷键。
3、setActionListener(ActionListener listener)：设置按钮的监听器，当按钮被点击时触发。
4、setBackground(Color color)：设置按钮的背景色。
5、setForeground(Color color)：设置按钮上显示的文本的颜色。
6、setFont(Font font)：设置按钮上显示的文本的字体。
7、setBorder(Border border)：设置按钮的边框。
8、setRolloverIcon(Icon icon)：设置按钮在鼠标指针滑过时显示的图标。
9、setDisabledIcon(Icon icon)：设置按钮被禁用时显示的图标。
10、setDisabledSelectedIcon(Icon icon)：设置按钮被禁用且被选中时显示的图标。

运行结果：

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.net.URL;

public class Main extends JFrame {
    public Main(){
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setTitle("单选按钮的使用");
        setBounds(100,100,240,120);
        getContentPane().setLayout(null);//设置绝对布局
        JLabel lbINewLabel = new JLabel("请选择性别:");
        //设置绝对布局
        lbINewLabel.setBounds(5, 5,120,15);
        getContentPane().add(lbINewLabel);
        JRadioButton rbtnNormal =new JRadioButton("男");
        rbtnNormal.setSelected(true);
        rbtnNormal.setBounds(40, 30, 75,22);
        getContentPane().add(rbtnNormal);
        JRadioButton rbtnPwd = new JRadioButton("女");
        rbtnPwd.setBounds(120,30,75,22);
        getContentPane().add(rbtnPwd);
        ButtonGroup group = new ButtonGroup(); //创建按钮组，把交互面板中的单选按钮添加到按钮组中
        group.add(rbtnNormal);
        group.add(rbtnPwd);

    }
    public static void main(String[] args) {
        Main p = new Main();
        p.setVisible(true);
    }

}

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.net.URL;

public class Main extends JFrame {
    public Main(){
        setBounds(100,100,170,110);//窗口坐标和大小
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        Container c=getContentPane();//获取主容器
        c.setLayout(new FlowLayout());//容器使用流布局
        JCheckBox c1=new JCheckBox("1");//创建复选框
        JCheckBox c2=new JCheckBox("2");
        JCheckBox c3=new JCheckBox("3");
        c.add(c1);//容器添加复选框
        c.add(c2);
        c.add(c3);
        JButton btn=new JButton("打印");//创建打印按钮
        btn.addActionListener(new ActionListener(){//打印按钮动作事件
            public void actionPerformed(ActionEvent e) {
                //在控制台分别输出三个复选框的选中状态
                System.out.println(c1.getText()+"按钮选中状态："+c1.isSelected());
                System.out.println(c2.getText()+"按钮选中状态："+c2.isSelected());
                System.out.println(c3.getText()+"按钮选中状态："+c3.isSelected());

            }
        });
        c.add(btn);//容器添加打印按钮
        setVisible(true);

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

}

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.net.URL;

public class Main extends JFrame {
    public Main(){
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setTitle("下拉列表框的使用");
        setBounds(100,100,317,147);
        getContentPane().setLayout(null);//设置绝对布局
        JLabel lblNewLabel = new JLabel("请选择证件:");
        lblNewLabel.setBounds(28,14,80,15);
        getContentPane().add(lblNewLabel);
        JComboBox<String>comboBox = new JComboBox<String>();//创建一个下拉列表框
        comboBox.setBounds(110,11,80,21);  //设置坐标
        comboBox.addItem("身份证");    //为下拉列表中添加项
        comboBox.addItem("军人证");
        comboBox.addItem("学生证");
        comboBox.addItem("工作证");
        comboBox.setEditable(true);   //将下拉列表添加到容器中
        getContentPane().add(comboBox);
        JButton btnNewButton= new JButton("确定");
        btnNewButton.setBounds(200,10,67,23);
        getContentPane().add(btnNewButton);
        btnNewButton.addActionListener(new ActionListener() { //为按钮添加监听事件

            @Override
            public void actionPerformed(ActionEvent e) {
                // TODO Auto-generated method stub
                lblNewLabel.setText("你的选择的是:"+ comboBox.getSelectedItem());
            }

        });

        setVisible(true);

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

}

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.net.URL;

public class Main extends JFrame {
    public Main(){
        Container cp=getContentPane();//获取窗体主容器

        cp.setLayout(null);//容器使用绝对布局
        //创建字符串数组保存列表中的数据
        String[]contents= {"列表1","列表2","列表3","列表4","列表5","列表6"};
        JList<String> jl=new JList<>(contents);//创建列表框并将字符串数组作为构造参数
        JScrollPane js=new JScrollPane(jl);//将列表框放入滚动面板
        js.setBounds(10, 10, 100, 109);//设定滚动面板的坐标和大小
        cp.add(js);
        JTextArea area=new JTextArea();//创建文本域
        JScrollPane scrollPane=new JScrollPane(area);//将文本域放入滚动面板
        scrollPane.setBounds(118,10,73,80);//设定滚动面板的坐标和大小
        cp.add(scrollPane);
        JButton bthNewButton=new JButton("确认");//创建确定按钮
        bthNewButton.setBounds(120,96,71,23);//设定按钮的坐标和大小
        cp.add(bthNewButton);
        bthNewButton.addActionListener(new ActionListener() {//添加按钮事件
            public void actionPerformed(ActionEvent e) {
                //获取列表中选中的元素返回JAVA.util.list类型
                java.util.List<String> values=jl.getSelectedValuesList();
                area.setText("");//清空文本域
                for(String value : values) {
                    area.append(value+"\n");//在文本域循环追加列表框中选中的值
                }
            }
        });
        setTitle("在这个窗口中使用了列表框");
        setSize(300,200);
        setVisible(true);
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);


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

}

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.net.URL;

public class Main extends JFrame {
    public Main() {
        Container c = getContentPane();//获取窗体主容器


        c.setLayout(new FlowLayout());
        JTextField jt = new JTextField("请点击清除按钮");//设定文本框初始值
        jt.setColumns(20);//设置文本框长度
        jt.setFont(new Font("宋体", Font.PLAIN, 20));//设置字体
        JButton jb = new JButton("清除");
        jt.addActionListener(new ActionListener() {//为文本框添加回车事件
            public void actionPerformed(ActionEvent arf0) {
                jt.setText("触发事件");//设置文本框中的值
            }
        });
        jt.addActionListener(new ActionListener() {// 为按钮添加事件
            public void actionPerformed(ActionEvent arf0) {
                System.out.println(jt.getText());//输出当前文本框的值
                jt.setText("");//将文本框置空
                jt.requestFocus();// 焦点回到文本框
            }
        });
        c.add(jt);//窗体容器添加文本框
        c.add(jb);//窗体添加按钮
        setBounds(100, 100, 250, 110);
        setVisible(true);
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    }

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

}

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.net.URL;

public class Main extends JFrame {
    public Main() {
        setSize(200,100);
        setTitle("定义自动换行的文本域");
        setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
        Container cp = getContentPane(); //获取窗体主容器
        //创建一个文本内容为“文本域”、行高和列宽均为 6 的文本域
        JTextArea jt = new JTextArea("文本域",6,6);
        jt.setLineWrap(true); //可以自动换行
        cp.add(jt);
        setVisible(true);
    }

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

}

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.net.URL;

public class Main extends JFrame {
    public Main() {
        setTitle("创建可以滚动的表格");
        setBounds(100,100,240,150);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        String[] columnNames = {"A","B"}; //定义表格列名数
        //定义表格数据数组
        String[][] tableValues ={{"A1","B1"},{"A2","B2"},{"A3","B3"},
                {"A4","B4"},{"A5","B5"}};
        //创建指定列名和数据的表格
        JTable table = new JTable(tableValues, columnNames);
        //创建显示表格的滚动面板
        JScrollPane scrollPane = new JScrollPane(table);
        //将滚动面板添加到边界布局的中间
        getContentPane().add(scrollPane, BorderLayout.CENTER);

        setVisible(true);
    }

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

}

import javax.swing.*;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.TableRowSorter;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.net.URL;

public class Main extends JFrame {
    public Main() {
        setTitle ("表演模型与表格");
        setBounds(100,100,240,150);//窗体宽高
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        JScrollPane scrollPane=new JScrollPane();
        getContentPane().add(scrollPane,BorderLayout.CENTER);
        String[] columnNames= {"A","B"};//定义表格列名数组
        //定义表格数据数组
        String[][] tableValues= {{"A1","B1"},{"A2","B2"},{"A3","B3"}};
        //创建指定表格列名和表格数据的表格模型
        DefaultTableModel tableModel=new DefaultTableModel(tableValues,columnNames);
        JTable table=new JTable(tableModel);//创建指定表格模型的表格
        table.setRowSorter(new TableRowSorter<>(tableModel));
        scrollPane.setViewportView(table);


        setVisible(true);
    }

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

}

import javax.swing.*;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.TableRowSorter;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.net.URL;


public class Main extends JFrame {
    private DefaultTableModel tableModel;//定义表格模型对象

    private JTable table;//定义表格对象

    private JTextField aTextFied;
    private JTextField bTextFied;

    public Main() {
        setTitle("维护表格模型");
        setBounds(100, 100, 520, 200);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        final JScrollPane scrollPane = new JScrollPane();
        getContentPane().add(scrollPane, BorderLayout.CENTER);
        String[] columnNames = {"A", "B"};//定义表格列名数组
        //定义表格数据数组
        String[][] tableValues = {{"A1", "B1"}, {"A2", "B2"}, {"A3", "B3"}};
        //创建指定表格列名和表格数据的表格模型
        tableModel = new DefaultTableModel(tableValues, columnNames);
        table = new JTable(tableModel);//创建指定表格模型的表格
        table.setRowSorter(new TableRowSorter<>(tableModel));//设置表格的排序器
        //设置表格的选择模式为单选
        table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
        //为表格添加鼠标事件监听器
        table.addMouseListener(new MouseAdapter() {
            public void mouseClicked(MouseEvent e) {//发生了单击事件
                int selectedRow = table.getSelectedRow();//获得被选中行的索引
                //从表格模型中获得指定单元格的值
                Object oa = tableModel.getValueAt(selectedRow, 0);
                //从表格模型中获得指定单元格的值
                Object ob = tableModel.getValueAt(selectedRow, 1);
                aTextFied.setText(oa.toString());//将值赋值给文本框
                bTextFied.setText(ob.toString());//将值赋值给文本框
            }
        });

        scrollPane.setViewportView(table);
        JPanel panel = new JPanel();
        getContentPane().add(panel, BorderLayout.SOUTH);
        panel.add(new JLabel("A:"));
        aTextFied = new JTextField("A4", 10);

        panel.add(aTextFied);
        panel.add(new JLabel("B:"));
        bTextFied = new JTextField("B4", 10);
        panel.add(bTextFied);
        JButton addButton = new JButton("添加");
        addButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                String[] rowValues = {aTextFied.getText(),
                        bTextFied.getText()};//创建表格行数组
                tableModel.addRow(rowValues);//向表格模型中添加一行
                int rowCount = table.getRowCount() + 1;
                aTextFied.setText("A" + rowCount);
                bTextFied.setText("B" + rowCount);
            }
        });

        panel.add(addButton);
        JButton updButton = new JButton("修改");
        updButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                int selectdRow = table.getSelectedRow();//获得被选中行的索引
                if (selectdRow != 1) {//判断是否存在被选中行
                    //修改表格模型中的指定值
                    tableModel.setValueAt(aTextFied.getText(), selectdRow, 0);
                    //修改表格模型中的指定
                    tableModel.setValueAt(bTextFied.getText(), selectdRow, 1);


                }
            }
        });
        panel.add(updButton);
        JButton delButton = new JButton("删除");
        delButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                int selectedRow = table.getSelectedRow();//获得被选中行的索引
                if (selectedRow != -1)//判断是否存在被选中行


                    tableModel.removeRow(selectedRow);//从表格模型中删除指定行
            }
        });

        panel.add(delButton);


    }

    public static void main(String[] args) {
        Main frame = new Main();
        frame.setVisible(true);

    }

}

import javax.swing.*;

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;


public class Main extends JFrame {
    private JButton jb=new JButton("我是按钮，点击我");
    public Main() {
        setLayout(null);
        setSize(200,100);
        setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
        Container cp=getContentPane();
        cp.add(jb);
        jb.setBounds(10,10,150,30);
        jb.addActionListener(new jbAction());
        setVisible(true);


    }
    class jbAction implements ActionListener{
        public void actionPerformed(ActionEvent arg0) {
            jb.setText("我被点击了");
        }
    }
    public static void main(String[] args) {
        new Main();

    }


}

import java.awt.BorderLayout;
import java.awt.EventQueue;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;
import java.awt.Color;
import java.awt.Component;

import javax.swing.JButton;
import java.awt.Font;
import javax.swing.SwingConstants;
import javax.swing.border.TitledBorder;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.util.ArrayList;

import javax.swing.JTextField;

/**
 * 虚拟键盘(键盘的按下与释放)
 */
public class Main extends JFrame { // 创建“键盘”类继承JFrame
    // 声明窗体中的成员组件
    private JPanel contentPane;
    private JTextField textField;
    private JButton btnQ;
    private JButton btnW;
    private JButton btnE;
    private JButton btnR;
    private JButton btnT;
    private JButton btnY;
    private JButton btnU;
    private JButton btnI;
    private JButton btnO;
    private JButton btnP;
    private JButton btnA;
    private JButton btnS;
    private JButton btnD;
    private JButton btnF;
    private JButton btnG;
    private JButton btnH;
    private JButton btnJ;
    private JButton btnK;
    private JButton btnL;
    private JButton btnZ;
    private JButton btnX;
    private JButton btnC;
    private JButton btnV;
    private JButton btnB;
    private JButton btnN;
    private JButton btnM;
    Color green = Color.GREEN;// 定义Color对象，用来表示按下键的颜色
    Color white = Color.WHITE;// 定义Color对象，用来表示释放键的颜色
    Color red=Color.RED;

    ArrayList<JButton> btns = new ArrayList<JButton>();// 定义一个集合，用来存储所有的按键ID
    // 自定义一个方法，用来将容器中的所有JButton组件添加到集合中

    private void addButtons() {
        for (Component cmp : contentPane.getComponents()) {// 遍历面板中的所有组件
            if (cmp instanceof JButton) {// 判断组件的类型是否为JButton类型
                btns.add((JButton) cmp);// 将JButton组件添加到集合中
            }
        }
    }

    /**
     * 主方法
     */
    public static void main(String[] args) {
        EventQueue.invokeLater(new Runnable() { // 使得Runnable中的的run()方法在the system EventQueue的指派线程中被调用
            public void run() {
                try {
                    Main frame = new Main(); // 创建KeyBoard对象
                    frame.setVisible(true); // 使frame可视
                    frame.addButtons();// 初始化存储所有按键的集合
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }

    /**
     * 创建JFrame窗体
     */
    public Main() { // KeyBoard的构造方法
        setTitle("\u865A\u62DF\u952E\u76D8\uFF08\u6A21\u62DF\u952E\u76D8\u7684\u6309\u4E0B\u4E0E\u91CA\u653E\uFF09"); // 设置窗体题目
        setResizable(false); // 不可改变窗体宽高
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // 设置窗体关闭的方式
        setBounds(100, 100, 560, 280); // 设置窗体的位置和宽高
        /**
         * 创建JPanel面板contentPane置于JFrame窗体中，并设置面板的背景色、边距和布局
         */
        contentPane = new JPanel();
        contentPane.setBackground(Color.WHITE);
        contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
        setContentPane(contentPane);
        contentPane.setLayout(null);
        /**
         * 创建按钮button置于面板contentPane中，设置按钮的背景色、位置、宽高以及按钮中的字体位置、内容、样式
         */
        btnQ = new JButton("Q");
        btnQ.setBackground(white);
        btnQ.setVerticalAlignment(SwingConstants.TOP);
        btnQ.setHorizontalAlignment(SwingConstants.LEADING);
        btnQ.setFont(new Font("Times New Roman", Font.PLAIN, 14));
        btnQ.setBounds(0, 60, 47, 45);
        contentPane.add(btnQ);
        /**
         * 创建按钮button_2置于面板contentPane中，设置按钮的背景色、位置、宽高以及按钮中的字体位置、内容、样式
         */
        btnW = new JButton("W");
        btnW.setBackground(white);
        btnW.setVerticalAlignment(SwingConstants.TOP);
        btnW.setHorizontalAlignment(SwingConstants.LEADING);
        btnW.setFont(new Font("Times New Roman", Font.PLAIN, 14));
        btnW.setBounds(55, 60, 49, 45);
        contentPane.add(btnW);
        /**
         * 创建按钮button_3置于面板contentPane中，设置按钮的背景色、位置、宽高以及按钮中的字体位置、内容、样式
         */
        btnE = new JButton("E");
        btnE.setBackground(white);
        btnE.setVerticalAlignment(SwingConstants.TOP);
        btnE.setHorizontalAlignment(SwingConstants.LEADING);
        btnE.setFont(new Font("Times New Roman", Font.PLAIN, 14));
        btnE.setBounds(110, 60, 45, 45);
        contentPane.add(btnE);
        /**
         * 创建按钮button_4置于面板contentPane中，设置按钮的背景色、位置、宽高以及按钮中的字体位置、内容、样式
         */
        btnR = new JButton("R");
        btnR.setBackground(white);
        btnR.setVerticalAlignment(SwingConstants.TOP);
        btnR.setHorizontalAlignment(SwingConstants.LEADING);
        btnR.setFont(new Font("Times New Roman", Font.PLAIN, 14));
        btnR.setBounds(165, 60, 45, 45);
        contentPane.add(btnR);
        /**
         * 创建按钮button_5置于面板contentPane中，设置按钮的背景色、位置、宽高以及按钮中的字体位置、内容、样式
         */
        btnF = new JButton("F");
        btnF.setBackground(white);
        btnF.setVerticalAlignment(SwingConstants.TOP);
        btnF.setHorizontalAlignment(SwingConstants.LEADING);
        btnF.setFont(new Font("Times New Roman", Font.PLAIN, 14));
        btnF.setBounds(195, 125, 45, 45);
        contentPane.add(btnF);
        /**
         * 创建按钮button_6置于面板contentPane中，设置按钮的背景色、位置、宽高以及按钮中的字体位置、内容、样式
         */
        btnD = new JButton("D");
        btnD.setBackground(white);
        btnD.setVerticalAlignment(SwingConstants.TOP);
        btnD.setHorizontalAlignment(SwingConstants.LEADING);
        btnD.setFont(new Font("Times New Roman", Font.PLAIN, 14));
        btnD.setBounds(137, 125, 45, 45);
        contentPane.add(btnD);

        btnT = new JButton("T");
        btnT.setVerticalAlignment(SwingConstants.TOP);
        btnT.setHorizontalAlignment(SwingConstants.LEADING);
        btnT.setFont(new Font("Times New Roman", Font.PLAIN, 14));
        btnT.setBackground(white);
        btnT.setBounds(220, 60, 45, 45);
        contentPane.add(btnT);

        btnY = new JButton("Y");
        btnY.setVerticalAlignment(SwingConstants.TOP);
        btnY.setHorizontalAlignment(SwingConstants.LEADING);
        btnY.setFont(new Font("Times New Roman", Font.PLAIN, 14));
        btnY.setBackground(white);
        btnY.setBounds(275, 60, 45, 45);
        contentPane.add(btnY);

        btnU = new JButton("U");
        btnU.setVerticalAlignment(SwingConstants.TOP);
        btnU.setHorizontalAlignment(SwingConstants.LEADING);
        btnU.setFont(new Font("Times New Roman", Font.PLAIN, 14));
        btnU.setBackground(white);
        btnU.setBounds(330, 60, 45, 45);
        contentPane.add(btnU);

        btnI = new JButton("I");
        btnI.setVerticalAlignment(SwingConstants.TOP);
        btnI.setHorizontalAlignment(SwingConstants.LEADING);
        btnI.setFont(new Font("Times New Roman", Font.PLAIN, 14));
        btnI.setBackground(white);
        btnI.setBounds(385, 60, 45, 45);
        contentPane.add(btnI);

        btnO = new JButton("O");
        btnO.setVerticalAlignment(SwingConstants.TOP);
        btnO.setHorizontalAlignment(SwingConstants.LEADING);
        btnO.setFont(new Font("Times New Roman", Font.PLAIN, 14));
        btnO.setBackground(white);
        btnO.setBounds(440, 60, 46, 45);
        contentPane.add(btnO);

        btnP = new JButton("P");
        btnP.setVerticalAlignment(SwingConstants.TOP);
        btnP.setHorizontalAlignment(SwingConstants.LEADING);
        btnP.setFont(new Font("Times New Roman", Font.PLAIN, 14));
        btnP.setBackground(white);
        btnP.setBounds(495, 60, 45, 45);
        contentPane.add(btnP);

        btnA = new JButton("A");
        btnA.setVerticalAlignment(SwingConstants.TOP);
        btnA.setHorizontalAlignment(SwingConstants.LEADING);
        btnA.setFont(new Font("Times New Roman", Font.PLAIN, 14));
        btnA.setBackground(white);
        btnA.setBounds(23, 125, 45, 45);
        contentPane.add(btnA);

        btnS = new JButton("S");
        btnS.setVerticalAlignment(SwingConstants.TOP);
        btnS.setHorizontalAlignment(SwingConstants.LEADING);
        btnS.setFont(new Font("Times New Roman", Font.PLAIN, 14));
        btnS.setBackground(white);
        btnS.setBounds(82, 125, 45, 45);
        contentPane.add(btnS);

        btnG = new JButton("G");
        btnG.setVerticalAlignment(SwingConstants.TOP);
        btnG.setHorizontalAlignment(SwingConstants.LEADING);
        btnG.setFont(new Font("Times New Roman", Font.PLAIN, 14));
        btnG.setBackground(white);
        btnG.setBounds(251, 125, 45, 45);
        contentPane.add(btnG);

        btnH = new JButton("H");
        btnH.setVerticalAlignment(SwingConstants.TOP);
        btnH.setHorizontalAlignment(SwingConstants.LEADING);
        btnH.setFont(new Font("Times New Roman", Font.PLAIN, 14));
        btnH.setBackground(white);
        btnH.setBounds(306, 125, 45, 45);
        contentPane.add(btnH);

        btnJ = new JButton("J");
        btnJ.setVerticalAlignment(SwingConstants.TOP);
        btnJ.setHorizontalAlignment(SwingConstants.LEADING);
        btnJ.setFont(new Font("Times New Roman", Font.PLAIN, 14));
        btnJ.setBackground(white);
        btnJ.setBounds(361, 125, 45, 45);
        contentPane.add(btnJ);

        btnK = new JButton("K");
        btnK.setVerticalAlignment(SwingConstants.TOP);
        btnK.setHorizontalAlignment(SwingConstants.LEADING);
        btnK.setFont(new Font("Times New Roman", Font.PLAIN, 14));
        btnK.setBackground(white);
        btnK.setBounds(416, 125, 47, 45);
        contentPane.add(btnK);

        btnL = new JButton("L");
        btnL.setVerticalAlignment(SwingConstants.TOP);
        btnL.setHorizontalAlignment(SwingConstants.LEADING);
        btnL.setFont(new Font("Times New Roman", Font.PLAIN, 14));
        btnL.setBackground(white);
        btnL.setBounds(471, 125, 45, 45);
        contentPane.add(btnL);

        btnZ = new JButton("Z");
        btnZ.setVerticalAlignment(SwingConstants.TOP);
        btnZ.setHorizontalAlignment(SwingConstants.LEADING);
        btnZ.setFont(new Font("Times New Roman", Font.PLAIN, 14));
        btnZ.setBackground(white);
        btnZ.setBounds(39, 190, 45, 45);
        contentPane.add(btnZ);

        btnX = new JButton("X");
        btnX.setVerticalAlignment(SwingConstants.TOP);
        btnX.setHorizontalAlignment(SwingConstants.LEADING);
        btnX.setFont(new Font("Times New Roman", Font.PLAIN, 14));
        btnX.setBackground(white);
        btnX.setBounds(107, 190, 45, 45);
        contentPane.add(btnX);

        btnC = new JButton("C");
        btnC.setVerticalAlignment(SwingConstants.TOP);
        btnC.setHorizontalAlignment(SwingConstants.LEADING);
        btnC.setFont(new Font("Times New Roman", Font.PLAIN, 14));
        btnC.setBackground(white);
        btnC.setBounds(178, 190, 45, 45);
        contentPane.add(btnC);

        btnV = new JButton("V");
        btnV.setVerticalAlignment(SwingConstants.TOP);
        btnV.setHorizontalAlignment(SwingConstants.LEADING);
        btnV.setFont(new Font("Times New Roman", Font.PLAIN, 14));
        btnV.setBackground(white);
        btnV.setBounds(250, 190, 45, 45);
        contentPane.add(btnV);

        btnB = new JButton("B");
        btnB.setVerticalAlignment(SwingConstants.TOP);
        btnB.setHorizontalAlignment(SwingConstants.LEADING);
        btnB.setFont(new Font("Times New Roman", Font.PLAIN, 14));
        btnB.setBackground(white);
        btnB.setBounds(315, 190, 45, 45);
        contentPane.add(btnB);

        btnN = new JButton("N");
        btnN.setVerticalAlignment(SwingConstants.TOP);
        btnN.setHorizontalAlignment(SwingConstants.LEADING);
        btnN.setFont(new Font("Times New Roman", Font.PLAIN, 14));
        btnN.setBackground(white);
        btnN.setBounds(382, 190, 47, 45);
        contentPane.add(btnN);

        btnM = new JButton("M");
        btnM.setVerticalAlignment(SwingConstants.TOP);
        btnM.setHorizontalAlignment(SwingConstants.LEADING);
        btnM.setFont(new Font("Times New Roman", Font.PLAIN, 14));
        btnM.setBackground(white);
        btnM.setBounds(449, 190, 48, 45);
        contentPane.add(btnM);
        /**
         * 创建面板panel置于面板contentPane中，设置面板panel的位置、宽高、TitledBorder、背景色以及布局方式（边界布局）
         */
        JPanel panel = new JPanel();
        panel.setBorder(new TitledBorder(null, "文本显示区", TitledBorder.LEADING, TitledBorder.TOP, null, null));
        panel.setBackground(Color.WHITE);
        panel.setBounds(0, 0, 540, 45);
        contentPane.add(panel);
        panel.setLayout(new BorderLayout(0, 0));

        /**
         * 创建文本框textField置于面板panel的中间
         */
        textField = new JTextField();
        textField.addKeyListener(new KeyAdapter() { // 文本框添加键盘事件的监听
            char word;

            @Override
            public void keyPressed(KeyEvent e) { // 按键被按下时被触发
                word = e.getKeyChar();// 获取按下键表示的字符
                for (int i = 0; i < btns.size(); i++) {// 遍历存储按键ID的ArrayList集合
                    // 判断按键是否与遍历到的按键的文本相同
                    if (String.valueOf(word).equalsIgnoreCase(btns.get(i).getText())) {
                        btns.get(i).setBackground(green);// 将指定按键颜色设置为绿色
                    }
                }
            }

            @Override
            public void keyReleased(KeyEvent e) { // 按键被释放时被触发
                word = e.getKeyChar();// 获取释放键表示的字符
                for (int i = 0; i < btns.size(); i++) {// 遍历存储按键ID的ArrayList集合
                    // 判断按键是否与遍历到的按键的文本相同
                    if (String.valueOf(word).equalsIgnoreCase(btns.get(i).getText())) {
                        btns.get(i).setBackground(red);// 将指定按键颜色设置为白色
                    }
                }
            }
        });
        panel.add(textField, BorderLayout.CENTER);
        textField.setColumns(10);
    }
}

运行结果：

public void mouseEntered(MouseEvent e):光标移入组件时被触发
public void mousePressed(MouseEvent e):鼠标按键被按下时被触发
public void mouseReleased(MouseEvent e):鼠标按键被释放时被触发
public void mouseClicked(MouseEvent e):发生单机事件时被触发
public void mouseExited(MouseEvent e):光标移出组件时被触发

分别代表：左键、滚轮和右键。

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

public class Main extends JFrame {
    public static void main(String args[]) {
        Main frame = new Main();
        frame.setVisible(true); // 设置窗体可见，默认为不可见
    }

    /**
     * 判断按下的鼠标键，并输出相应提示
     *
     * @param e 鼠标事件
     */
    private void mouseOper(MouseEvent e) {
        int i=e.getButton();
        if(i==MouseEvent.BUTTON1)
            System.out.println("按下的是鼠标左键");
        else if (i==MouseEvent.BUTTON2)
            System.out.println("按下的是鼠标滚轮");
        else if(i==MouseEvent.BUTTON3)
            System.out.println("按下的是鼠标右键");

    }

    public Main() {
        super(); // 继承父类的构造方法
        setTitle("鼠标事件示例"); // 设置窗体的标题
        setBounds(100, 100, 500, 375); // 设置窗体的显示位置及大小
        // 设置窗体关闭按钮的动作为退出
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        final JLabel label = new JLabel();
        label.addMouseListener(new MouseListener() {
            public void mouseEntered(MouseEvent e) {
                System.out.println("光标移入组件");
            }
            public void mousePressed (MouseEvent e) {
                System.out.println("鼠标按键被按下");
                mouseOper(e);
            }
            public void mouseReleased (MouseEvent e) {
                System.out.println("鼠标按键被释放");
                mouseOper(e);
            }
            public void mouseClicked (MouseEvent e) {
                System.out.println("单击了鼠标按键");
                mouseOper(e);
                int clickCount=e.getClickCount();
                System.out.println("单击次数为"+clickCount+"下");
            }
            public void mouseExited(MouseEvent e) {
                System.out.println("光标移出组件");
            }
        });
        getContentPane().add(label, BorderLayout.CENTER);
    }

}

运行结果：

public class Mian{
    public static void main(String[] args) {
        JFrame jf=new JFrame("wuhu");
        jf.setSize(500,500);

        jf.add(new MyPanel());

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

class MyPanel extends JPanel { // 定义一个名为 MyPanel 的类，继承自 JPanel 类，用于绘制图形

    public void paintComponent(Graphics g) { // 重写 JPanel 类中的 paintComponent 方法，用于绘制图形
        super.paintComponent(g); // 调用父类的 paintComponent 方法，进行默认的界面绘制

        // 获取 Graphics 对象并强制转换为 Graphics2D 对象
        Graphics2D g2d = (Graphics2D) g;

        // 设置绘图颜色为红色
        g2d.setColor(Color.RED);

        // 设置线条粗细为 2f
        g2d.setStroke(new BasicStroke(2f));

        // 绘制一个填充的矩形，左上角坐标为 (50,50)，宽度为 100，高度为 100，填充颜色为红色
        g2d.fillRect(50, 50, 100, 100);

        // 设置绘图颜色为黑色
        g2d.setColor(Color.BLACK);

        // 设置字体为 Arial 字体，字号为 24
        g2d.setFont(new Font("Arial", Font.PLAIN, 24));

        // 绘制文本，文本内容为 "Hello World!"，左上角坐标为 (100,150)
        g2d.drawString("Hello World!", 100, 150);
    }
}

setStroke(Stroke stroke);

运行结果：

运行结果：

package demo_1;
import java.awt.*;
import java.io.*;
import javax.imageio.ImageIO;
import javax.swing.*;
import javax.swing.event.*;
public class text_1 extends JFrame {
    Image img;
    private int W,H;
    private JSlider jSlider;

    public text_1() {
        try {
            img=ImageIO.read(new File("img/down.png"));//读取图片

        }catch(IOException e) {
            e.printStackTrace();
        }
        CanvasPanel can=new CanvasPanel();
        jSlider=new JSlider();
        jSlider.setMaximum(1000);
        jSlider.setValue(100);
        jSlider.setMinimum(1);
        jSlider.addChangeListener(new ChangeListener() {
            public void stateChanged(ChangeEvent e) {
                can.repaint();

            }
        });
        JPanel center=new JPanel();
        center.setLayout(new BorderLayout());
        center.add(jSlider,BorderLayout.SOUTH);
        center.add(can,BorderLayout.CENTER);
        setContentPane(center);
        setBounds(100,100,800,600);//窗体大小
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//关闭模式
        setTitle("绘制图片");

    }
    class CanvasPanel extends JPanel{
        public void paint(Graphics g) {
            int newW=0,newH=0;
            W=img.getWidth(this);//获取图片宽度
            H=img.getHeight(this);//获取图片高度
            float value=jSlider.getValue();//滑块组件的取值
            newW=(int)(W*value/100);//计算图片放大后的宽度
            newH=(int)(H*value/100);//计算图片放大后的高度
            g.drawImage(img,0,0,newW,newH,this);//绘制指定大小的图片

        }
    }
    public static void main(String[] args) {
        new text_1().setVisible(true);

    }

}

package demo_1;

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.*;
import javax.imageio.ImageIO;
import javax.swing.*;
import javax.swing.event.*;


public class text_1 extends JFrame {
    private Image img;
    private int dx1,dy1,dx2,dy2;
    private int sx1,sy1,sx2,sy2;
    private int W=300,H=200;
    private JButton v=null;
    private JButton h=null;
    private CanvasPanel canvasPanel=null;
    public text_1() {
        try {
            img=ImageIO.read(new File("img/left.png"));
        }catch(IOException e) {
            e.printStackTrace();
        }
        dx2=sx2=W;
        dy2=sy2=H;
        v=new JButton("垂直旋转");
        h=new JButton("水平翻转");
        JPanel botton=new JPanel();
        botton.add(h);
        botton.add(v);
        Container c=getContentPane();
        c.add(botton,BorderLayout.SOUTH);
        canvasPanel =new CanvasPanel();
        c.add(canvasPanel,BorderLayout.CENTER);

        addListener();

        setBounds(100,100,300,260);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setTitle("图片翻转");

    }
    private void addListener() {
        v.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                sy1=Math.abs(sy1-H);
                sy2=Math.abs(sy2-H);
                canvasPanel.repaint();
            }
        });
        h.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                sx1=Math.abs(sx1-W);
                sx2=Math.abs(sx2-W);
                canvasPanel.repaint();
            }

        });
    }
    class CanvasPanel extends JPanel{
        public void paint(Graphics g) {
            g.drawImage(img, dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2, this);
        }
    }
    public static void main(String[] args) {
        new text_1().setVisible(true);

    }

}

package demo_1;

import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class text_1 extends JFrame {
    private Image img;
    private text_1() {
        try {
            img=ImageIO.read(new File("img/right.png"));//读取图片

        }catch(IOException e) {
            e.printStackTrace();
        }
        setBounds(100,100,400,350);//设置窗体大小
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//设置关闭模式
        setTitle("图片旋转");//设置窗体标题
        add(new CanvasPanel());
    }
    class CanvasPanel extends JPanel{
        public void paint(Graphics g) {
            Graphics2D g2=(Graphics2D) g;
            g2.rotate(Math.toRadians(5));//旋转5°,传入的是弧度值
            g2.drawImage(img, 70, 10, 300, 200, this);
            g2.rotate(Math.toRadians(5));
            g2.drawImage(img, 70, 10, 300, 200, this);
            g2.rotate(Math.toRadians(5));
            g2.drawImage(img, 70, 10, 300, 200, this);

        }
    }
    public static void main(String[] args) {
        new text_1().setVisible(true);

    }

}

package demo_1;

import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class text_1 extends JFrame{
    private Image img;
    public text_1() {
        try {
            img=ImageIO.read(new File("img/cell.png"));//读取图片

        }catch(IOException e) {
            e.printStackTrace();
        }

        setBounds(100,100,400,300);//窗体大小
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//关闭模式
        setTitle("图片倾斜");//窗体标题
        add(new CanvasPanel());
    }
    class CanvasPanel extends JPanel{
        public void paint(Graphics g) {
            Graphics2D g2=(Graphics2D)g;
            g2.shear(0.3,0);//倾斜30%
            g2.drawImage(img,0,0,300,200,this);
        }
    }
    public static void main(String[] args) {
        new text_1().setVisible(true);

    }

}

1、继承性：Thread类是java.lang.Object的子类，因此可以继承Object类的属性和方法。
2、抽象性：Thread类是一个抽象类，这意味着它不能直接实例化。为了使用Thread类，我们需要创建一个Thread的子类，并重写其run()方法。
3、线程安全性：Thread类是线程安全的，这意味着多个线程可以同时调用Thread类的方法，而不会导致数据不一致或其他并发问题。
4、常用方法：Thread类有许多有用的方法，包括start()（启动线程）、run()（执行线程）、sleep()（使线程休眠）、interrupt()（中断线程）等。

public class MyThread extends Thread {  
    @Override  
    public void run() {  
        // 在这里编写线程需要执行的代码  
        System.out.println("My thread is running.");  
    }  
}

public class demo_1 {
    public static void main(String[] args) {
        /*
            实现方式：1
            自定义一个类继承Thread、或者构建Thread对象，重写run方法
            重写run方法
            启动线程
        */
        MyThread t1=new MyThread();
        MyThread t2=new MyThread();
        
        // 为线程指定名字
        t1.setName("线程一");  
        t2.setName("线程二");
    
        t1.start(); // 开启线程
        t2.start(); // 开启线程
    }
}
class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(getName()+ "芜湖");
        }
    }
}

1、自定义一个类实现Runnable接口
2、重写run方法，
3、创建自己类的对象，
4、创建Thread对象开启线程

package text_1;

public class demo_2 {
    public static void main(String[] args) {
        /*
        *   第二种实现方式：
        *   自定义一个类实现Runnable接口
        *   重写run方法，
        *   创建自己类的对象，
        *   创建Thread对象开启线程
        *
        * */
        MyRun mr=new MyRun();

        Thread t1=new Thread(mr);
        Thread t2=new Thread(mr);

        t1.setName("芜湖");
        t2.setName("呀呼");

        t1.start();
        t2.start();
    }
}
class MyRun implements Runnable{
    @Override
    public void run() {
        Thread thread = Thread.currentThread(); // 获取当前线程的对象
        for (int i = 0; i < 10; i++) {
            System.out.println(thread.getName()+ "爱坤");
        }
    }
}

只所以能通过这中方式创建线程，是因为Thread类就是Runnable接口的实现类。

package text_2;

public class demo_1 {
    public static void main(String[] args) {
        MyThread mt1 = new MyThread();
        mt1.start();
    }
}

class MyThread extends Thread{
    @Override
    public void run() {

        for (int i = 0; i < 10; i++) {
            try {
                // 以毫秒为单位
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("芜湖");
        }
    }
}

在Java多线程编程中，join方法是一个非常重要的概念。它用于确保主线程等待其他线程完成其任务后再继续执行。当一个线程调用另一个线程的join方法时，调用线程会阻塞，直到被调用线程结束执行。

join方法通常在创建线程时使用，以确保主线程不会在子线程完成前结束。这有助于防止数据竞争和其他并发问题。

示例：

运行结果：

package text_3;

public class demo {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();

        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");

        t1.start();
        t2.start();
        t3.start();
    }
}

class MyThread extends Thread {
    static int ticket = 0;
    @Override
    public void run() {
        while (true) {
            // 同步线程：线程锁（锁对象） 需要注意的是锁对象一定是要唯一的
            synchronized (MyThread.class) {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (ticket < 100) {
                    ++ticket;
                    System.out.println(getName() + "正在卖第" + ticket + "张票");
                } else {
                    break;
                }
            }
        }
    }
}

传输控制协议（TCP）
用户数据报协议（UDP）

import java.net.*;
 
public class Demo21_1 {
 
 public static void main(String[] args) {
  InetAddress ip;//创建InetAddress对象
 
   try {//捕捉异常
    ip=InetAddress.getLocalHost();//实例化对象
    String ming=ip.getHostName();//获取本机名
    String dizi=ip.getHostAddress();//获取本机地址
    System.out.println("本机名："+ming);//输出本机名
    System.out.println("本机IP地址："+dizi);//将本机IP地址输出
   } catch (UnknownHostException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();//输出异常
   }
  
 
 }
 
}

ServerSocket(): 创建非绑定服务器套接字。
ServerSocket(int port): 创建绑定到特定端口的服务器套接字。
ServerSocket(int port,int backlog): 利用指定的 backlog 创建服务器套接字，并将其绑定到指定的本地端口号上。
ServerSocket(int port,int backlog,InetAddress bindAddress): 使用指定的端口、侦听 backlog 和要绑定到的本地 IP 地址创建服务器。这种情况适用于计算机上有多块网卡和多个IP 地址的情况，用户可以明确规定 ServerSocket 在哪块网卡或哪个 IP 地址上等待客户的连接请求。

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
 
public class Demo21_2 {
 private ServerSocket s;//服务器套接字
 private Socket sk;//客户端套接字
 void start() {//启动服务器
  try {
   s=new ServerSocket(8998);//服务器启用8998端口
   System.out.println("服务器套接字已经创建成功");
   while(true) {
    System.out.println("等待客户机的接入");
    sk=s.accept();//监听客户机的连接
    BufferedReader r=new BufferedReader(new InputStreamReader(sk.getInputStream()));
    while(true) {//循环接收信息
     String m=r.readLine();//读取一行文本
     if("退出".equals(m)) {//如果客户机发来的内容为退出
      System.out.println("客户机退出");
      break;//停止接收信息
     }
     System.out.println("客户机"+m);
     
    }
    r.close();//关闭流
    sk.close();//关闭套接字
   }
  }catch(IOException e) {
   e.printStackTrace();
  }
 }
 public static void main(String[] args) {
  Demo21_2 tcp=new Demo21_2();
  tcp.start();//启动服务器
 
 }
 
}

import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.IOException;
import java.io.PrintWriter;
import java.net.Socket;
 
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;
 
public class Demo21_2_2 extends JFrame{
  private PrintWriter w;//字符输出流
   Socket s;//客户端套接字
  private JTextArea area=new JTextArea();//文本域
  private JTextField text=new JTextField();//文本框
  public Demo21_2_2() {
   setTitle("向服务器送数据");
   setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
   Container c=getContentPane();//主容器
   JScrollPane scrollPane=new JScrollPane(area);//滚动面板
   getContentPane().add(scrollPane,BorderLayout.CENTER);
   c.add(text,"South");//将文本框放到窗体下部
   text.addActionListener(new ActionListener() {//文本框触发回车事件
    public void actionPerformed(ActionEvent e) {
     w.println(text.getText().trim());//将文本框的信息写入流
     area.append(text.getText()+"\n");//将文本框的信息显示在文本域中
     text.setText("");//将文本框清空
    }
   });
  }
  public void c() {//连接服务器方法
   area.append("尝试连接\n");//文本域中提示信息
   try {
    s=new Socket("127.0.0.1",8998);//连接本地计算机的端口8998
    w=new PrintWriter(s.getOutputStream(),true);
    area.append("完成连接\n");
   }catch(IOException e) {
    e.printStackTrace();
   }
  }
  
 public static void main(String[] args) {
  Demo21_2_2 c=new Demo21_2_2();
  c.setSize(200, 200);//窗体大小
  c.setVisible(true);//是否显示
  c.c();//连接服务器
 
 }
 
}

发送数据部分：

接收数据部分：