jb_reset.setText("\u91cd\u7f6e"); jb_reset.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent evt) { jb_resetActionPerformed(evt); } })

这段代码是Java Swing中的一个按钮组件的定义和事件处理。其中`\u91cd\u7f6e`表示“重置”两个汉字的Unicode编码，用于设置按钮上的文本。`jb_reset`是该按钮的名称。`addActionListener()`方法用于为按钮添加一个监听器，即当用户点击该按钮时，会调用`jb_resetActionPerformed()`方法进行响应处理。

需要注意的是，该代码片段只是一个按钮的定义和事件处理，不能独立运行。在使用该代码时，需要将按钮添加到一个容器中才能够正常显示。此外，在实际使用中，需要根据具体需求来实现`jb_resetActionPerformed()`方法的具体逻辑。

相关问题

java钢琴_Java swing实现支持录音等功能的钢琴程序

Java Swing是一种基于Java语言的图形用户界面(GUI)工具包。使用Java Swing，可以轻松地创建各种GUI应用程序，包括钢琴程序。以下是一个简单的Java Swing钢琴程序示例，支持录音等功能。

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

public class Piano extends JFrame implements ActionListener {
    private static final long serialVersionUID = 1L;

    private JButton[] whiteKeys = new JButton[7];
    private JButton[] blackKeys = new JButton[5];
    private JButton recordButton;
    private JButton playButton;
    private JButton stopButton;
    private boolean isRecording = false;
    private boolean isPlaying = false;
    private Sequence sequence;
    private Sequencer sequencer;
    private Track track;
    private int currentTick;
    private ByteArrayOutputStream byteArrayOutputStream;
    private AudioFormat audioFormat;
    private TargetDataLine targetDataLine;
    private AudioInputStream audioInputStream;
    private byte[] audioData;

    public Piano() {
        setTitle("Java Piano");
        setSize(800, 300);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        setLayout(new BorderLayout());

        JPanel keyboardPanel = new JPanel();
        keyboardPanel.setLayout(new GridLayout(1, 0));

        // Add white keys
        String[] whiteNotes = {"C", "D", "E", "F", "G", "A", "B"};
        for (int i = 0; i < 7; i++) {
            whiteKeys[i] = new JButton(whiteNotes[i]);
            whiteKeys[i].setPreferredSize(new Dimension(80, 200));
            whiteKeys[i].addActionListener(this);
            keyboardPanel.add(whiteKeys[i]);
        }

        // Add black keys
        String[] blackNotes = {"C#", "D#", "", "F#", "G#", "A#"};
        for (int i = 0; i < 6; i++) {
            if (i != 2) {
                blackKeys[i] = new JButton(blackNotes[i]);
                blackKeys[i].setPreferredSize(new Dimension(50, 120));
                blackKeys[i].setBackground(Color.BLACK);
                blackKeys[i].setOpaque(true);
                blackKeys[i].addActionListener(this);
                keyboardPanel.add(blackKeys[i]);
            }
        }

        // Add record, play, and stop buttons
        JPanel controlPanel = new JPanel();
        controlPanel.setLayout(new FlowLayout());

        recordButton = new JButton("Record");
        recordButton.addActionListener(this);
        controlPanel.add(recordButton);

        playButton = new JButton("Play");
        playButton.addActionListener(this);
        controlPanel.add(playButton);

        stopButton = new JButton("Stop");
        stopButton.addActionListener(this);
        controlPanel.add(stopButton);

        add(keyboardPanel, BorderLayout.CENTER);
        add(controlPanel, BorderLayout.SOUTH);

        setVisible(true);
    }

    public void actionPerformed(ActionEvent e) {
        if (e.getSource() == recordButton) {
            if (!isRecording) {
                isRecording = true;
                recordButton.setText("Stop Recording");
                startRecording();
            } else {
                isRecording = false;
                recordButton.setText("Record");
                stopRecording();
            }
        } else if (e.getSource() == playButton) {
            if (!isPlaying) {
                isPlaying = true;
                playButton.setText("Stop Playing");
                startPlaying();
            } else {
                isPlaying = false;
                playButton.setText("Play");
                stopPlaying();
            }
        } else {
            JButton button = (JButton) e.getSource();
            String note = button.getText();
            playSound(note);
            if (isRecording) {
                addNoteToSequence(note);
            }
        }
    }

    private void startRecording() {
        try {
            audioFormat = getAudioFormat();
            DataLine.Info dataLineInfo = new DataLine.Info(TargetDataLine.class, audioFormat);
            targetDataLine = (TargetDataLine) AudioSystem.getLine(dataLineInfo);
            targetDataLine.open(audioFormat);
            targetDataLine.start();

            byteArrayOutputStream = new ByteArrayOutputStream();
            audioData = new byte[1024];

            new Thread(new Runnable() {
                public void run() {
                    while (isRecording) {
                        int numBytesRead = targetDataLine.read(audioData, 0, audioData.length);
                        byteArrayOutputStream.write(audioData, 0, numBytesRead);
                    }
                }
            }).start();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    private void stopRecording() {
        try {
            targetDataLine.stop();
            targetDataLine.close();
            byteArrayOutputStream.close();

            byte[] byteArray = byteArrayOutputStream.toByteArray();
            ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArray);
            audioInputStream = new AudioInputStream(byteArrayInputStream, audioFormat, byteArray.length / audioFormat.getFrameSize());

            // Convert audio data to MIDI sequence
            AudioToMidiConverter converter = new AudioToMidiConverter();
            sequence = converter.convert(audioInputStream);

            // Create new track to add notes to
            sequencer = MidiSystem.getSequencer();
            sequencer.open();
            sequence.deleteTrack(sequence.getTracks()[0]);
            track = sequence.createTrack();
            currentTick = 0;
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    private void startPlaying() {
        try {
            sequencer.setSequence(sequence);
            sequencer.start();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    private void stopPlaying() {
        sequencer.stop();
        sequencer.close();
    }

    private void addNoteToSequence(String note) {
        try {
            int velocity = 127;
            int duration = 100;
            int pitch = getMidiPitch(note);
            ShortMessage messageOn = new ShortMessage(ShortMessage.NOTE_ON, 0, pitch, velocity);
            track.add(new MidiEvent(messageOn, currentTick));
            currentTick += duration;
            ShortMessage messageOff = new ShortMessage(ShortMessage.NOTE_OFF, 0, pitch, velocity);
            track.add(new MidiEvent(messageOff, currentTick));
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    private void playSound(String note) {
        try {
            Synthesizer synthesizer = MidiSystem.getSynthesizer();
            synthesizer.open();
            MidiChannel[] channels = synthesizer.getChannels();
            int velocity = 127;
            int pitch = getMidiPitch(note);
            channels[0].noteOn(pitch, velocity);
            Thread.sleep(100);
            channels[0].noteOff(pitch, velocity);
            synthesizer.close();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    private int getMidiPitch(String note) {
        String[] notes = {"C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"};
        int[] pitches = {60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71};
        for (int i = 0; i < notes.length; i++) {
            if (note.equals(notes[i])) {
                return pitches[i];
            }
        }
        return 0;
    }

    private AudioFormat getAudioFormat() {
        float sampleRate = 44100.0F;
        int sampleSizeInBits = 16;
        int channels = 1;
        boolean signed = true;
        boolean bigEndian = false;
        return new AudioFormat(sampleRate, sampleSizeInBits, channels, signed, bigEndian);
    }

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

这个程序使用Java Swing创建了一个钢琴界面，包括白键和黑键。它还包括三个按钮：录音，播放和停止。当用户按下一个键时，程序将播放相应的音符，并且如果正在录音，则将该音符添加到MIDI序列中。当用户按下录音按钮时，程序开始录制音频，并将其转换为MIDI序列。当用户按下播放按钮时，程序将播放MIDI序列中的音符。

java文件 记事本_[源码和文档分享]基于JAVA的记事本

以下是基于Java的记事本的源代码和文档：

源代码：

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

public class Notepad extends Frame implements ActionListener
{
    // Text component
    TextArea t;

    // Frame
    Frame f;

    // Constructor
    Notepad()
    {
        f = new Frame("Notepad");

        try {
            // Set theme
            UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
        }
        catch (Exception e) {
            System.err.println(e.getMessage());
        }

        // Text component
        t = new TextArea();

        // Create menu bar
        MenuBar mb = new MenuBar();

        // Create menu
        Menu m1 = new Menu("File");

        // Create menu items
        MenuItem mi1 = new MenuItem("New");
        MenuItem mi2 = new MenuItem("Open");
        MenuItem mi3 = new MenuItem("Save");
        MenuItem mi4 = new MenuItem("Print");

        // Add action listener
        mi1.addActionListener(this);
        mi2.addActionListener(this);
        mi3.addActionListener(this);
        mi4.addActionListener(this);

        // Add menu items to menu
        m1.add(mi1);
        m1.add(mi2);
        m1.add(mi3);
        m1.add(mi4);

        // Create menu
        Menu m2 = new Menu("Edit");

        // Create menu items
        MenuItem mi5 = new MenuItem("Cut");
        MenuItem mi6 = new MenuItem("Copy");
        MenuItem mi7 = new MenuItem("Paste");

        // Add action listener
        mi5.addActionListener(this);
        mi6.addActionListener(this);
        mi7.addActionListener(this);

        // Add menu items to menu
        m2.add(mi5);
        m2.add(mi6);
        m2.add(mi7);

        // Create menu
        Menu m3 = new Menu("Help");

        // Create menu item
        MenuItem mi8 = new MenuItem("About Notepad");

        // Add action listener
        mi8.addActionListener(this);

        // Add menu item to menu
        m3.add(mi8);

        // Add menu to menu bar
        mb.add(m1);
        mb.add(m2);
        mb.setHelpMenu(m3);

        // Set menu bar to frame
        f.setMenuBar(mb);

        // Set text area to frame
        f.add(t);

        // Set size of frame
        f.setSize(500, 500);

        // Show frame
        f.show();
    }

    // If a button is pressed
    public void actionPerformed(ActionEvent e)
    {
        String s = e.getActionCommand();

        if (s.equals("Cut")) {
            t.cut();
        }
        else if (s.equals("Copy")) {
            t.copy();
        }
        else if (s.equals("Paste")) {
            t.paste();
        }
        else if (s.equals("Save")) {
            // Create object of JFileChooser class
            FileDialog fd = new FileDialog(f, "Save", FileDialog.SAVE);
            fd.setVisible(true);

            // Get file name and directory
            String fileName = fd.getFile();
            String directory = fd.getDirectory();

            try {
                // Create file writer object
                FileWriter fw = new FileWriter(directory + fileName);

                // Write content to file
                fw.write(t.getText());

                // Close file writer
                fw.close();
            }
            catch (Exception ex) {
                System.err.println(ex.getMessage());
            }
        }
        else if (s.equals("Print")) {
            try {
                // Print text
                t.print();
            }
            catch (Exception ex) {
                System.err.println(ex.getMessage());
            }
        }
        else if (s.equals("Open")) {
            // Create object of JFileChooser class
            FileDialog fd = new FileDialog(f, "Open", FileDialog.LOAD);
            fd.setVisible(true);

            // Get file name and directory
            String fileName = fd.getFile();
            String directory = fd.getDirectory();

            try {
                // Create file reader object
                FileReader fr = new FileReader(directory + fileName);

                // Read content from file
                int i;
                String s1 = "";

                while ((i = fr.read()) != -1) {
                    s1 += (char)i;
                }

                t.setText(s1);

                // Close file reader
                fr.close();
            }
            catch (Exception ex) {
                System.err.println(ex.getMessage());
            }
        }
        else if (s.equals("New")) {
            t.setText("");
        }
        else if (s.equals("About Notepad")) {
            // Create object of About class
            About a = new About();
        }
    }

    public static void main(String args[])
    {
        Notepad n = new Notepad();
    }
}

// About class
class About extends Dialog implements ActionListener
{
    // Constructor
    About()
    {
        // Create frame
        Frame f = new Frame();

        // Set title
        setTitle("About Notepad");

        // Set modal
        setModal(true);

        // Create label
        Label l = new Label("Notepad 1.0");

        // Create OK button
        Button b = new Button("OK");

        // Add action listener
        b.addActionListener(this);

        // Create panel
        Panel p = new Panel();

        // Add label and button to panel
        p.add(l);
        p.add(b);

        // Add panel to dialog
        add(p);

        // Set size of dialog
        setSize(300, 100);

        // Show dialog
        show();
    }

    // If OK button is pressed
    public void actionPerformed(ActionEvent e)
    {
        dispose();
    }
}

文档：

基于Java的记事本

1. 简介

基于Java的记事本是一个基本的文本编辑器，它允许用户打开、编辑、保存和打印文本文件。该应用程序使用Java编写，并具有跨平台性。

2. 功能

基于Java的记事本具有以下功能：

a) 新建文件。该功能允许用户创建一个新文件。

b) 打开文件。该功能允许用户打开一个现有的文件。

c) 保存文件。该功能允许用户将当前文件保存到硬盘上。

d) 打印文件。该功能允许用户打印当前文件。

e) 剪切、复制和粘贴。这些功能允许用户在文本中执行常见的编辑操作。

f) 关于记事本。该功能提供有关应用程序的一些基本信息。

3. 实现

基于Java的记事本由以下几个组件组成：

a) Frame：这是主窗口，它包含菜单栏和文本区域。

b) TextArea：这是用于编辑文本的区域。

c) MenuBar：这是菜单栏，它包括File、Edit和Help菜单。

d) Menu：这是菜单，它包括各种菜单项。

e) MenuItem：这是菜单项，它执行各种操作。

f) ActionListener：这是一个接口，它处理用户的操作。

4. 操作

以下是基于Java的记事本的操作：

a) 新建文件 - 单击File菜单，然后单击New菜单项。如果当前文件未保存，则提示用户保存文件。

b) 打开文件 - 单击File菜单，然后单击Open菜单项。选择要打开的文件，然后单击打开按钮。

c) 保存文件 - 单击File菜单，然后单击Save菜单项。选择要保存的位置和文件名，然后单击保存按钮。

d) 打印文件 - 单击File菜单，然后单击Print菜单项。选择打印机，然后单击打印按钮。

e) 剪切、复制和粘贴 - 选择要编辑的文本，然后单击Edit菜单。选择Cut、Copy或Paste菜单项，然后执行相应的操作。

f) 关于记事本 - 单击Help菜单，然后单击About Notepad菜单项。

5. 结论

基于Java的记事本是一个简单而实用的文本编辑器。它提供了常见的文件操作和编辑功能，并具有跨平台性。